Spesso, programmando in c++, mi scontro con diversità nell'interpretazione (ed effettiva implementazione) della programmazione a oggetti rispetto al c#. Quando mi trovo in queste situazioni mi viene da pensare il motivo di questa differenza e perchè in fase di progettazione dei due linguaggi Straustrup e Hejlsberg sono arrivati a due conclusioni differenti. L'esempio più eclatante riguarda sicuramente la diatriba sull'ereditarietà multipla. In questo post invece mi volevo soffermare su un problema molto meno rilevante dell'esempio appena citato: l'initializer nei costruttori e in particolare richiamare nell'initializer un'altra versione del costruttore della classe.
In entrambi i linguaggi l'initializer è opzionale e in c# accetta solo costruttori, tramite la parola chiave this (che invoca un costruttore della stessa classe) o base (che invoca il costruttore della classe base). In c++ l'inizializer accetta solo o membri della classe oppure un costruttore della classe base, senza dare la possibilità di richiamare un altro costruttore della stessa classe. Vediamo un esempio:
Abbiamo una classe A e una classe B che eredita da A. Le dichiarazione delle classi è sostanzialmente analoga:
[C#]
public class A
{
private int _a;
//Constructor....
}
public class B: A
{
private int _b;
//Constructor...
}
[C++]
public class A
{
private:
int _a;
//Constructor....
};
public class B: public A
{
private:
int _b;
//Constructors....
};
La parte interessate riguarda l'implementazione dei costruttori. Vediamo i costruttori della classe A:
[C#]
public A() : this(0)
{}
public A(int a)
{
_a = a;
}
....
[C++]
public:
A(void) : _a(0)
{}
A(int a): _a(a)
{}
Le differenze tra i due linguaggi balzano subito agli occhi: In C# non possono essere inizializzati i membri nell'initializer (anche perchè in realtà non ci sarebbe differenza, se non sintattica, rispetto ad inizializzarli nel corpo del costruttore) mentre in c++ non può essere richiamata dal costruttore A(void) la versione del costruttore A(int a).
Vediamo ora i costruttori della classe B:
[C#]
public B() : this(0)
{}
public B(int b): this(0, b)
{}
public B(int a, int b): base(a)
{
_b = b;
}
....
[C++]
public:
B(void) : A(0), _b(0) //Richiamo del costruttore con un parametro della classe base e inizializzazione del membro _b
{}
B(int b): A(0), _b(b)
{}
B(int a, int b): A(a), _b(b)
{}
Dalla classe figlia B balza all'occhio ancora la comodità (e spesso necessità) del c++ di inizializzare i membri nell'initializer e l'impossibilità di richiamare una versione diversa del costruttore della classe. E' possibile invece richiamare un costruttore della classe figlia.
Come si dice in questi casi la domanda nasce spontanea: perchè inell'initializer, n c++, si può richiamare un costruttore della classe base e non un costruttore diverso della classe figlia? E' una scelta progettuale ed è dettata da una ragione ben precisa o più semplicemente in fase di progettazione del linguaggio non è stata proprio pensata una situazione di questo genere? Visto e considerato che C# è un linguaggio più nuovo, e permette questa situazione, mi viene da pensare che sia stata una "dimenticanza" del c++. La sensazione è che a questa domanda può rispondere solo Mr. Straustrup:)
Ai POSTeri l'ardua sentenza....