Vraag waarom de referentiegrootte altijd 4 bytes is - c ++


Op een 32-bits machine krijg ik altijd de sizeof van een verwijzing 4 bytes zelfs als het een verwijzing naar een dubbel is, dus wat slaat het echt op in deze 4 bytes.

 BEWERK :

class A{
public:
  double&  a;
};

int main(){
  cout << sizeof(A) << endl; // this will print out 4
}

10
2018-05-04 10:18


oorsprong


antwoorden:


De standaard is vrij duidelijk sizeof (C ++ 11, 5.3.3 / 4):

Wanneer het wordt toegepast op een referentie of een referentietype, is het resultaat het   grootte van het type waarnaar wordt verwezen.

Dus als je het echt meeneemt sizeof(double&), de compiler vertelt je dat sizeof(double) is 4.

Bijwerken: Dus, wat je echt aan het doen bent, is toepassen sizeof naar een klasse type. In dat geval,

Wanneer het wordt toegepast op een klasse, is het resultaat het aantal bytes in een   object van die klasse [...]

Dus we weten dat de aanwezigheid van de referentie erin zit A zorgt ervoor dat deze 4 bytes in beslag neemt. Dat komt omdat, hoewel de standaard niet bepaalt hoe verwijzingen moeten worden geïmplementeerd, de compiler ze nog steeds op de een of andere manier moet implementeren. Dit kan op de een of andere manier heel verschillend zijn, afhankelijk van de context, maar voor een referentielid van een klassetype is de enige benadering die logisch is sluipen in een double* achter je rug en noem het een double& in je gezicht.

Dus als uw architectuur 32-bits is (waarbij wijzers 4 bytes lang zijn), zou dit het resultaat verklaren.

Houd daar gewoon rekening mee het concept van een referentie is niet gebonden aan een specifieke implementatie. De standaard staat de compiler toe om referenties te implementeren, maar hij wil dit wel.


35
2018-05-04 10:21



Dat kan je niet, en dat is het niet.

Een C ++ -referentie is niet een aanwijzer. Het is een alias van een object. Soms, de compiler kiest om dit te implementeren met behulp van een aanwijzer. Maar vaak wordt het geïmplementeerd door helemaal niets doen. Door simpelweg code te genereren die rechtstreeks naar het oorspronkelijke object verwijst.

In elk geval, sizeof toegepast op een referentietype geeft je niet de maat van een referentie. Dus het is niet echt duidelijk wat je doet, waardoor het onmogelijk is uit te leggen wat er aan de hand is.

Bewerk 

Nu je wat code hebt getoond, kunnen we de vraag beantwoorden:

U neemt de grootte van een klasse die een referentie bevat. Zoals ik hierboven al zei, is een verwijzing geen aanwijzer, maar wanneer nodig kan de compiler terugvallen op het gebruik van een aanwijzer om deze weer te geven. Wanneer u een klasse met een verwijzing maakt, is de enige (normale) manier waarop de compiler deze kan implementeren, door een klasse te definiëren die het adres van een object bevat. Op 32-bits systemen zijn adressen 32 bits of 4 bytes, breed. Zo sizeof zo'n klasse zal (meestal) 4 zijn.


20
2018-05-04 10:22