C ++参考如何工作 | 码农家园

How C++ reference works

在C++工作了15年之后，我发现我完全不了解参考文献。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

class TestClass
{
public:
TestClass() : m_nData(0)
{
}

TestClass(int n) : m_nData(n)
{
}

~TestClass()
{
cout <<"destructor" << endl;
}

void Dump()
{
cout <<"data =" << m_nData <<" ptr = 0x" << hex << this << dec << endl;
}

private:
int m_nData;
};

int main()
{
cout <<"main started" << endl;

TestClass& c = TestClass();
c.Dump();

c = TestClass(10);
c.Dump();

cout <<"main ended" << endl;

return 0;
}

// prints:
// main started
// data = 0 ptr = 0x0012FF54
// destructor
// data = 10 ptr = 0x0012FF54
// main ended
// destructor

我从这个测试中了解到，testclass实例是在堆栈上创建的(这是正确的吗？)并由第一个testclass构造函数初始化。当分配这个实例时：加载主函数或执行引用分配时？当它被摧毁？

第二次引用分配后，对象地址不变。这是否意味着析构函数和构造函数被应用到同一个内存区域？或者内存被释放(动态地？在堆栈上？)又分配了吗？

我知道关于栈和堆分配对象生存期的所有信息，它们的构造函数和析构函数。但我不能理解这个程序到底发生了什么。

编辑：谢谢大家。我试图在这个测试中重现一些其他(更复杂的)程序行为。你的评论帮助我理解了我的错误和我正在与之斗争的另一个计划…

固定码为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int main()
{
cout <<"main started" << endl;
TestClass t;

TestClass& c(t);
c.Dump();

c = TestClass(10);
c.Dump();

cout <<"main ended" << endl;
return 0;
}

相关讨论

这段代码无法编译。不能将非常量引用绑定到临时引用。
有没有实现不将自动对象放在堆栈上的C++实现？如果是，他们是哪一个？
你用哪一个编译器来编译它？它不应该编译。
@杰里米：没有，这在逻辑上是不可能的。令人费解的是，那些传播城市神话的人并不都是白痴。我无法解释他们为什么这样做，除了可能是因为苏格兰人和人行道发生性关系而被判刑，这只是莫名其妙的行为。
@Alf P.Steinbach它不是Cray上的堆栈：它是"堆栈"帧的链接列表，alloca()的一些实现的源代码带有与之兼容的伤疤。
它是一个非标准的msvc扩展，使用/w4编译以获得c4239。有一些矫揉造作的人正在进行这项工作，看起来有一些参考交换，以安全地销毁第一个实例。不能说我真的看到了它的工作原理。
只是术语而已。尤其是一种我称之为"律师说话"的味道。你会在ISO标准中发现它的重要性，因为它是一个专门设计的术语，可以使语句在未来几十年内保持不变，而不管实现细节如何。我可能只有几年的经验，但这不是我计划永远担心的事情。
亚历克斯：C++中重要的是对象是否被自动或动态分配，因为这决定了对象的生存期。自动对象在相关范围结束时自动死亡，而动态对象的生存期由用户控制(因此以手动删除结束)。无论变量的内存在堆栈上还是堆上都不那么重要(事实上，如果需要的话，您可以将一个动态对象放到堆栈上)，这对您理解语言没有真正的帮助。
@Kerrek：用一般的实用术语来说，当您声明可以将动态对象放到堆栈上时，您是错的。只是文字游戏。例如，在堆栈的某个缓冲区中进行就地分配，这不是我们通常所说的动态分配。
@阿尔夫：当然可以。埃多克斯1〔1〕。它是一个动态对象，我必须管理它的生命周期，它在堆栈中。同样，如果我愿意，我可以将动态对象放入静态内存中。这没什么不自然的。它不是"动态分配"，而是"动态存储对象"。我想我很小心不要说"动态分配"，也不要说"动态对象"。分配是指内存，以及对象的构造。
@Alf P.Steinbach我承认，不管编译器选择的内存布局——是否是单调地址的帧序列——它都是以后进先出的方式访问的，应该称为"堆栈"。而且，Cray源代码也这么称呼它。
@阿尔夫：这不是逻辑上不可能的。可以想象，实现可以通过对每个自动对象的malloc的后台调用动态分配内存。(当然，我一点也不暗示存在这样的编译器，只是它在逻辑上并非不可能。)
@阿尔夫：为什么不符合标准？标准中唯一提到"栈"的地方是"栈展开"的上下文中的异常，这是一个方便的短语，而不是一个实现需求。如果"stack"是指每个嵌套函数调用都有自己的自动变量作用域的一般概念，那么是的，它总是一个堆栈。
@奥利：举个例子，"栈展开"，你认为是哪个栈被展开了。它是自动分配对象和返回地址的堆栈。你有大约5万个代表点，所以，这意味着你不是一个完全的新手。因此，当您假装不知道堆栈需求时，以及当您假装不知道堆栈展开是堆栈展开时，都是在撒谎。
@阿尔夫：你说得对，我完全知道"堆栈展开"的含义。但我要小心区分行为和该行为的实现。行为是嵌套的作用域；其一个实现是通过传统的堆栈机制实现的。
@奥利：你不"小心区分行为和实现"。相反，你把它们混为一谈了。既然这已经转移到关于你先前论点的争论上，而不是重复错误的愚蠢的技术断言，我将停止回应。
@阿尔夫·P·斯坦巴赫：我不明白你的个人战争与我的问题有什么关系……
@亚历克斯：把这称为"个人战争"是对我个人的攻击。它通常被称为自动寻的攻击，一种试图传达一个人的印象的论点，而不是与技术事实或逻辑有关。我不记得曾和你讨论过任何事情，也不记得与你有任何关系，我怀疑，例如，奥利会非常高兴你的广告总部试图帮助，如果这是什么。
我不想帮助任何人，只是想知道我的问题为什么会引起如此情绪化的讨论。
@阿尔夫：同意，这是行不通的；这只是一个关于定义的争论。但总的来说，我不认为函数作用域通常是通过物理堆栈机制实现的这一事实意味着这种行为的所有其他实现也应该称为堆栈。
请保持建设性的意见和主题。

你的问题与患者或从多个代码最终会使意识。然而，Let’s黑客通过它。

1)你只能暂时绑定到const引用，从而延长其寿命。

1	const TestClass & c = TestClass();

2)现在我们不能使用，因为你不dump宣布，它const：

1	void Dump() const

(3)在一个c = TestClass()分配。然而，现在c参考到一个常量，不能被分配到分配的，因为是非恒定的(明显的原因)。在这个黑客：Let’s

1	const_cast<TestClass&>(c) = TestClass(10);

现在，我们已经指定新的值到该临时对象的可扩展的c和所有它应该是：

1
2
3
4
5
6

main started
data = 0 ptr = 0x0xbfa8219c
destructor
data = 10 ptr = 0x0xbfa8219c
main ended
destructor

该指针是相同的，因为只有一个目标，即通过一个相关的c(临时)。它是一assigning(这是未定义行为，在一般情况下，我们用它去，但这个演示的目的。

中间函数的第二TestClass(10)那是临时的。

1)你不能让非const引用临时对象。

2)在网络(10)；c＝TestClass)一个被称为算子(？)

1	TestClass& c = TestClass();

这不是甚至重新编译！

对临时attempting绑定到非const引用将导致编译错误。

然而，你可以暂时绑定到const引用。

1
2
3
4
5

{
const TestClass& c = TestClass();
//use c
//....
}//<-------- the temporary will be destroyed here.

在这个案例的生命的延伸，在临时的寿命的参考，即当参考变量超出范围的推移，临时将显示在M。