我有以下代码：
class T {};
class container {
const T &first, T &second;
container(const T&first, const T & second);
};
class adapter : T {};
container(adapter(), adapter());
我曾以为常量引用的生命周期将是容器的生命周期。
然而，事实并非如此，适配器对象在容器创建后被销毁，留下了悬空引用。
正确的生命周期是什么？
适配器临时对象的堆栈范围是容器对象还是容器构造函数？
如何正确地将临时对象绑定到类成员引用？
谢谢
adapter a, b;
container(a, b); // lifetime is the lifetime of a and b
最好的做法是，除非对象非常密切相关且绝对不是暂时性的，在极其紧急的情况下，不要使用对类成员的常量引用。
引用将在container的整个生命周期内存在，但是所引用的对象只会在该对象的生命周期内存在。在这种情况下，您已将引用绑定到具有自动存储分配（“堆栈分配”，尽管这不是C++术语）的临时对象上。因此，您不能指望临时对象存在于编写它的语句之外（因为在调用container的构造函数之后立即超出作用域）。处理此问题的最佳方法是使用复制而不是引用。由于您无论如何都使用了const引用，因此它将具有类似的语义。
您应该将类重新定义为：
template<typename T>
class container
{
public:
container(const T& first, const T& second) : first(first), second(second) {}
private:
const T first;
const T second;
};
或者，您可以给对象命名以防止它们超出作用域：
adaptor first; adaptor second; container c(first,second);
但是，我认为这不是一个好主意，因为诸如return c之类的语句是无效的。
编辑
如果您的目标是共享对象以避免复制成本，那么您应该考虑使用智能指针对象。例如，我们可以使用智能指针重新定义您的对象如下：
template<typename T>
class container
{
public:
container(const boost::shared_ptr<const T>& first, const boost::shared_ptr<const T>& second) : first(first), second(second) {}
private:
boost::shared_ptr<const T> first;
boost::shared_ptr<const T> second;
};
然后您可以使用以下代码：
boost::shared_ptr<const adaptor> first(new adaptor); boost::shared_ptr<const adaptor> second(new adaptor); container<adaptor> c(first,second);
或者，如果您想在本地拥有first和second的可变副本：
boost::shared_ptr<adaptor> first(new adaptor); boost::shared_ptr<adaptor> second(new adaptor); container<adaptor> c(boost::const_pointer_cast<const adaptor>(first),boost::const_pointer_cast<const adaptor>(second));
如果您想避免复制，那么我想容器必须自行创建存储的实例。
如果您想调用默认构造函数，那么应该没有问题。只需调用Container的默认构造函数即可。
如果您想调用所包含类型的非默认构造函数，那么可能会更棘手。C ++ 0x将有更好的解决方案。
作为一种练习，容器可以接受T或包含T构造函数参数的对象。这仍然依赖于RVO（返回值优化）。
template <class T1>
class construct_with_1
{
T1 _1;
public:
construct_with_1(const T1& t1): _1(t1) {}
template <class U>
U construct() const { return U(_1); }
};
template <class T1, class T2>
class construct_with_2
{
T1 _1;
T2 _2;
public:
construct_with_2(const T1& t1, const T2& t2): _1(t1), _2(t2) {}
template <class U>
U construct() const { return U(_1, _2); }
};
//etc for other arities
template <class T1>
construct_with_1<T1> construct_with(const T1& t1)
{
return construct_with_1<T1>(t1);
}
template <class T1, class T2>
construct_with_2<T1, T2> construct_with(const T1& t1, const T2& t2)
{
return construct_with_2<T1, T2>(t1, t2);
}
//etc
template <class T>
T construct(const T& source) { return source; }
template <class T, class T1>
T construct(const construct_with_1<T1>& args)
{
return args.template construct<T>();
}
template <class T, class T1, class T2>
T construct(const construct_with_2<T1, T2>& args)
{
return args.template construct<T>();
}
template <class T>
class Container
{
public:
T first, second;
template <class T1, class T2>
Container(const T1& a = T1(), const T2& b = T2()) :
first(construct<T>(a)), second(construct<T>(b)) {}
};
#include <iostream>
class Test
{
int n;
double d;
public:
Test(int a, double b = 0.0): n(a), d(b) { std::cout << "Test(" << a << ", " << b << ")\n"; }
Test(const Test& x): n(x.n), d(x.d) { std::cout << "Test(const Test&)\n"; }
void foo() const { std::cout << "Test.foo(" << n << ", " << d << ")\n"; }
};
int main()
{
Test test(4, 3.14);
Container<Test> a(construct_with(1), test); //first constructed internally, second copied
a.first.foo();
a.second.foo();
}
不要这样做。临时变量在创建它的表达式结束后立即被销毁（除非它立即绑定到引用，此时它是引用的作用域）。生命周期不能延长到类的生命周期。
这就是为什么我从不将成员存储为引用 - 只复制对象或指针。对我来说，指针使得生命周期变得明显。特别是在构造函数的情况下，你的构造函数参数必须比类本身的寿命更长，这一点并不明显。
struct container { const &adapter a; container() : a(adapter()) {} };这样的东西。 - Steve Jessop