Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

When to use addressof(x) instead of &x?

Tags:

c++

addressof

How do I decide whether I need addressof(x) instead of &x when taking the address of an object?


Seems like the question was confusing, so a clarification is in order:

addressof obviously bypasses the overloaded address-of operator. I'm already aware of that.

What I want to know is:
How do I know if that's what I really want to do? (Especially when inside a template, etc.)

Is there some kind of "rule" that helps me figure out when I need addressof instead of &?
After all, they both return the "address of" the object, so when do I use which?

like image 854
user541686 Avatar asked Feb 11 '13 20:02

user541686


People also ask

When should I use & in C++?

The ampersand symbol & is used in C++ as a reference declarator in addition to being the address operator. The meanings are related but not identical. If you take the address of a reference, it returns the address of its target. Using the previous declarations, &rTarg is the same memory address as &target .

Can you get the address of a reference in C++?

NO. There is no way to get the address of a reference. That is because a reference is not an object, it is an alias (this means it is another name for an object).


5 Answers

You use std::addressof when you have to. Sadly, "when you have to" includes anytime you are working in template code and want to turn a variable of unknown type T or T& into an honest-to-God pointer to that variable's memory.

Because the C++ committee foolishly allowed the overloading of the reference operator (to little legitimate purpose), it is possible for a user to instantiate your template with some type that you can't use the reference operator to get an actual pointer to. std::addressof is a way to work around users who use this dubious C++ feature in order to do what the language should have guaranteed to work to begin with.

In short, it's a library fix for a language stupidity. Use it in template code instead of & if you want to make sure users can't break your code. If your users can be trusted not to use this ill-conceived feature, then you can use &.

like image 180
Nicol Bolas Avatar answered Oct 08 '22 14:10

Nicol Bolas


If it's a user-defined type with overloaded unary operator&, and you want its address, use addressof.

I'd say you should always use & because, as you say, if you don't, it defeats the purpose of the overload. Unless of course you do something meaningful with the overload, in which case you'd need addressof (outside the class, inside you can just use this), but you have to be very certain of what you're doing.

Here's more - if you want to overload operator& outside the class (you can), you have to use addressof to return the address, otherwise it results in infinite recursion:

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
}

I know this isn't safe.

like image 34
Luchian Grigore Avatar answered Oct 08 '22 16:10

Luchian Grigore


Use it when you want to know the actual address of the object, and not the result of an address-of operator& overload.

like image 29
juanchopanza Avatar answered Oct 08 '22 15:10

juanchopanza


My opinion only:

Unless you are part of the team designing the class and its interface, never. I've personally never seen a good reason to overload that operator. But if someone designs a class where it makes sense, and assuming the class is meant for public consumption(that is to say, the class is not for internal use only in a particular library), I will expect the class to work in normal code that naturally expects that & means "address of". If the class that overloads the operator isn't designed in such a sensible way, then I wouldn't use that class, period. Because either that class is broken, or it is not meant to be used outside the library which it is a part of.

like image 42
Benjamin Lindley Avatar answered Oct 08 '22 16:10

Benjamin Lindley


After all, they both return the "address of" the object, so when do I use which?

You have absolutely no guarantee that an overloaded operator& is the "address of" the object, chances are it isn't, or the class author probably wouldn't have bothered to overload it. They could have overloaded it to return a different type, or even to return void if they are ill-advisedly trying to prevent people taking its address.

If you want a pointer to an object which might have overloaded & (e.g. because its type is a template parameter so you don't know) then either use std::addressof or document that your template doesn't support types which don't return the object's real address as the right type.

like image 33
Jonathan Wakely Avatar answered Oct 08 '22 14:10

Jonathan Wakely