Are there any variables whose address can not be obtained?

Question

I am learning for my CPP exam and one of the questions will be like this: "How to get variable address and are there any variables whose address cannot be obtained"?

So first one is easy, you just use "&" operator, but are there any variables (mind you that question only concerns variables!) whose address cannot be accessed with ampersand?

Any help would be appreciated

References and rvalues come to mind. I don't know if you would consider those "variables". — François Andrieux, Feb 08 '18 at 18:50
Well, you can't obtain the address of a bit. The smallest thing you can address in C++ is a byte. — Carl, Feb 08 '18 at 18:50
_"...variables..."_ such an ill defined term, see __Built-in address-of operator__ in: http://en.cppreference.com/w/cpp/language/operator_member_access This being an exam question depends on how your course has defined __variable__. — Richard Critten, Feb 08 '18 at 18:52
Those which are of type with `operator&` overloaded in such a way, from which you can not get to the address? You'd have to use `std::addressof`. — LogicStuff, Feb 08 '18 at 18:52
If you consider a preprocessor macro such as `#define MAX_DUMBNESS 255` a variable, you can't get the address of that. (I personally don't) — zzxyz, Feb 08 '18 at 18:53
@zzxyz A macro is not even remotely related to a _variable_. — , Feb 08 '18 at 18:54
@FrançoisAndrieux Why wouldn't a bit field be considered a variable? You can read from it and assign to it just like any other variable. — Barmar, Feb 08 '18 at 18:55
I do not get the downvotes, it does not seem to be that obvious. — Derek Johnson, Feb 08 '18 at 18:56
@DerekJohnson The whole point of exercises like this is for you to try to figure it out yourself. That's how you understand the underlying concepts. — Barmar, Feb 08 '18 at 18:58
If you count reference you cannot get the address of the actual reference, only what it refers to. — NathanOliver, Feb 08 '18 at 19:09
What about the address of a `constexpr` `int`? I would think some answers should address the possibility, or impossibility, of finding a way to create a 'variable' that is a prvalue - perhaps a contradiction in terms, but worth commenting on, I think. — Dan Nissenbaum, Feb 08 '18 at 19:51
See https://stackoverflow.com/q/14872240/368896 for discussion of attempt to take address of a (non-static-member) `constexpr`. — Dan Nissenbaum, Feb 08 '18 at 19:57

score 10 · Accepted Answer · answered Feb 08 '18 at 18:54

are there any variables whose address cannot be obtained?

You cannot get addresses of member variables of structs that are bit-fields.

From the C++11 Standard:

The address-of operator & shall not be applied to a bit-field, so there are no pointers to bit-fields.

llllllllll · Answer 2 · 2018-02-08T19:04:39.803

5

but are there any variables (mind you that question only concerns variables!) whose address cannot be accessed with ampersand?

I think the question in your content is different from the one from the title. I assume the one in your content is what you want.

There are variables whose address can't be obtained by ampersand, because you can overload that operator.

The code below, &a won't give you the address of a.

#include <iostream>

struct foo {
    int operator &() {
        return 900;
    }
};

int main() {
    foo a;
    std::cout << (&a) << "\n";
}

NOTE: Such variable's address can be obtained by other methods. Basically the principle is erasing the type so that the overloaded operator has no effect. std::addressof implemented this functionality.

edited Feb 08 '18 at 19:04

answered Feb 08 '18 at 18:57

llllllllll

16,169
4
31
54

1

[`std::addressof`](http://en.cppreference.com/w/cpp/memory/addressof) gets around this. – NathanOliver Feb 08 '18 at 18:58
1

This answer is technically right, because the question asks specifically about `operator&` *("whose address cannot be accessed with ampersand?")*. But you can use [`std::addressof`](http://en.cppreference.com/w/cpp/memory/addressof) in that case. – François Andrieux Feb 08 '18 at 18:58
@NathanOliver Note in OP's description in the **content**, it's "**cannot be accessed with ampersand**". – llllllllll Feb 08 '18 at 18:59

Carl · Answer 3 · 2018-02-08T19:05:24.400

So as an example. The smallest thing you can address in C++ is a byte, and so attempting to access for example any of the 1 bit uint8_t's inside this bitField is not legal.

#include <iostream>
#include <cstdint>

struct bitField {
    uint8_t n0 : 1;
    uint8_t n1 : 1;
    uint8_t n2 : 1;
    uint8_t n3 : 1;
    uint8_t n4 : 1;
    uint8_t n5 : 1;
    uint8_t n6 : 1;
    uint8_t n7 : 1;
};

int main() {
    bitField example;

    // Can address the whole struct
    std::cout << &example << '\n'; // FINE, addresses a byte

    // Can not address for example n4 directly
    std::cout << &example.n4; // ERROR, Can not address a bit

    // Printing it's value is fine though
    std::cout << example.n4 << '\n'; // FINE, not getting address

    return 0;
}

As TheDude mentioned in the comment section however, the STL has a class std::bitset<N> which offers a workaround for this. It basically wraps an array of bools. Still, the end result is indexing bytes, not bits.

Are there any variables whose address can not be obtained?

3 Answers3

Linked