Are temporary objects in C++ const indeed?

Question

I always believed that temporary objects in C++ are automatically considered as const by the compiler. But recently I experienced that the following example of code:

function_returning_object().some_non_const_method();

is valid for C++ compiler. And it makes me wonder - are temporary objects in C++ const indeed? If yes, then why the code above is considered correct by the compiler?

Who or what gave you the idea that they were const in the first place? — fredoverflow, Jan 15 '11 at 19:18
@Fred: Probably because they can be bound to `const T&` but not `T&`. — GManNickG, Jan 15 '11 at 19:28
@mrn: Thought so. Temporaries only being able to bind to `const T&` is a decision, not a requirement. All references could easily refer to a temporary object, but it turns out there's pit-falls when you let things use a `T&` referring to a temporary, so it's not allowed. — GManNickG, Jan 15 '11 at 19:37
@GMan: [related](http://stackoverflow.com/questions/4670137/) — fredoverflow, Jan 15 '11 at 19:49

score 6 · Answer 1 · answered Jan 15 '11 at 19:12

6

No, they're not. Not unless you declare the return type as const.

answered Jan 15 '11 at 19:12

Benjamin Lindley

101,917
9
204
274

I think the OP was hoping there's something in the standard that explains this. – chrisaycock Jan 15 '11 at 19:13
The way the standard would "specify" something like this is by not ever requiring that temporaries be const. It doesn't. – Edward Strange Jan 15 '11 at 19:18
4

@chrisayrock -- Why would the standard need to say that? Objects are not const by default. – Benjamin Lindley Jan 15 '11 at 19:19

score 5 · Answer 2 · answered Jan 15 '11 at 19:19

It depends.

int f();
const int g();

class C { };
C x();
const C y();

In the case of both f() and g(), the returned value is not const because there are no const-qualified rvalues of non-class type. The const in the return type of g() is completely useless (in fact, it's worse than useless, since it can in rare circumstances cause issues with template instantiation).

In the case of x(), the returned value is not const (because it isn't const-qualified). In the case of y(), the returned value is const (because the return type is const-qualified). The const qualifier here (or lack thereof) is meaningful because the return type is a class type.

related: [non-class rvalues always have cv-unqualified types](http://stackoverflow.com/questions/2169932/) — fredoverflow, Jan 15 '11 at 19:33

CashCow · Answer 3 · 2012-12-12T10:38:18.483

Answering the question first, they are not actually const. You may not bind one to a non-const reference. This was probably done to prevent errors in certain situations where they would be passed as a parameter to a function that modifies them, only for the changes to be made to a temporary object and not the intended target.

Allowing non-const operations on a temporary is especially useful when you wish to call "swap" on it with a local variable.

std::vector<T> local;
method_that_returns_a_vector().swap( local );

Before the days of move semantics, this was considered the most efficient way to return a large data set and acquire it without copying all the data.

score 2 · Answer 4 · answered Jan 15 '11 at 19:19

2

Temporary objects can be const, but they don't have to be.

((string const)"hello").append(" world"); // error!

It allows for various things. Consider

struct bitref {
  int index;
  bitref &operator=(bool value); // non-const!
};

struct bitset {
  int flags;
  // returns a bitref temporary that's associated with the bit
  // at index 'index'. 
  bitref operator[](int index); 
  // ...
};

You could do

bitset b;
b[1] = true; // change second bit to 1

This is what's done by the std::bitset<> template.

answered Jan 15 '11 at 19:19

Johannes Schaub - litb

496,577
130
894
1,212

Haven't seen a -1 on your answer in a while. :) +1 Wonder why. EDIT: Looks like you've got a hunch. :o – GManNickG Jan 15 '11 at 19:24
@GMan yeah I have. I better not show it to others though. I'll do fairplay :) – Johannes Schaub - litb Jan 15 '11 at 19:27
Haha, ok. We'll see if you get your comment. :) – GManNickG Jan 15 '11 at 19:29

score 2 · Answer 5 · answered Jan 15 '11 at 19:33

2

Temporary objects aren't const, but they can only bind to const lvalue references. It's easy to demonstrate that allowing temporaries to bind to non-const lvalue references would be bade in virtually all scenarios. You also can't take the address of a temporary, even though you can bind a reference to it, and a number of other very silly things happen with regards to temporaries in C++03. Just be glad that C++0x will be here soon... hopefully.

answered Jan 15 '11 at 19:33

Puppy

144,682
38
256
465

1

`struct C { C* operator&() { return this; } };` ... `C* x = &C();` OMG! I took the address of a temporary! :-D (I know; I cheated...) – James McNellis Jan 15 '11 at 19:43

score 0 · Answer 6 · answered Jan 15 '11 at 19:22

It all depends on the return type of the function.

//Temporary objects: nameless objects that are only usable in current statement
Object function();           //Return a temporary object by value (using copy constructor)
const Object function();     //Return a const temp object by value

//references, return a reference to an object existing somewhere else in memory
Object & function();         //Return an object reference, non-const behaves as any other non-const
const Object & functon();    //Return const obj reference, behaves as any other const

Are temporary objects in C++ const indeed?

6 Answers6

Linked