Follow me on Twitter RSS FEED

Calcolatrice in C#

Posted in By Joker 0 commenti

Da qualche giorno mi stò dedicando alprogetto di una calcolatrice in C#.

Per adesso mi sono fermatopiù sulla grafica che sul codice, ma ci stò ragionando sopra.
 
Ho guardato su you tube per vedere se trovavo qualche suggerimento interessante su come impostare il codice e ho trovato questo interessante video, non è niente di speciale, ma per chi è agli inizi come me tornerà sicuramente utile.


Esercizio sull'ereditarietà in C++

Posted in By Joker 0 commenti

Nota: Definizioni tratte dal sito http://www.bo.cnr.it/corsi-di-informatica/corsoCstandard/Lezioni/31Eredita.html

Esistono tre specificatori:
private: (default) indica che tutti i membri seguenti sono privati, e non possono essere ereditati;
public: indica che tutti i membri seguenti sono pubblici, e possono essere ereditati;
protected: indica che tutti i membri seguenti sono protetti, nel senso che sono privati, ma possono essere ereditati;
L'accessibilità dei membri ereditati da una classe base dipende anche dallo "specificatore di accesso alla classe base", che deve essere indicato come nel seguente esempio:

          class Figlio : spec.di accesso Padre  {  ........  } ;
 
dove spec.di accesso può essere: private (default), protected o public (notare l'assenza dei due punti). Ogni membro ereditato avrà l'accesso più "restrittivo" fra il proprio originario e quello indicato dallo specificatore di accesso alla classe base, come è chiarito dalla seguente tabella http://www.bo.cnr.it/corsi-di-informatica/corsoCstandard/Lezioni/31Eredita.html:




Quindi un membro ereditato è pubblico solo se è public nella classe base e l'accesso della classe derivata alla classe base è public.
Se una classe derivata è a sua volta genitrice di una nuova classe, in quest'ultima l'accesso ai membri ereditati è governato dalle stesse regole, che vengono però applicate esclusivamente ai membri della classe "intermedia", indipendentemente da come questi erano nella classe base. In altre parole, ogni classe "vede" la sua diretta genitrice, e non si preoccupa degli altri eventuali "ascendenti".
Normalmente l'accesso alla classe base è public. In alcune circostanze, tuttavia, si può volere che i suoi membri pubblici e protetti, ereditati nella classe derivata, siano accessibili unicamente da funzioni membro e friend della classe derivata stessa: in questo caso, occorre che lo specificatore di accesso alla classe base sia private; analogamente, se si vuole che i membri pubblici e protetti di una classe base siano accessibili unicamente da funzioni membro e friend della classe derivata e di altre eventuali classi derivate da questa,  occorre che lo specificatore di accesso alla classe base sia protected
Esercizio
Creo una sopraclasse di nome Padre e tre sottoclassi di nome Figlio, ognuna di queste sottoclassi però erediterà in modo diverso i membri e gli attributi della classe Padre.   


#include <cstdlib>
#include <iostream>


using namespace std;


class Padre {
public:
int a,b;
int Addizione(){return a+b;};
};


class FiglioPubblico:public Padre {
public:
int Addizione(){return a+b;};
int Sottrazione(){return a-b;};


};


class FiglioPrivato:private Padre {
public:
int Addizione(){return a+b;};
int Sottrazione(){return a-b;};


};


class FiglioProtetto:protected Padre {
public:
int Addizione(){return a+b;};
int Sottrazione(){return a-b;};


};


int main(int argc, char *argv[])
{
FiglioPubblico pubb;
FiglioPrivato priv;
FiglioProtetto prot;


cout<<"Pubblico"<<endl;
cout<<"Inserire a: ";
cin>>pubb.a;
cout<<"Inserire b: ";
cin>>pubb.b;


cout<<"Addizione = "<<pubb.Addizione()<<endl;
cout<<"Sottrazione = "<<pubb.Sottrazione()<<endl;


/*cout<<"Privato"<<endl;
cout<<"Inserire a: ";
cin>>priv.a;
cout<<"Inserire b: ";
cin>>priv.b;


cout<<"Addizione = "<<priv.Addizione()<<endl;
cout<<"Sottrazione = "<<priv.Sottrazione()<<endl;*/


/*cout<<"Protetto"<<endl;
cout<<"Inserire a: ";
cin>>prot.a;
cout<<"Inserire b: ";
cin>>prot.b;


cout<<"Addizione = "<<prot.Addizione()<<endl;
cout<<"Sottrazione = "<<prot.Sottrazione()<<endl;*/




system("PAUSE");
return EXIT_SUCCESS;
}


Ecco il risultato del primo test:
Nel primo test utilizzo lo specificatore public per ereditare dal Padre i suoi membri a e b e il metodo Addizione( ).
Ecco cosa mi compare sullo schermo:
 
Ecco il risultato del secondo test:
Nel secondo test utilizzo lo specificatore private per ereditare dal Padre i suoi membri a e b e il metodo Addizione( ).
Ecco cosa mi compare sullo schermo:



Ecco il risultato del terzo test:
Nel terzo test utilizzo lo specificatore protected per ereditare dal Padre i suoi membri a e b e il metodo Addizione( ).
Ecco cosa mi compare sullo schermo:

L'ereditarietà in C++

Posted in By Joker 0 commenti

L'ereditarietà è la capacità di riutilizzare le componenti (membri e attributi) della classe base in quella derivata.
                                      es. class Figlio : Padre  {  ........  } ;

L'esempio indica che la classe derivata Figlio possiede, oltre ai menbri elencati nella propria definizione, anche quelli ereditati dalla classe base Padre.

La classe che è stata derivata da un'altra usando l'ereditarietà è detta sottoclasse mentre la classe genitrice è detta sopraclasse

La nuova classe si differenzia dalla sopraclasse in due modi:
per estensione, quando la sottoclasse aggiunge nuovi attributi e/o metodi che si sommano a quelli ereditati;
per ridefinizione, quando la sottoclasse ridefinisce i metodi ereditati.

Esistono due tipi di ereditarietà: singola e multipla.
L'ereditarietà singola si verifica quando una sottoclasse deriva da un'unica sopraclasse.


L'ereditarietà multipla si verifica quando da una sottoclasse derivano due o più sopraclassi.


Si tratta di un vero e proprio riciclo del codice, poichè quanto già scritto e collaudato è incapsulato nella sopraclasse (classe Padre) e viene inglobata nella nuova classe che si va a creare (classe Figlio) .

Per approfondimenti vi rimando al sito cnr che vi fornirà un quadro più completo sull'argomento:
http://www.bo.cnr.it/corsi-di-informatica/corsoCstandard/Lezioni/31Eredita.html

Le videolezioni di Camuso sul C#

Posted in By Joker 1 commenti

Strutture avanzate di dati - L'albero

Posted in By Joker 0 commenti

L’ albero è un grafo orientato in cui da ogni nodo possono discendere più figli ma tale che ogni nodo, ad eccezione della radice, abbia un solo padre.



Gli elementi di un albero si chiamano nodi, mentre con ramo si indica un cammino composto da più nodi connessi. Un nodo posto al termine di un ramo è chiamato foglia, mentre il nodo da cui partono i rami è detto radice.

L’albero è considerato un grafo connesso privo di circuiti perché essendo privo di circuiti, garantisce che, partendo dalla radice, si possa raggiungere qualsiasi foglia senza rischiare di finire in un circolo dal quale non si possa uscire.

Nota: Per circuiti si intende un percorso chiuso che permette, partendo da un elemento, di tornare sul medesimo elemento senza ripercorrere lo stesso tratto due volte.

Un albero, a differenza di altre strutture dati quali array, lista, coda, ecc., ha le seguenti caratteristiche:
• Struttura non lineare
• Struttura ricorsiva
• Struttura complessa

Il nodo da cui discende un altro nodo è detto padre. I nodi discendenti da un nodo padre sono detti figli.
Il rapporto padre-figlio dei nodi dell'albero vale per ogni nodo ad eccezione:
• della radice (ha solo figli e non ha padre)
• delle foglie (hanno solo il padre ma non hanno figli)
Una foglia, come già espresso sopra, è un nodo terminale, ovvero un nodo senza figli. Tutti i figli di uno stesso nodo si chiamano fratelli.

Un tipo particolare di albero è l'albero binario.



Un albero binario è caratterizzato dal fatto che da ogni nodo partono al massimo due rami distinti chiamati sottoalbero sinistro e sottoalbero destro.




Per visitare un albero (cioè visitarne tutti i nodi) esistono tre modi:
PREORDINE (Preorder) o ordine anticipato: R - S - D
POSTORDINE (Postorder) o ordine posticipato o polacco: S - D - R
INORDINE (Inorder) o ordine simmetrico: S - R - D

Dove R sta per la radice, D sta per sottoalbero destro della radice e S sta invece per sottoalbero sinistro della radice.

Il numero massimo di nodi toccati per arrivare ad una foglia prende il nome di profondità dell’albero: nel caso illustrato a destra la profondità è 4.
Si dice anche che l’albero ha quattro livelli, dove per livello si intende l’insieme dei dati che distano un uguale numero di nodi dalla radice.




In generale, se p è la profondità, N il numero massimo di nodi e F il numero massimo di foglie:
N=2P-1 F=2(p-1)
Esempio:
N=26-1 N=64

Un albero avente la profondità strettamente necessaria a contenere i nodi che lo costituiscono si dice bilanciato: ad esempio un albero profondo 6 con 40 nodi è bilanciato, in quanto una profondità inferiore (5) consente di inserire solo 31 nodi e non 40. Viceversa un albero profondo 5 con 14 nodi non è bilanciato,in quanto 14 nodi potrebbero stare in un albero meno profondo.

LA DICHIARAZIONE

Partiamo dal caso più semplice: gli alberi binari. Gli alberi binari possono essere implementati mediante record (strutture, in c) di tre campi: R (il valore del nodo, chiamato R in quanto radice del sotto albero che genera), *D (puntatore al figlio destro e quindi al sotto albero destro generato) e *S (puntatore al figlio sinistro).
Gli alberi non binari invece possono essere implementati, fra i vari modi, mediante record di due campi: la radice (o valore del nodo) e il campo che punta alla lista (o al vettore) dei figli.

Vediamo ora come si dichiara una struttura albero in C.

struct nodo {
// Albero di numeri interi
int DATO;
// Puntatore al sottoalbero destro
struct nodo *DX;
// Puntatore al sottoalbero sinistro
struct nodo *SX;
} NODO;

Questo è il record di tre campi di cui abbiamo parlato all'inizio: DATO, che precedentemente abbiamo chiamato R, *DX e *SX. Per chi non lo ricordasse DATO è la variabile che contiene il valore del nodo.
Ricordo inoltre che il C/C++ è case sensitive e che quindi "NODO" è diverso da "nodo".

Una volta dichiarata la struttura del generico nodo dell'albero, dobbiamo ora dichiarare una variabile che punti a tale struttura.
Tale variabile la chiameremo tree (in inglese tree = albero):

typedef struct nodo* tree;

Questo significa che stiamo definendo un nuovo tipo di dato (typedef) di nome tree che è un puntatore a variabile di tipo nodo.
Design by: WPYAG
Blogger Template by Anshul | Funny Pictures.