size di una Classe base e derivata
nembo kid
Eckel nel suo "Thinking in C++", scrive così, ma non ho capito il perché.
GM
> 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é.
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
?manu*
> Il size di una classe derivata è il doppio di quella base?
No. L'unica cosa certa è che il size di una classe derivata non è
inferiore al size della classe base.
> Eckel nel suo "Thinking in C++", scrive così, ma non ho capito il perché.
Riporta la sua frase e ne discutiamo.
E.
Andrea Laforgia
> 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é.
Non ti sembra doveroso riportare il brano incriminato? (dubito molto
anch'io che Eckel lo abbia scritto).
seimess
> 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é.
assolutamente no...
poi se inizi con le derivazioni virtuali ancora meno...
non vuol dire proprio nulla una considerazione del genere...
nembo kid
> 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);
}
//////////////////////////////////////////
Gabriele Greco
> ?manu* ha scritto:
>
>> 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)
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!
nembo kid
> In questo esempio e` vero che Y e il doppio della classe X, ma
> semplicemente perche` Y contiene due interi e X uno solo.
La var. i sua e la var.i di X??
Grazie
GM
> nembo kid wrote:
>> ?manu* ha scritto:
>>
>>> 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)
>
> In questo esempio e` vero che Y e il doppio della classe X, ma
> 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