Wanneer gebruik je addressof(x) in plaats van &x?

Hoe beslis ik of ik addressof(x)nodig heb in plaats van &xbij het nemen van het adres van een object?

Het lijkt erop dat de vraag verwarrend was, dus een verduidelijking is op zijn plaats:

addressofomzeilt uiteraard het overbelaste adres-of-operator. Dat weet ik al.

Wat ik wil weten is:
Hoe weet ik of dat is wat ik echt wil doen? (Vooral in een sjabloon, enz.)

Is er een soort “regel” die me helpt erachter te komen wanneer ik addressofnodig heb in plaats van &?
Ze geven tenslotte allebei het “adres van” het object terug, dus wanneer gebruik ik welke?

Antwoord 1, autoriteit 100%

Je gebruikt std::addressofals het moet. Helaas omvat “wanneer het moet” elk moment dat u in sjablooncode werkt en een variabele van het onbekende type Tof T&wilt veranderen in een eerlijk-naar-God pointer naar het geheugen van die variabele.

Omdat de C++-commissie dwaas de overbelasting van de referentie-operator toestond (met weinig legitiem doel), is het voor een gebruiker mogelijk om uw sjabloon te instantiëren met een type dat u niet kunt gebruiken met de referentie-operator om een ​​echte verwijzing naar . std::addressofis een manier om gebruikers te omzeilen die deze dubieuze C++-functie gebruiken om te doen wat de taal in het begin gegarandeerd zou moeten werken.

Kortom, het is een bibliotheekoplossing voor een taaldomheid. Gebruik het in sjablooncode in plaats van &als u ervoor wilt zorgen dat gebruikers uw code niet kunnen breken. Als uw gebruikers erop kunnen vertrouwen dat ze deze ondoordachte functie niet gebruiken, kunt u &gebruiken.

Antwoord 2, autoriteit 13%

Als het een door de gebruiker gedefinieerd type is met een overbelaste unaire operator&, en je wilt het adres, gebruik dan addressof.

Ik zou zeggen dat je altijd &moet gebruiken omdat, zoals je zegt, als je dat niet doet, het doel van de overbelasting voorbij gaat. Tenzijnatuurlijk iets zinvols met de overbelasting doet, in welk geval je addressofnodig hebt (buiten de klas, binnen kun je gewoon this), maar je moet heel zeker zijn van wat je doet.

Hier is meer: ​​als u operator&buiten de klas wilt overbelasten (dat kan), moetaddressofgebruiken om de adres, anders resulteert dit in oneindige recursie:

struct Class
{
   virtual ~Class() {}
   int x;
};
void* operator&(const Class& x)
{
    //return &x; <---- infinite recursion
    return addressof(x) + 4; //I know this isn't safe
                             //but I also know the intrinsics of my compiler
                             //and platform to know this will actually return
                             //the address to the first data member
}

Ik weet dat dit niet veilig is.

Antwoord 3, autoriteit 8%

Gebruik het als je het werkelijke adres van het object wilt weten, en niet het resultaat van een adres-of operator&overbelasting.

Antwoord 4, autoriteit 6%

Alleen mijn mening:

Tenzij je deel uitmaakt van het team dat de klasse en de interface ontwerpt, nooit. Ik heb persoonlijk nooit een goede reden gezien om die operator te overbelasten. Maar als iemand een klasse ontwerpt waar het logisch is, en ervan uitgaat dat de klasse bedoeld is voor openbare consumptie (dat wil zeggen, de klasse is niet alleen voor intern gebruik in een bepaalde bibliotheek), verwacht ik dat de klasse in normale code werkt dat verwacht natuurlijk dat &“adres van” betekent. Als de klasse die de operator overbelast niet op zo’n verstandige manier is ontworpen, dan zou ik die klasse niet gebruiken, punt uit. Omdat die klasse ofwel kapot is, ofwel niet bedoeld is om te worden gebruikt buiten de bibliotheek waar hij deel van uitmaakt.

Antwoord 5, autoriteit 5%

Ze geven tenslotte allebei het “adres van” het object terug, dus wanneer gebruik ik welke?

Je hebt absoluut geen garantie dat een overbelaste operator&het “adres” is van het object, de kans is groot dat dit niet het geval is, anders zou de klasse-auteur waarschijnlijk niet de moeite hebben genomen om het te overbelasten. Ze hadden het kunnen overbelasten om een ander type terug te sturen, of zelfs om voidterug te sturen als ze onverstandig proberen te voorkomen dat mensen het adres ervan innemen.

Als u een verwijzing naar een object wilt dat mogelijkoverbelast is &(bijvoorbeeld omdat het type een sjabloonparameter is, zodat u het niet weet), gebruik dan ofwel std::addressofof documenteer dat uw sjabloon geen typen ondersteunt die het echte adres van het object niet als het juiste type retourneren.