[此贴子已经被作者于2004-12-21 02:34:26编辑过]

const的意思是“常量”，的确有这么一层意思； 我还看过有的书上说const是constant（不变的）的缩写。 ——不管，不玩文字。 A:常规用法：用const定义常量； 如：const int A=100; 相当与：#define A 100; B：const与指针： 1、const int *p; p是指向const int的指针，所以不能用赋值语句对*p赋值；但可以对p本身赋值。 如：int c;p=&c; 是正确的，而 int c; *p=c; 就错了。 2、int * const p=&i; p是指向int的const指针。p是const数据，所以其本身不可改变，而*p可以被赋值。 （注意和const int *p；的区别。）p被初始化为i的地址，i是变量，这是*p可赋值的原因。 3、const int * const p=&i; p是一个const指针，其指向const数据i。p、*p都不能再被赋值。 可以在初始化p指针时对其初始化。

分析： double d; const double cd=20.5; cosnt double *pcd; double *const cpd1=&d; double *const cpd2=&cd;

pcd=&d; *pcd=2.5; pcd=&cd;

那么，对于函数呢？ const int f(); int f(const int i); int f(const int *p); int f(int * const p); int f(int *p const); int f(int i) const;

const int f(); 没有参数，返回值是一个 const int 型的函数 int f(const int i); 只有一个参数，类型是 const int，返回值是一个 int 型的函数

int f(const int *p); 只有一个参数，类型是 const int*，返回值是一个 int 型的函数

int f(int * const p); 只有一个参数，类型是 int* const，返回值是一个 int 型的函数

int f(int i) const; 只有一个参数，类型是 int，返回值是一个 int 型的函数 该函数是一个某个类的成员函数，并且不能直接修改对象中的数据。

int f(int *p const); 这个没有见过，不知道。

最后一个int f(int i) const; 用于类内成员函数 class A{ int i_; public: int f(int i) const{ // 在函数内不能改变类里的成员变量 return i_+i; // error return i; } };

1. const int i = 0;//表示i的值不能再改变。且一开始就要初始化。 2. const int* i；//表示*i的值不能改变。但i的值能改变。不用一开始就初始化。 int d = 4 , e = 5; i=&d ;//ok; *i = 9 //error; 3. int* const i //指针值不能改变。 *i = 3 //ok； i = &d //error; const int a[2] = {1,2}; int*g = &a[1] //error &a[1]为const int*;注意const type 不能给 type； 4. const int* const i;//指针和指向的值都不能改变； 5. const int& i =d; i++ //error; 6. 没有 int& const i这种形式//因为引用一旦初始化后，就不能再改变； int& i =d; 7. void f(const int i);// 对于内部结构const int i 没什么意义。 8. void f(const int* i); int i = 8; f(&i) //可以保证i不被改变。 9. const int f(); //对于内部结构没意义。 int d = f(); d++;//ok 10.const int* f(); int* i = f() //error; const int * i = f() //ok;//它返回地址是一个常量地址，所以不能给变量地址； 11.int* const f(); int* i = f() //ok; 12.const int* const f(); int* i = f() //error; const int* i = f() //ok;(1) const int* const i = f() //ok; 对与一为什么可以编译通过,是因为const int* i=f()把f()返回的地址复制给 i,但i指向的地址具const性. 所以int* i = f() //error;通不过.

13.关于类的const class test{ const int i; test(int j):i(j){} int f() const{ i++//error 不能改变i; return i; } int fa(){ i++; return i; } } const test t; t.fa()//error; t.f() //ok;

先看以下两个简单的程序：

第一： #include<iostream.h> void main() { int a=3; int *p=new int; p=&a; cout<<*p<<endl; delete p; //有错误 }

第二： #include<iostream.h> void main() { int a=3; int *p=new int; *p=a; cout<<*p<<endl; delete p; }

其中第一个程序存在错误(会生成.exe文件，但是运行有错误)，问题出在对new和delete、堆不是很了解。而第二个程序是正确的。现在我来分析一下： int *p=new int; 是在heap分配一个int型的空间，而p是在stack里的一个指针，它指向heap里的那个int，在程序结束的时候，p指针将被释放掉，所以要在程序结束的时候delete p,这是为了释放在heap里分配的那个int，否者会造成heap区空间的泄漏，这是很严重的。

第一个程序中的： p=&a; 它把a的地址赋给p，这时p指的是a，而不是heap里的那个int了，后来 delete p; 这是想删除p指向的内容，但是此时p指向的是stack里的a，而delete是不能用于stack的数据的，所以出错。

第二个程序中的： *p=a; 这只是将a的值赋给p指向的那个int，此时p还是指向heap里的int， 所以这里的 delete p； 是合法的，不会出错。

[此贴子已经被作者于2004-12-04 14:44:50编辑过]

[问题] C++中创建本地（或者说局域）变量是在堆栈（stack）中分配内存地址，而创建全局变量则是在堆（heap）中分配内存地址。 我想知道什么是堆（heap）？为什么全局变量和本地变量在分配内存地址时要分别对待，堆和堆栈那一个更有效率？

[回答] 在Window中执行的每一个应用程序都有其自己的内存地址。一部分内存空间用于存放程序代码，一部分内存空间用于存放程序执行期间 创建的变量。创将变量的方法有两种，一种是在堆中，另外一种则在堆栈里。

理解堆的最好的方法是将它看成一个程序随时可以使用的内存块。为了创建堆变量，程序要使用“new”（在C++里）操作符或者 “malloc”（在C中）例程，它们返回指向变量的指针（堆变量总是通过指针来处理和操作）。最后程序用“delete”（在C++里）操作符 或者“free”（在C中）例程来删除或者释放内存空间。

而堆栈则不同，它是某个函数被调用后随时可以创建的一小块内存，被用于在函数范围内保存变量（也称为自动变量）。在函数中，任何 包含在{}内的代码都有其自己的堆栈。当这个函数或者{}退出时，堆栈以及它包含的所有内容都被摧毁。因此下面的代码是不运行的：

void Myfunction() { int i = 5;

{ int j = 6; }

int k = i+j; }

所以本文问题的答案是：使用堆栈（stack）分配本地或者局域变量的地址空间，而用堆（heap）分配大块内存地址或者动态创建对象的情形。 例如：

void MyFunction() { int i = 5; // 堆栈中的本地(自动)变量 int *iArray; // 堆栈中的本地(自动)变量

iArray = new int[10000]; // 这一行代码将在堆中创建10000个元素的数组，由iArray指向其地址

for (int k = 0; k < 10000 ; k++) { iArray[k] = k + i; cout << iArray[k] << "\n"; }

delete iArray; // 从堆中删除或释放数组占用的地址空间，否则将会有内存泄漏

} //函数结束

注意：iArray 不是一个堆变量。它是一个局部指针变量，指向堆中未命名的一个数组

昏哦。。版主 你还的我 20 分没了。。点下载什么东西都没有。。。我还以为是网速慢。。。。哎 。。。。

还有，我下载过了，有东西的，如下：

本附件大小为6KB，下载本附件需要花费10点积分,是否要下载？