引用的问题______一个引用什么时候被销毁

[csdn_jzy]

1、当一个变量声名为另一个变量的引用时(如:int count=9;int& refcout=count),那么作为引用的变量refcout是什么时候被销毁的，是不是当count销毁时，refcout就销毁了？
2、在堆栈中分配一段内存空间：Csimple *p=new Csimple();（设Csimple为已经 声名的类）然后将其与一个引用关联如：Csimple＆ refsimple=*p。当使用delete p
操作时引用refsimple就会出现空引用的危险。那么如果直接将引用和一个Csimple对象关联，当这个对象销毁时就不会出现空引用出现的危险，怎么解释？

[yuanhen]

1. count销毁时，refcout所引用的对象被销毁了，如果要操纵refcout就是未定义的行为
2. 是这样的吗？

[darkhawk]

1.引用的生存期和引用的变量的生存期是一致的.
2.不提倡使用引用到一个可能为空的指针变量,除非能保证引用的指针变量确实在引用的使用期间不为空,尤其注意不要用如下方式引用
A *P = NULL;
A &ref = *p;

[maxcai]

up

[luohualiushui]

--------------------------------------------------------------------------------



条款31: 千万不要返回局部对象的引用，也不要返回函数内部用new初始化的指针的引用

本条款听起来很复杂，其实不然。它只是一个很简单的道理，真的，相信我。

先看第一种情况：返回一个局部对象的引用。它的问题在于，局部对象 ----- 顾名思义 ---- 仅仅是局部的。也就是说，局部对象是在被定义时创建，在离开生命空间时被销毁的。所谓生命空间，是指它们所在的函数体。当函数返回时，程序的控制离开了这个空间，所以函数内部所有的局部对象被自动销毁。因此，如果返回局部对象的引用，那个局部对象其实已经在函数调用者使用它之前被销毁了。

当想提高程序的效率而使函数的结果通过引用而不是值返回时，这个问题就会出现。下面的例子和条款23中的一样，其目的在于详细说明什么时候该返回引用，什么时候不该：

class rational { // 一个有理数类
public:
rational(int numerator = 0, int denominator = 1);
~rational();

...

private:
int n, d; // 分子和分母

// 注意operator* (不正确地)返回了一个引用
friend const rational& operator*(const rational& lhs,
const rational& rhs);
};

// operator*不正确的实现
inline const rational& operator*(const rational& lhs,
const rational& rhs)
{
rational result(lhs.n * rhs.n, lhs.d * rhs.d);
return result;
}

这里，局部对象result在刚进入operator*函数体时就被创建。但是，所有的局部对象在离开它们所在的空间时都要被自动销毁。具体到这个例子来说，result是在执行return语句后离开它所在的空间的。所以，如果这样写：

rational two = 2;

rational four = two * two; // 同operator*(two, two)


函数调用时将发生如下事件：

1. 局部对象result被创建。
2. 初始化一个引用，使之成为result的另一个名字；这个引用先放在另一边，留做operator*的返回值。
3. 局部对象result被销毁，它在堆栈所占的空间可被本程序其它部分或其他程序使用。
4. 用步骤2中的引用初始化对象four。

一切都很正常，直到第4步才产生了错误，借用高科技界的话来说，产生了"一个巨大的错误"。因为，第2步被初始化的引用在第3步结束时指向的不再是一个有效的对象，所以对象four的初始化结果完全是不可确定的。

教训很明显：别返回一个局部对象的引用。

"那好，"你可能会说，"问题不就在于要使用的对象离开它所在的空间太早吗？我能解决。不要使用局部对象，可以用new来解决这个问题。"象下面这样：

// operator*的另一个不正确的实现
inline const rational& operator*(const rational& lhs,
const rational& rhs)
{
// create a new object on the heap
rational *result =
new rational(lhs.n * rhs.n, lhs.d * rhs.d);

// return it
return *result;
}

这个方法的确避免了上面例子中的问题，但却引发了新的难题。大家都知道，为了在程序中避免内存泄漏，就必须确保对每个用new产生的指针调用delete，但是，这里的问题是，对于这个函数中使用的new，谁来进行对应的delete调用呢？

显然，operator*的调用者应该负责调用delete。真的显然吗？遗憾的是，即使你白纸黑字将它写成规定，也无法解决问题。之所以做出这么悲观的判断，是基于两条理由：

第一，大家都知道，程序员这类人是很马虎的。这不是指你马虎或我马虎，而是指，没有哪个程序员不和某个有这类习性的人打交道。想让这样的程序员记住无论何时调用operator*后必须得到结果的指针然后调用delete，这样的几率有多大呢？也是说，他们必须这样使用operator*：

const rational& four = two * two; // 得到废弃的指针；
// 将它存在一个引用中
...

delete &four; // 得到指针并删除

这样的几率将会小得不能再小。记住，只要有哪怕一个operator*的调用者忘了这条规则，就会造成内存泄漏。

返回废弃的指针还有另外一个更严重的问题，即使是最尽责的程序员也难以避免。因为常常有这种情况，operator*的结果只是临时用于中间值，它的存在只是为了计算一个更大的表达式。例如：

rational one(1), two(2), three(3), four(4);
rational product;

product = one * two * three * four;

product的计算表达式需要三个单独的operator*调用，以相应的函数形式重写这个表达式会看得更清楚：

product = operator*(operator*(operator*(one, two), three), four);

是的，每个operator*调用所返回的对象都要被删除，但在这里无法调用delete，因为没有哪个返回对象被保存下来。

解决这一难题的唯一方案是叫用户这样写代码：

const rational& temp1 = one * two;
const rational& temp2 = temp1 * three;
const rational& temp3 = temp2 * four;

delete &temp1;
delete &temp2;
delete &temp3;

果真如此的话，你所能期待的最好结果是人们将不再理睬你。更现实一点，你将会在指责声中度日，或者可能会被判处10年苦力去写威化饼干机或烤面包机的微代码。

所以要记住你的教训：写一个返回废弃指针的函数无异于坐等内存泄漏的来临。

另外，假如你认为自己想出了什么办法可以避免"返回局部对象的引用"所带来的不确定行为，以及"返回堆(heap)上分配的对象的引用"所带来的内存泄漏，那么，请转到条款23，看看为什么返回局部静态(static)对象的引用也会工作不正常。看了之后，也许会帮助你避免头痛医脚所带来的麻烦。

[csdn_jzy]

谢谢大家，但我想问的是，如果使用了new初始化的指针的引用，那么即使在程序结束时再使用delete 来防止内存泄漏，此时是不是就会出现引用所指向的对象为空的情况？

谢谢解答

[messagebox]

引用的生存期应该是<=引用的变量的生存期

[langzi8818]

我认为………………
就算他通过指针达到引用。但是他还是和指针所指的内容同时死

[hot1985]

up

[messagebox]

修改一下我的观点：
引用的生存期应该是==引用的变量的生存期

[jianjianzhang]

引用的一些规则如下：
（1）引用被创建的时候必须被初始化（指针则可以在任何时候被初始化）
（2）不能有NULL的引用，引用必须与合法的存储单元关联
（3）一旦引用被初始化，就不能改变引用的关系
所以，引用被销毁是在远变量被销毁的前提下进行的。

[luixui]

up

[thebigmouse]

引用和指针相似，仅仅是一个地址值，但它被编译器赋予了一些特殊的属性。
这样C++才可以堂而皇之的引入这个概念嘛：）
参考一下有关书籍上的解释吧！很难有人解释清楚的。