C++ reference pointing to a temporary variable?

Question

class ClassB {
    int m_b;
public:
    ClassB(int b) : m_b(b) {}
    void PrintClassB() const {
        cout << "m_b: " << m_b << endl;
    }
};


int main(int argc, char* argv[])
{
    const ClassB &af = ClassB(1);
    af.PrintClassB(); // print m_b: 1 with vs2008 & gcc 4.4.3
}

Given the above code, I have difficulties to understand this snippet:

Q1> What does this line mean?

const ClassB &af = ClassB(1);

Here is my understanding:

af refers to a temporary variable ClassB(1) and after the

execution of this line, the temporary variable is destroyed and af refers to an undefined variable. During this procedure, no copy-constructor is called.

Then why we can still issue the following statement and obtain the results?

af.PrintClassB(); // print m_b: 1 with vs2008 & gcc 4.4.3

Answer 1

const ClassB &af = ClassB(1);

const here extend the life time of the temporary object (i.e., ClassB(1)) being created. It's scope lasts until af falls out of scope;

af.PrintClassB(); // print m_b: 1 with vs2008 & gcc 4.4.3

This is because, af is nothing but the temporary object's reference which was constructed passing 1 to it's constructor.

Answer 2

What you see is guaranteed by the Standard.

C++03 12.2 Temporary objects:

The second context is when a reference is bound to a temporary. The temporary to which the reference is bound or the temporary that is the complete object to a subobject of which the temporary is bound persists for the lifetime of the reference except as specified below...

[Example:

class C {
    // ...
public:
    C();
    C(int);
    friend C operator+(const C&, const C&);
    ˜C();
};
C obj1;
const C& cr = C(16)+C(23);
C obj2;

..a third temporary T3 to hold the result of the addition of these two expressions. 
The temporary T3 is then bound to the reference cr..The temporary T3 bound to the
reference cr is destroyed at the end of cr’s lifetime, that is, at the end of the
program. 

—end example]