5

在问这个问题时，我了解到对临时对象的 const 引用在 C++ 中是有效的：

int main ()
{
  int a = 21;
  int b = 21;

  //error: invalid initialization of non-const reference
  //int     & sum = a + b;e [...]

  //OK
  int const & sum = a + b;

  return sum;
}

但在下面的示例中， const 引用refnop指的是已销毁的临时对象。我想知道为什么？

#include <string>
#include <map>

struct A
{
   // data 
   std::map <std::string, std::string>  m;
   // functions
   const A& nothing()           const { return *this;    }
   void init()                        { m["aa"] = "bb";  }
   bool operator!= (A const& a) const { return a.m != m; }
};

int main()
{
  A a;
  a.init();

  A const& ref    = A(a);
  A const& refnop = A(a).nothing();

  int ret = 0;
  if (a != ref)     ret += 2;
  if (a != refnop)  ret += 4;

  return ret;
}

使用 GCC 4.1.2 和 MSVC 2010 测试，它返回 4；

$> g++ -g refnop.cpp
$> ./a.out ; echo $?
4

ref和之间的区别在于实际上什么都不做refnop的调用。nothing()似乎在这个调用之后，临时对象被破坏了！

我的问题：
为什么在 的情况下refnop，临时对象的生命周期与其 const 引用不同？

4

2 回答 2

11

当临时对象绑定到第一个引用时，临时对象的生命周期扩展只能执行一次。在那之后，引用指向一个临时对象的知识就消失了，因此进一步的生命周期扩展是不可能的。

让你困惑的案例

A const& refnop = A(a).nothing();

类似于这种情况：

A const& foo(A const& bar)
{
    return bar;
}
//...
A const& broken = foo(A());

在这两种情况下，临时变量都绑定到函数参数（隐式thisfor nothing()，barfor foo()）并将其生命周期“延长”到函数参数的生命周期。我把“扩展”放在引号中，因为临时的自然生命周期已经更长了，所以没有实际的扩展发生。

因为生命周期扩展属性是不可传递的，所以返回一个引用（碰巧引用一个临时对象）不会进一步延长临时对象的生命周期，结果是两者都refnop引用broken了不再存在的对象。

于 2013-06-21T12:09:11.243 回答
1

我原来的例子很复杂。

因此，我在这里发布一个更简单的示例，并提供相应的ISO C++ 标准段落。

这个更简单的示例也可以在coliru.stacked-crooked.com/上找到

#include <iostream>

struct A
{
  A(int i) { std::cout<<"Cstr "<< i<<'\n'; p = new int(i); }
 ~A()      { std::cout<<"Dstr "<<*p<<'\n'; delete p;       }

  const A& thiz() const { return *this; }

  int *p;
};

const A& constref( const A& a )
{
  return a;
}

int main()
{
  const A& a4 = A(4);
  const A& a5 = A(5).thiz();
  const A& a6 = constref( A(6) );

  std::cout << "a4 = "<< *a4.p <<'\n';
  std::cout << "a5 = "<< *a5.p <<'\n';
  std::cout << "a6 = "<< *a6.p <<'\n';
}

使用命令行的输出g++-4.8 -std=c++11 -O2 -Wall -pedantic -pthread main.cpp && ./a.out： 

Cstr 4
Cstr 5
Dstr 5
Cstr 6
Dstr 6
a4 = 4
a5 = 0
a6 = 0
Dstr 4

如您所见，由a5和引用的临时对象a6在函数的末尾分别被销毁thiz和constref。

这是§12.2 Temporary objects的摘录，其中粗体部分适用于这种情况：

第二个上下文是引用绑定到临时的。引用绑定到的临时对象或作为引用绑定到的子对象的完整对象的临时对象在引用的生命周期内持续存在，但以下情况除外：

  • 临时绑定到构造函数的 ctor-initializer (12.6.2) 中的引用成员将持续存在，直到构造函数退出。
  • 临时绑定到函数调用 (5.2.2) 中的引用参数将持续存在，直到包含调用的完整表达式完成。
  • 临时绑定到函数返回语句 (6.6.3) 中的返回值的生命周期不会延长；临时在 return 语句中的完整表达式的末尾被销毁。
  • 临时绑定到new-initializer (5.3.4) 中的引用，直到包含new-initializer的完整表达式完成为止。

这是一个更完整的例子：

#include <iostream>

struct A
{
     A()         { std::cout<<"Cstr 9\n";         p = new int(v = 9);      }
     A(int i)    { std::cout<<"Cstr "<<i<<'\n';   p = new int(v = i);      }
     A(const A&o){ std::cout<<"Copy "<<o.v<<'\n'; p = new int(v = 10+o.v); }
    ~A()         { std::cout<<"Del "<<v<<' '<<*p<<'\n'; *p = 88; delete p; }

    const A& thiz() const { return *this; }

    int *p;
    int  v;
};

const A& constref( const A& a )
{
  return a;
}

std::ostream& operator<<( std::ostream& os, const A& a )
{
  os <<"{ *p="<< *a.p <<" , v="<< a.v <<" }\n";
  return os;
}

int main()
{
    std::cout << "---const A  a1 = A(1)"                "\n";
                     const A  a1 = A(1);
    std::cout << "---const A  a2 = A(2).thiz()"         "\n";
                     const A  a2 = A(2).thiz();
    std::cout << "---const A  a3 = constref( A(3) )"    "\n";
                     const A  a3 = constref( A(3) );
    std::cout << "---const A& a4 = A(4)"                "\n";
                     const A& a4 = A(4);
    std::cout << "---const A& a5 = A(5).thiz()"         "\n";
                     const A& a5 = A(5).thiz();
    std::cout << "---const A& a6 = constref( A(6) )"    "\n";
                     const A& a6 = constref( A(6) );

    std::cout << "a1 = "<< a1;
    std::cout << "a2 = "<< a2;
    std::cout << "a3 = "<< a3;
    std::cout << "a4 = "<< a4;
    std::cout << "a5 = "<< a5;
    std::cout << "a6 = "<< a6;
}

g++以及使用相同命令行的相应输出：

---const A  a1 = A(1)
Cstr 1
---const A  a2 = A(2).thiz()
Cstr 2
Copy 2
Del 2 2
---const A  a3 = constref( A(3) )
Cstr 3
Copy 3
Del 3 3
---const A& a4 = A(4)
Cstr 4
---const A& a5 = A(5).thiz()
Cstr 5
Del 5 5
---const A& a6 = constref( A(6) )
Cstr 6
Del 6 6
a1 = { *p=1 , v=1 }
a2 = { *p=12 , v=12 }
a3 = { *p=13 , v=13 }
a4 = { *p=4 , v=4 }
a5 = { *p=0 , v=5 }
a6 = { *p=0 , v=6 }
Del 4 4
Del 13 13
Del 12 12
Del 1 1
于 2014-06-13T16:34:07.207 回答