Newsgroup: it.comp.lang.c++
Titolo: size di una Classe base e derivata

Il size di una classe derivata è il doppio di quella base?
Eckel nel suo "Thinking in C++", scrive così, ma non ho capito il perché.

 Eckel nel suo "Thinking in C++", scrive così, ma non ho capito il perché.
Dubito molto che Eckel abbia scritto una c...ata di questo calibro.
Non credo esista una "regola" che stabilisca una relazione tra le due 
size e che valga sempre (o meglio un'"imposizione" dello standard)
Quello che posso dirti è che in certi casi potresti avere 
sizeof(derivata) == sizeof(base) e questo succede se la base è senza 
membri dati E il tuo compilatore usa la cosiddetta Empty Base class 
Optimization (che è una delle poche "ottimizzazioni" contemplate dallo 
std) oppure può succedere se la derivata non aggiunge membri dati (ma 
anche in questo caso non credo che ci sia una garanzia esplicita dello std).
Nella maggior parte dei casi "pratici" la size della derivata sarà 
quella della base + il posto per i dati aggiunti dalla derivata (+ 
eventuale "padding"). Poi membri virtuali e/o ereditarietà multipla 
complicano le cose...
Quello che mi sento di poter dire è che è impossibile che 
sizeof(derivata) < sizeof(base)
GM

 Eckel nel suo "Thinking in C++", scrive così, ma non ho capito il perché.
Riporta la sua frase e ne discutiamo.
E.

 Eckel nel suo "Thinking in C++", scrive così, ma non ho capito il perché.
Non ti sembra doveroso riportare il brano incriminato? (dubito molto
anch'io che Eckel lo abbia scritto).

 Eckel nel suo "Thinking in C++", scrive così, ma non ho capito il perché.
assolutamente no...
poi se inizi con le derivazioni virtuali ancora meno...
non vuol dire proprio nulla una considerazione del genere...

 Riporta la sua frase e ne discutiamo.
p. 587
In main() you can see that Y's data elements are combined wiht X's 
because the sizeof(Y) is twice as big as sizeof(C):
#include <iostream>
using namespace std;
//////////////////////////////////////////
class X {
   int i;
public:
   X() { i = 0; }
   void set ( int ii ) { i = ii; }
   int read() const { return i; }
   int permute() { return i = i * 47; }
};
//////////////////////////////////////////
//////////////////////////////////////////
class Y : public X {
   int i; // Different from X's i
public:
   Y() { i = 0; }
   int change() {
     i = permute(); // Different name call
     return i;
   }
   void set(int ii) {
     i = ii;
     X::set(ii); // Same-name function call
   }
};
//////////////////////////////////////////
//////////////////////////////////////////
int main() {
   cout << "sizeof(X) = " << sizeof(X) << endl;
   cout << "sizeof(Y) = "
        << sizeof(Y) << endl;
   Y D;
   D.change();
   // X function interface comes through:
   D.read();
   D.permute();
   // Redefined functions hide base versions:
   D.set(12);
}
//////////////////////////////////////////

 because the sizeof(Y) is twice as big as sizeof(C)
In questo esempio e` vero che Y e il doppio della classe X, ma 
semplicemente perche` Y contiene due interi e X uno solo.
Non generalizzare un'affermazione relativa ad un esempio!

 semplicemente perche` Y contiene due interi e X uno solo.
La var. i sua e la var.i di X??
Grazie

 semplicemente perche` Y contiene due interi e X uno solo.
E inoltre non credo proprio che questa proprietà sia garantita dallo std 
(ma se qualcuno ha info più sicure smentisca (che tra l'altro mi interessa))
Quasi tutto quello che riguarda size, allineamento, packing ecc. è 
implementation defined.
GM