C ++: qual è la dimensione di un oggetto di una classe vuota?

Mi chiedevo quale potesse essere la dimensione di un oggetto di una classe vuota . Sicuramente non potrebbe essere 0 byte poiché dovrebbe essere possibile fare riferimento e puntare ad esso come qualsiasi altro oggetto. Ma quanto è grande un oggetto del genere?

Ho usato questo piccolo programma:

#include <iostream>
using namespace std;

class Empty {};

int main()
{
    Empty e;
    cerr << sizeof(e) << endl;
    return 0;
}

L'output che ho ottenuto su entrambi i compilatori Visual C ++ e Cygwin-g ++ era di 1 byte ! Questo è stato un po 'sorprendente per me poiché mi aspettavo che fosse della dimensione della parola macchina (32 bit o 4 byte).

Qualcuno può spiegare perché la dimensione di 1 byte? Perché non 4 byte? Dipende anche dal compilatore o dalla macchina? Inoltre, qualcuno può fornire una ragione più convincente per cui un oggetto di classe vuoto non sarà di dimensione 0 byte?

Citando le domande frequenti su stile e tecnica C ++ di Bjarne Stroustrup , il motivo per cui la dimensione è diversa da zero è "Per garantire che gli indirizzi di due oggetti diversi siano diversi". E la dimensione può essere 1 perché l'allineamento non ha importanza qui, poiché non c'è nulla da guardare effettivamente.

Lo standard afferma che tutti gli oggetti più derivati ​​hanno sizeof ()> = 1:

A meno che non sia un campo di bit (class.bit), un oggetto più derivato deve avere una dimensione diversa da zero e occupare uno o più byte di memoria. Gli oggetti secondari della classe base possono avere dimensione zero. ISO / IEC FDIS 14882: 1998 (E) intro.object

Questo è davvero un dettaglio di implementazione. Una volta, molto tempo fa, pensavo che potesse essere zero byte o mille byte, che non ha alcuna relazione con le specifiche del linguaggio. Ma, dopo aver esaminato lo standard (sezione 5.3.3), sizeofviene definito come restituirne sempre uno o più, qualunque cosa accada.

La dimensione di una classe più derivata deve essere maggiore di zero.

Ciò è necessario, tra le altre cose, per consentire di gestire array di oggetti e puntatori ad essi. Se ai tuoi elementi fosse consentito di essere di dimensione zero, allora &(array[0])sarebbe identico a &(array[42]), il che causerà ogni sorta di caos ai tuoi loop di elaborazione.

Il motivo per cui potrebbe non essere una parola macchina è che non ci sono elementi al suo interno che effettivamente richiedono che sia allineato su un confine di parola (come un numero intero). Ad esempio, se si inserisce char x; int y;all'interno della classe, il mio GCC lo sincronizza a otto byte (poiché il secondo int deve essere allineato in quell'implementazione).

C'è un'eccezione: array di lunghezza 0

#include <iostream>

class CompletlyEmpty {
  char NO_DATA[0];
};

int main(int argc, const char** argv) {
  std::cout << sizeof(CompletlyEmpty) << '\n';
}

Anche se non è necessario assegnare memoria per una classe vuota, ma per creare oggetti di classi vuote, il compilatore assegna la memoria minima che può essere assegnata, che è 1 byte. In questo modo il compilatore può distinguere in modo univoco due oggetti della stessa classe vuota e sarà in grado di assegnare l'indirizzo dell'oggetto a un puntatore del tipo di classe vuota.

Penso che potrebbe essere utile collegare a una risposta che spieghi anche questo bene. E ' su boost::compressed_pairda Logan Capaldo .

Questo può aiutarti :-) http://bytes.com/topic/c/insights/660463-sizeof-empty-class-structure-1-a

La dimensione di una classe o struttura vuota è 1

Il motivo per cui ciò accade si riduce all'implementazione corretta dello standard, una delle cose che lo standard C ++ dice è che "nessun oggetto deve avere lo stesso indirizzo in memoria di qualsiasi altra variabile" .... Qual è il modo più semplice per assicurarlo? Assicurati che tutti i tipi abbiano una dimensione diversa da zero. Per ottenere ciò, il compilatore aggiunge un byte fittizio a strutture e classi che non hanno membri di dati e funzioni virtuali in modo che abbiano una dimensione di 1 anziché una dimensione di 0 e quindi è garantito che abbiano un indirizzo di memoria univoco.

L'assegnazione di 1 byte per una classe vuota dipende dal compilatore. I compilatori devono assicurarsi che gli oggetti risiedano in posizioni di memoria diverse e devono allocare una dimensione di memoria diversa da zero a un oggetto. Ascolta le note su questo argomento qui: http://listenvoice.com/listenVoiceNote.aspx?id=27

Anche se i compilatori allocano dimensioni diverse da zero a una classe vuota, eseguono anche ottimizzazioni quando nuove classi derivano da classi vuote. Ascolta l'ottimizzazione della base vuota sulle domande dell'intervista di programmazione c ++ di ListenVoice.

il motivo per la classe senza membri di dati ma con dimensione 1 byte è che questo * testo forte * deve essere archiviato in memoria in modo che un riferimento o un puntatore possa puntare all'oggetto di quella classe

classe vuota -quella classe non contiene alcun contenuto.

qualsiasi classe che non sia vuota sarà rappresentata dal suo contenuto in memoria.

ora come sarà rappresentata la classe vuota nella memoria? siccome non ha contenuto nessun modo per mostrare la sua esistenza nella memoria, ma la classe è presente, è obbligatorio mostrare la sua presenza nella memoria. Per mostrare la presenza di una classe vuota in memoria è richiesto 1 byte.

Penso che sia così perché 1 byte è l'unità di memoria più piccola che può essere utilizzata come segnaposto e non può dare dimensione zero in quanto non sarà possibile creare un array di oggetti ..

e la cosa che hai detto "Questo è stato un po 'sorprendente per me poiché mi aspettavo che fosse della dimensione della parola macchina (32 bit o 4 byte)." sarà vero per la variabile di riferimento (parole macine) di tipo empty (), non per la dimensione della classe stessa (che è un tipo di dati astratto),

Penso che questa domanda sia solo di interesse teorico ma non ha importanza nella pratica.

Come già sottolineato da altri, derivare da una classe vuota non fa alcun danno, in quanto ciò non consumerà memoria extra per la porzione della classe base.

Inoltre, se una classe è vuota (il che significa che, in teoria, non necessita di memoria per istanza, ovvero non ha membri di dati non statici o funzioni membro virtuali), allora tutte le sue funzioni membro possono (e dovrebbe) essere definito come statico. Quindi non è necessario creare mai un'istanza di questa classe.

Conclusione: se ti ritrovi a scrivere una classe X vuota, rendi statiche tutte le funzioni membro. Quindi non sarà necessario creare oggetti X e le classi derivate non saranno influenzate in alcun modo.

#include<iostream>
using namespace std;


    class Empty { };
    int main()
    {
        Empty* e1 = new Empty;
        Empty* e2 = new Empty;

        if (e1 == e2)
            cout << "Alas same address of two objects" << endl;
        else
            cout << "Okay it's Fine to have different addresses" << endl;

        return 0;
    }

Risultato: va bene avere indirizzi diversi

La restituzione della dimensione 1 garantisce che i due oggetti non avranno lo stesso indirizzo.

È diverso da zero per garantire che i due diversi oggetti abbiano indirizzi diversi. Oggetti diversi dovrebbero avere indirizzi diversi, quindi la dimensione di una classe vuota è sempre 1 byte.

Penso che se la dimensione di una classe vuota è zero significa che non esiste. Affinché esista (classe), è necessario che abbia almeno 1 byte, poiché questo byte è l'indirizzo di memoria / riferimento.

È a causa di questo puntatore, sebbene il puntatore sia (intero) di 4 byte ma si riferisca a una posizione di memoria (una unità) che è di 1 byte.