Newsgroup: it.comp.lang.c++
Titolo: Quant'e' grande una struttura ?

Per testare l'esercizio n. 20 del capitolo 4 di Thinking in C++, 
ho scritto il seguente codice :
#include <stdio.h>
struct Prova1 { 
       float DataMember ;
       void Method1() ;
       void Method2() ;
} ;
void Prova1::Method1()
{
     puts( "ciao sono il metodo di Prova1" ) ;
}
void Prova1::Method2()
{
     puts( "ciao sono il metodo di Prova1" ) ;
}
struct Prova2 { 
       char DataMember ;
} ;
 
struct Prova3 { 
       double Method() ;
} ;
double Prova3::Method()
{
     puts( "ciao sono il metodo di Prova3" ) ;
}
struct Prova4 { 
} ;
main()
{
    printf( "%d %d %d %d\n", sizeof( Prova1 ),
    sizeof( Prova2 ),
    sizeof( Prova3 ),
    sizeof( Prova4 ) ) ;
}
Compilato da riga di comando con il compilatore Borland C++ 5.5
ottengo :
4 1 8 8
Ora, e' chiaro che 4 e 1 sono i valori riferiti a float e char, il che
mi fa capire che
l'incapsulamento o meno di metodi in una struct e' irrilevante al fine
del calcolo
della dimensione della stessa.
Quello che non mi spiego pero' e' perche' per una struct vuota
(equivalente, quindi, da questo
punto di vista, ad una che incapsula solo metodi) si ha come
dimensione proprio 8.
Cosa mi sfugge ?	

 Cosa mi sfugge ?
Il fatto che è una questione dipendente dal compilatore. Infatti con il
DJGPP il risultato è 4 1 1 1. Comunque una dimensione è necessaria anche
per le strutture o classi senza dati membro in quanto è richiesta dal
principio che un oggetto deve avere un'identità (e quindi un indirizzo).
EMG

Probabilmente dipende dall'opzione di allineamento.
Io ottengo (con allineamento a byte) 4 1 1 1
Il che significa che apparentemente viene allocata memoria
anche per gli oggetti statici vuoti!
A proposito che dice lo standard in merito alle
classi senza data member... cosa deve restituire
sizeof?
Paolo
--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
--------------------------------------------------

sizeof?
Bruce Eckel, in Thinking in C++, ammette, riferendosi al suo esempio :
"struct B is something of an anomaly because it is a struct with no
data members. In C, this is illegal, but in C++ we need the option of
creating a struct whose sole task is to scope function names, so it is
allowed. Still, the result produced by the second print
statement is a somewhat surprising nonzero value. In early versions of
the language, the size was zero, but an awkward situation
arises when you create such objects: They have the same address as the
object created directly after them, and so are not
distinct. One of the fundamental rules of objects is that each object
must have a unique address, so structures with no data
members will always have some minimum nonzero size."
Quindi, se non erro, nel caso del djgpp viene allocato 1 byte per
queste strutture, giusto perche' esse devono avere una locazione in
memoria a cui poter far riferimento tramite indirizzo.

Penso che in una classe (o struttura o altro simile) le funzioni membro non
vengano replicate per tutte le istanze, dato che il codice da eseguire è
sempre quello, ne viene tenuta solo una copia in memoria. Forse vengono
creati solo i puntatori a queste, e sempre forse 8 byte potrebbero essere i
puntatori a un costruttore e un distruttore di default.
FORSE!
Ciao
Michele

you wrote:

No, non credo.
Durante la compilazione le funzioni membro subiscono la cosiddetta
"name decoration", per cui vengono sganciate dalla classe in se' e
vengono trattate come semplici funzioni. Cioe' all'interno della
classe in memoria (intesa come struttura dati) non vengono conservati
dei puntatori alle funzioni membro.

puntatori a un costruttore e un distruttore di default.
Il codice delle funzioni membro e' sempre condiviso, gli 8 byte 
dipendono sicuramente da un problema di allineamento.
Le istanze di una classe condividono invece la vtable (quando esiste),
oltre agli eventuali attributi static.
Paolo