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.
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 membriereditati da una classe base dipende anche dallo "specificatore di accesso alla classe base", che deve essere indicato come nel seguente esempio:
classFiglio :spec.di accessoPadre{ ........};
dove spec.di accesso può essere: private (default), protected o public (notare l'assenza dei due punti). Ogni membroereditato 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 membroereditato è pubblico solo se è public nella classe base e l'accesso della classederivata alla classe base è public.
Se una classederivata è a sua volta genitrice di una nuova classe, in quest'ultima l'accesso ai membriereditati è 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 membripubblici e protetti, ereditati nella classederivata, siano accessibili unicamente da funzionimembro e friend della classederivata stessa: in questo caso, occorre che lo specificatore di accesso alla classe base sia private; analogamente, se si vuole che i membripubblici e protetti di una classe base siano accessibili unicamente da funzionimembro e friend della classederivata e di altre eventuali classiderivate 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;};
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à è la capacità di riutilizzare le componenti (membri e attributi) della classe base in quella derivata.
es. classFiglio :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:
