Definition ambiguity about whether dereference operator yields object vs value in an expression

Question

Recently, I have started learning C++ and following the first book from this StackOverflow resource. My question is pretty straight forward. The way * (in an expression) is defined as in the three current resources I am referring to learn C++ are as follows.

* in this context is the dereference operator.

1. C++ Primer says * yields an object.
2. Wikipedia says * returns an l-value equivalent to the value at the pointer address.
3. A Tour of C++ says * returns the content of object.

Where, 2 and 3 make complete sense to me but not 1. Can someone dumb it down for me?

In my understanding an object is simply a memory location which holds some value. However, Can object be thrown as keyword to reflect the value in context to dereferencing a pointer as in 1?

Examples are greatly appreciated.

Edit: Solved, Answers by user eerorika and bolov are perfect and elegant. However eerorika answered first so I will accept it as the answer but all the answers are great as well in their own way. Thanks SO community.

Answer 1

Colloquially, and in this context in particular, value and object are often used as synonyms.

All three descriptions are correct. Wikipedia one is the most precise description out of those three.

Wikipedia says of values:

An lvalue refers to an object that persists beyond a single expression. An rvalue is a temporary value that does not persist beyond the expression that uses it.

C++ standard (draft) says of objects:

The constructs in a C ++ program create, destroy, refer to, access, and manipulate objects. An object is created by a definition (6.1), by a new-expression (8.3.4), when implicitly changing the active member of a union (12.3), or when a temporary object is created (7.4, 15.2). An object occupies a region of storage in its period of construction (15.7), throughout its lifetime (6.8), and in its period of destruction (15.7). ...

And about memory location:

A memory location is either an object of scalar type or a maximal sequence of adjacent bit-fields all having nonzero width. ...

---

In my understanding an object is simply a memory location which holds some value which can be useful or null

An object cannot be null in general - unless that object is a pointer, or some other specific type which has a special value described by the word null.

Answer 2

They are all wrong. But that's ok, because they are all correct :)

The only real authority here is the standard. And the standard is very precise:

§5.3.1 Unary operators [expr.unary.op]

1 The unary * operator performs indirection: the expression to which it is applied shall be a pointer to an object type, or a pointer to a function type and the result is an lvalue referring to the object or function to which the expression points. If the type of the expression is “pointer to T,” the type of the result is “T.”

[n4296]

So there you go, the only valid definition is:

the result is an lvalue referring to the object or function to which the expression points

Anything else is plain wrong.

Except... The standard is useful for compiler implementers and settling down debates of code conformity with the standard. When teaching or just when talking about C++ we generally aren't as rigorous as the standard. We do some simplications for the sake of ... well simplicity (or sometimes just out of ignorance). So we sometimes say "object" when the correct standard terminology would be "lvalue expression referring to an object" and so on.

I would say all the definitions are correct, they just use different terms or take different shortcuts for the sake of easy understanding.

Answer 3

In C++ terminology, an "object" is a value which occupies a region of storage. Here are examples of objects:

int x = 42; // x is an object of type int
int y; // y is an object of type int
char *p = new char; // p points to an object of type char
size_t s = std::string().size(); // s is an object of type size_t; there is also an unnamed temporary object of type std::string involved in the expression

Dereferencing a pointer yields an lvalue which refers to the object to which the point points. So let's take another example:

int i = 42;
int *p = &i;
*p = 314;

The expression *p is an lvalue which references the object i. After the above code, i will have the value 314.

So I'd say that both statements 1 (C++ Primer) and 2 (Wikipedia) are correct, saying the same thing in different words. While 3 is probably correct as well, I consider it somewhat misleading, as you don't normally say an object to have "contents." You could say an object has a value, or that it is a value.

---

Regarding this statement which was originally present in the question:

In my understanding an object is simply a memory location which holds some value which can be useful or null.

The first part is effectively correct, an object is a memory location which holds some value. However, the second part seems somewhat confused: in C++, you normally speak about null only in the context of pointers. A pointer is a type of object which holds an address of another object (or function), or a special value, the null pointer value, which means "not pointing to anything." Most objects (ints, doubles, chars, arrays, instances of class types) cannot be said to be "null".

Answer 4

From the docs

The dereference or indirection expression has the form

* pointer-expression
If pointer-expression is a pointer to function, the result of the dereference operator is a function designator for that function.
If pointer-expression is a pointer to object, the result is an lvalue expression that designates the pointed-to object.

So as an example

int x = 5;    // x is an lvalue
int* p = &x;  // p is a pointer that points to x
*p = 7;       // dereferencing p returns the lvalue x, which you can then operate on