Question

I’ve recently tried to really come to grips with references and pointers in C++, and I’m getting a little bit confused. I understand the * and & operators which can respectively get the value at an address and get the address of a value, however why can’t these simply be used with basic types like ints?

I don’t understand why you can’t, for example, do something like the following and not use any weird pointer variable creation:

string x = "Hello";
int y = &x; //Set 'y' to the memory address of 'x'
cout << *y; //Output the value at the address 'y' (which is the memory address of 'x')

The code above should, theoretically in my mind, output the value of ‘x’. ‘y’ contains the memory address of ‘x’, and hence ‘*y’ should be ‘x’. If this works (which incidentally on trying to compile it, it doesn’t — it tells me it can’t convert from a string to an int, which doesn’t make much sense since you’d think a memory address could be stored in an int fine).

Why do we need to use special pointer variable declarations (e.g. string *y = &x)?
And inside this, if we take the * operator in the pointer declaration literally in the example in the line above, we are setting the value of ‘y’ to the memory address of ‘x’, but then later when we want to access the value at the memory address (‘&x’) we can use the same ‘*y’ which we previously set to the memory address.

Answer 1

Some very low-level languages… like machine language… operate exactly as you describe. A number is a number, and it’s up to the programmer to hold it in their heads what it represents. Generally speaking, the hope of higher level languages is to keep you from the concerns and potential for error that comes from that style of development.

You can actually disregard C++’s type-safety, at your peril. For instance, the gcc on a 32-bit machine I have will print “Hello” when I run this:

string x = "Hello";
int y = reinterpret_cast<int>(&x);
cout << *reinterpret_cast<string*>(y) << endl;

But as pretty much every other answerer has pointed out, there’s no guarantee it would work on another computer. If I try this on a 64-bit machine, I get:

error: cast from ‘std::string*’ to ‘int’ loses precision

Which I can work around by changing it to a long:

string x = "Hello";
long y = reinterpret_cast<long>(&x);
cout << *reinterpret_cast<string*>(y) << endl;

The C++ standard specifies minimums for these types, but not maximums, so you really don’t know what you’re going to be dealing with when you face a new compiler. See: What does the C++ standard state the size of int, long type to be?

So the potential for writing non-portable code is high once you start going this route and “casting away” the safeties in the language. reinterpret_cast is the most dangerous type of casting…

When should static_cast, dynamic_cast, const_cast and reinterpret_cast be used?

But that’s just technically drilling down into the “why not int” part specifically, in case you were interested. Note that as @BenVoight points out in the comment below, there does exist an integer type as of C99 called intptr_t which is guaranteed to hold any poniter. So there are much larger problems when you throw away type information than losing precision…like accidentally casting back to a wrong type!