基础知识 求解

[mubeiliulang]

int i;
for (i= 0; i < 9; ++i)
  int c = i;
 

请问这个C是同一个，还是不停变化的

[caewow]

是同一个 c ，不信的话可用下面的代码检测：

    int i;
	for(i=0;i<10;i++)
	{
		int c=i;
		cout<<&c<<endl;
	}

可以看到，每次 c 的地址都是一样的。 不过，不推荐这么写代码。因为这样写的话， c 的作用域范围是很有限的，在 for 循环外面 c 就被析构了。

[Morrisss_]

引用 2 楼 crestine 的回复:

是同一个 c ，不信的话可用下面的代码检测：

    int i;
	for(i=0;i<10;i++)
	{
		int c=i;
		cout<<&c<<endl;
	}

可以看到，每次 c 的地址都是一样的。 不过，不推荐这么写代码。因为这样写的话， c 的作用域范围是很有限的，在 for 循环外面 c 就被析构了。

编译器优化的吧。。。要是是同一个，每次进入循环都再定义一次，绝对违背单定义规则了。

[lizadana]

for (int i= 0; i < 9; ++i) int c = i; 等价于 for (int i= 0; i < 9; ++i){ int c = i;} i=0时，int c=i即，声明了c，也初始化为i，为0，也完成了定义； i=1开始，c已经声明了，也初始化了，int c = i此时仅仅是赋值操作； 余同。

[max_min_]

不同的，一次循环后，就释放了，然后循环又重新申请了的

[Morrisss_]

引用 4 楼 u013084973 的回复:

for (int i= 0; i < 9; ++i) int c = i; 等价于 for (int i= 0; i < 9; ++i){ int c = i;} i=0时，int c=i即，声明了c，也初始化为i，为0，也完成了定义； i=1开始，c已经声明了，也初始化了，int c = i此时仅仅是赋值操作； 余同。

都说了是编译器优化的问题，你可以测试下面的这段代码：

#include <iostream>

int main()
{
    int c = 10;
    for (int i = 0; i < 10; i++) {
        std::cout << &c << std::endl;
        int c = i;
        std::cout << &c << std::endl;
    }

    return 0;
}

照你说的后面的都只是声明，那么显然，除了第一次进入循环的时候c的地址不同，其余次数的地址都应该是相同的！

[lhrlong]

不是同一个，跟踪代码显示在当前循环结束时C的值并没有更新（C所在的地址的值更新了），下次循环分配的C的地址跟上一次还是一样的，不知道是怎么回事？不知道有谁能够解答

[Morrisss_]

引用 7 楼 lhrlong 的回复:

不是同一个，跟踪代码显示在当前循环结束时C的值并没有更新（C所在的地址的值更新了），下次循环分配的C的地址跟上一次还是一样的，不知道是怎么回事？不知道有谁能够解答

编译器优化的问题。

[Falleyes]

变量的生命周期问题，每个变量的声明周期只局限于声明他的语块。

[赵4老师]

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构…… 对学习编程者的忠告： 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步对应汇编一行！ 单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。 VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）

[lizadana]

// cpptest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include <iostream>
int _tmain(int argc, _TCHAR* argv[])
{
	for (int i = 0; i < 9; ++i)
	{
		int c = i;
		std::cout << &c << std::endl;
	}

	return 0;
}

microsoft visual studio ultimate 2013 运行结果 C：\windows\system32\cmd.exe窗口里 001DFD0C 001DFD0C 001DFD0C 001DFD0C 001DFD0C 001DFD0C 001DFD0C 001DFD0C 001DFD0C 请按任意键继续. . .

[middzwb]

受教了。。。

[阿佳夕]

怎么可能是同一个呢，即使是每次C的地址都一样，那也是巧合，因为那个地址没有被占用，每次释放掉又重新被C占用。每循环一次都会创建和销毁一次C

[纹枰老妖]

引用 13 楼 yuzhenxiong0823 的回复:

怎么可能是同一个呢，即使是每次C的地址都一样，那也是巧合，因为那个地址没有被占用，每次释放掉又重新被C占用。每循环一次都会创建和销毁一次C

同意仁兄的看法，每次进入循环时，机器都会重新“产生”出一个c，并为c开辟存储位置【但极可能每次c的存储位置都在同一个地方】

[ForestDB]

每次进入一个迭代，定义一个变量c，出这个迭代，变量c就“消失” 再次定义，是个新的c，和原来的没关系，哪怕它和原来的c在同一个地方（内存地址） 过分强调编译器优化的那位，可以从哲学／辩证法的角度来看这个问题，每次的c，从逻辑上来看，彼非此的。 另外你会有这样的“错觉”，一个原因就是这里在用原始类型int来讨论，如果用类类型（对象）的观点来看，就能知道，每次其实是不同的对象，见如下的例子： # include <iostream> using namespace std; class foo { int i; public: foo(int i) { this->i = i; cout << "construct " << i << endl; } ~foo() { cout << "destruct " << i << endl; } }; int main() { for (int i = 0; i < 10; i++) { foo obj(i); cout << & obj << endl; } return 0; } construct 0 0x7fff5fbffaa0 destruct 0 construct 1 0x7fff5fbffaa0 destruct 1 construct 2 0x7fff5fbffaa0 destruct 2 construct 3 0x7fff5fbffaa0 destruct 3 construct 4 0x7fff5fbffaa0 destruct 4 construct 5 0x7fff5fbffaa0 destruct 5 construct 6 0x7fff5fbffaa0 destruct 6 construct 7 0x7fff5fbffaa0 destruct 7 construct 8 0x7fff5fbffaa0 destruct 8 construct 9 0x7fff5fbffaa0 destruct 9 所以说对象的地址一样，并不能说这就是同一个对象

[点不亮的黑色]

数值会不断变化的。。。

[xy8366033]

不是一个地址。变量是在循环中不同创建的，不断创建和析构的。只是你在重复这个动作，所以申请的地址也是一样的。但你再进入第二次的时候，变量已经没有值了。你可以下面测试： for(int i =0;i<9;i++) { std::cout<<c; int c= i; } 这样绝对会报错，所以不是同一个，只是在反复新建和析构名字为C的变量而已。

[xy8366033]

引用 19 楼 xy8366033 的回复:

不是一个地址。变量是在循环中不同创建的，不断创建和析构的。只是你在重复这个动作，所以申请的地址也是一样的。但你再进入第二次的时候，变量已经没有值了。你可以下面测试： for(int i =0;i<9;i++) { std::cout<<c; int c= i; } 这样绝对会报错，所以不是同一个，只是在反复新建和析构名字为C的变量而已。

说错了，地址可能是一样的，但变量是不一样的。因为可能你当前电脑没其他程序申请新地址。有时间可以看下内存分配原理。

[风吹得好舒服]

不是同一个。@oYinGui1说得非常的清楚。

[赵4老师]

引用 14 楼 ForestDB 的回复:

每次进入一个迭代，定义一个变量c，出这个迭代，变量c就“消失” 再次定义，是个新的c，和原来的没关系，哪怕它和原来的c在同一个地方（内存地址） 过分强调编译器优化的那位，可以从哲学／辩证法的角度来看这个问题，每次的c，从逻辑上来看，彼非此的。 另外你会有这样的“错觉”，一个原因就是这里在用原始类型int来讨论，如果用类类型（对象）的观点来看，就能知道，每次其实是不同的对象，见如下的例子： # include <iostream> using namespace std; class foo { int i; public: foo(int i) { this->i = i; cout << "construct " << i << endl; } ~foo() { cout << "destruct " << i << endl; } }; int main() { for (int i = 0; i < 10; i++) { foo obj(i); cout << & obj << endl; } return 0; } construct 0 0x7fff5fbffaa0 destruct 0 construct 1 0x7fff5fbffaa0 destruct 1 construct 2 0x7fff5fbffaa0 destruct 2 construct 3 0x7fff5fbffaa0 destruct 3 construct 4 0x7fff5fbffaa0 destruct 4 construct 5 0x7fff5fbffaa0 destruct 5 construct 6 0x7fff5fbffaa0 destruct 6 construct 7 0x7fff5fbffaa0 destruct 7 construct 8 0x7fff5fbffaa0 destruct 8 construct 9 0x7fff5fbffaa0 destruct 9 所以说对象的地址一样，并不能说这就是同一个对象

白马非马论。 人不可能同时踏入同一条河流。

[xiaoqiangy2012]

引用 3 楼 oYinGui1 的回复:

[quote=引用 2 楼 crestine 的回复:] 是同一个 c ，不信的话可用下面的代码检测：

    int i;
	for(i=0;i<10;i++)
	{
		int c=i;
		cout<<&c<<endl;
	}

可以看到，每次 c 的地址都是一样的。 不过，不推荐这么写代码。因为这样写的话， c 的作用域范围是很有限的，在 for 循环外面 c 就被析构了。

编译器优化的吧。。。要是是同一个，每次进入循环都再定义一次，绝对违背单定义规则了。[/quote] 楼上说的没错，如果在中间某一次循环的过程中，有别的变量占用了这个内存地址的话，c的地址应该就会不一样了