谈C/C++指针精髓

时间 2019-11-10

标签 c++ 指针精髓栏目 C&C++ 繁體版

原文原文链接

[摘要]

指针是C和C++语言编程中最重要的概念之一，也是最容易产生困惑并致使程序出错的问题之一。利用指针编程能够表示各类数据结构, 经过指针可以使用主调函数和被调函数之间共享变量或数据结构，便于实现双向数据通信；并能像汇编语言同样处理内存地址，从而编出精练而高效的程序。指针极大地丰富了Ｃ和C++语言的功能。 html

在本文中，主要分两部分对指针进行讨论。首先，基础篇讨论关于指针的内容和运算操做等，能够是读者对指针的知识有必定了解和认识；随后在使用篇中重点讨论指针的各类应用，揭破指针在平常编程中的精髓，从而使读者可以真正地了解、认识和使用指针。程序员

[关键字] C C++ 指针引用数组结构体类编程

第一篇:基础篇 数组

1.1指针的概念

谈到指针,它的灵活性和难控制性让许多程序员谈虎色变;但它的直接操做内存，在数据安全

操做方面有着速度快，节约内存等优势，又使许多C++程序员的深爱不以.那么指针到底是怎么样一个概念呢? 数据结构

其实, 指针就是一类变量，是一类包含了其余变量或函数的地址的变量。与其余变量所不一样的是，通常的变量包含的是实际的真实的数据,而指针是一个指示器，它告诉程序在内存的哪块区域能够找到数据。函数

好了,在这里咱们能够这样定义指针:指针是一类包含了其余变量或函数的地址的变量,它里面存储的数值被解释成为内存的地址. post

1.2指针的内容

简单讲,指针有四个方面的内容:即指针的类型,指针所指向的类型,指针的值,指针自己所测试

占有的内存区.下面咱们将分别阐述这些内容. spa

1.2.1指针的类型

从语法的角度看，指针的类型是指把指针声明语句中的指针名字去掉所剩下的部分。这是指针自己所具备的类型。例如：

int*ip; //指针的类型是int*

char*ip; //指针的类型是char*

int**ip; //指针的类型是int**

int(*ip)[5]; //指针的类型是int(*)[5]

1.2.2指针所指向的类型

当你经过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将把那片内存区里的内容当作什么类型来看待。从语法的角度看，指针所指向的类型是指针声明语句中的指针名字和名字左边的指针声明符*去掉所剩下的部分。例如：

int*ip; //指针所指向的类型是int

char*ip; //指针所指向的类型是char

int**ip; //指针所指向的类型是int*

int(*ip)[5]; //指针所指向的类型是int()[5]

1.2.3指针的值（或称指针所指向的内存区）

指针的值或者叫指针所指向的内存区或地址，是指针自己存储的数值，这个值将被编译器看成一个地址，而不是一个通常的数值。在32位程序里，全部类型的指针的值都是一个32位整数，由于32位程序里内存地址全都是32位长。指针所指向的内存区就是从指针的值所表明的那个内存地址开始，长度为sizeof(指针所指向的类型)的一片内存区。之后，咱们说一个指针的值是XX，就至关于说该指针指向了以XX为首地址的一片内存区域；咱们说一个指针指向了某块内存区域，就至关于说该指针的值是这块内存区域的首地址。

指针所指向的内存区和指针所指向的类型是两个彻底不一样的概念。在上例中，指针所指向的类型已经有了，但因为指针还未初始化，因此它所指向的内存区是不存在的，或者说是无心义的。

之后，每遇到一个指针，都应该问问：这个指针的类型是什么？指针指的类型是什么？该指针指向了哪里？

1.2.4指针自己所占有的内存区

指针自己所占有的内存区是指针自己占内存的大小，这个你只要用函数sizeof(指针的

类型)测一下就知道了。在32位平台里，指针自己占据了4个字节的长度。

指针自己占据的内存这个概念在判断一个指针表达式是不是左值时颇有用。

谈C/C++指针精髓（二）

2008-02-18 16:09 by 马伟, 4212 visits, 网摘, 收藏, 编辑

1.3指针与内存管理

利用指针你能够将数据写入内存中的任意位置，可是，一旦你的程序中有一个野指针("wild”pointer)，即指向一个错误位置的指针，你的数据就危险了—存放在堆中的数据可能会被破坏，用来管理堆的数据结构也可能会被破坏，甚至操做系统的数据也可能会被修改，有时，上述三种破坏状况会同时发生。因此合理的正确的分配指针的地址是很是重要的。

1.3.1内存分配的方式

内存分配方式有三种：

（1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。

（2）在栈上建立。在执行函数时，函数内局部变量的存储单元均可以在栈上建立，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，可是分配的内存容量有限。

（3）从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员本身负责在什么时候用free或delete释放内存。动态内存的生存期由咱们决定，使用很是灵活，但问题也最多，如下咱们重点讲解动态内存分配。

1.3.2 malloc/free 的使用要点

malloc与free是C/C++语言的标准库函数，它用于申请动态内存和释放内存。

函数malloc的原型以下：

void * malloc(size_t size);

用malloc申请一块长度为length的整数类型的内存，程序以下：

int *ip = (int *) malloc(sizeof(int) * length);

咱们应当把注意力集中在两个要素上：“类型转换”和“sizeof”。

malloc函数返回值的类型是void *，因此在调用malloc时要显式地进行类型转换，将void * 转换成所须要的指针类型。

malloc函数自己并不识别要申请的内存是什么类型，它只关心内存的总字节数。例如int变量在16位系统下是2个字节，在32位下是4个字节；而float变量在16位系统下是4个字节，在32位下也是4个字节。这个你能够用sizeof(类型)去测试。

在malloc的“()”中使用sizeof运算符是良好的风格，但要小心有时咱们会昏了头，写出 ip = malloc(sizeof(ip))这样的程序来。

函数free的原型以下：

void free( void * memblock );

为何free函数不象malloc函数那样复杂呢？这是由于指针p的类型以及它所指的内存的容量事先都是知道的，语句free(p)能正确地释放内存。若是p是NULL指针，那么free对p不管操做多少次都不会出问题。若是p不是NULL指针，那么free对p连续操做两次就会致使程序运行错误。

1.3.3 new/delete 的使用要点

对于非内部数据类型的对象而言，光用maloc/free没法知足动态对象的要求。对象在建立的同时要自动执行构造函数，对象在消亡以前要自动执行析构函数。因为malloc/free是库函数而不是运算符，不在编译器控制权限以内，不可以把执行构造函数和析构函数的任务强加于malloc/free。

所以C++语言须要一个能完成动态内存分配和初始化工做的运算符new，以及一个能完成清理与释放内存工做的运算符delete。注意new/delete不是库函数,只是C++的运算符。咱们来看以下例子就知道怎么回事了。

class Object

{

public :

Object(void){std::cout << “Initialization”<< std::endl; }

~Object(void){std::cout << “Destroy”<< std::endl; }

void Initialize(void){std:: cout << “Initialization”<< std::endl; }

void Destroy(void){ std::cout << “Destroy”<< std::endl; }

}

void UseMallocFree(void)

{

Object *ip = (Object *)malloc(sizeof(Object)); // 申请动态内存

ip->Initialize(); // 初始化

//…

ip->Destroy(); // 清除工做

free(ip); // 释放内存

}

void UseNewDelete(void)

{

Object *ip = new Object; // 申请动态内存而且初始化

//…

Delete ip; // 清除而且释放内存

}

用malloc/free和new/delete如何实现对象的动态内存管理

类Object的函数Initialize模拟了构造函数的功能，函数Destroy模拟了析构函数的功能。函数UseMallocFree中，因为malloc/free不能执行构造函数与析构函数，必须调用成员函数Initialize和Destroy来完成初始化与清除工做。函数UseNewDelete则简单得多。

因此咱们不要企图用malloc/free来完成动态对象的内存管理，应该用new/delete。因为内部数据类型的“对象”没有构造与析构的过程，对它们而言malloc/free和new/delete是等价的。new内置了sizeof、类型转换和类型安全检查功能, ,对于非内部数据类型的对象而言，new在建立动态对象的同时完成了初始化工做。

new/delete 常使用的方法以下：

typeof *ip = new typeof[length];

类/结构 *ip = new 类结构；

通常释放以下：delete ip;

数组的释放以下：delete [] ip;

1.3.4内存耗尽怎么办？

若是在申请动态内存时找不到足够大的内存块，malloc和new将返回NULL指针，宣告内存申请失败。一般有三种方式处理“内存耗尽”问题。

（1）判断指针是否为NULL，若是是则立刻用return语句终止本函数。例如：

void Func(void)

{

A *a = new A;

if(a == NULL)

{

return;

}

…

}

（2）判断指针是否为NULL，若是是则立刻用exit(1)终止整个程序的运行。例如：

void Func(void)

{

A *a = new A;

if(a == NULL)

{

std::cout << “Memory Exhausted” << std::endl;

exit(1);

}

…

}

（3）为new和malloc设置异常处理函数。例如Visual C++能够用_set_new_hander函数为new设置用户本身定义的异常处理函数，也可让malloc享用与new相同的异常处理函数。详细内容请参考C++使用手册。

有一个很重要的现象要告诉你们。对于32位以上的应用程序而言，不管怎样使用malloc与new，几乎不可能致使“内存耗尽”。由于32位操做系统支持“虚存”，内存用完了，自动用硬盘空间顶替。我不想误导读者，必须强调：不加错误处理将致使程序的质量不好，千万不可因小失大。

1.3. 5杜绝“野指针”

“野指针”不是NULL指针，是指向“垃圾”内存的指针。人们通常不会错用NULL指针，由于用if语句很容易判断。可是“野指针”是很危险的，if语句对它不起做用。 “野指针”的缘由主要有以下几种：

（1）指针变量没有被初始化。任何指针变量刚被建立时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。因此，指针变量在建立的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。例如

char *ip = NULL;

char *ip = new char;

（2）指针ip被free或者delete以后，没有置为NULL，让人误觉得ip是个合法的指针。

（3）指针操做超越了变量的做用范围。这种状况让人防不胜防，示例程序以下：

class A

{

public:

void Func(void){ std::cout << “Func of class A” << std::endl; }

};

void Test(void)

{

A *p;

{

A a;

p = &a; // 注意 a 的生命期

}

p->Func(); // p是“野指针”

}

函数Test在执行语句p->Func()时，对象a已经消失，而p是指向a的，因此p就成了“野指针”。但奇怪的是有些编译器运行这个程序时竟然没有出错，这可能与编译器有关。

1.3.6指针参数是如何传递内存的？

若是函数的参数是一个指针，不要期望用该指针去申请动态内存。见以下例子：

void GetMemory(char *ip, int num)

{

ip = (char *)malloc(sizeof(char) * num);

}

void Test(void)

{

char *str = NULL;

GetMemory(str, 100); // str 仍然为 NULL

strcpy(str, "hello"); // 运行错误

}

试图用指针参数申请动态内存

毛病出在函数GetMemory中。编译器老是要为函数的每一个参数制做临时副本，指针参数ip的副本是 _ip，编译器使 _ip = ip。若是函数体内的程序修改了_ip的内容，就致使参数ip的内容做相应的修改。这就是指针能够用做输出参数的缘由。在本例中，_ip申请了新的内存，只是把_ip所指的内存地址改变了，可是ip丝毫未变。因此函数GetMemory并不能输出任何东西。事实上，每执行一次GetMemory就会泄露一块内存，由于没有用free释放内存。

若是非得要用指针参数去申请内存，那么应该改用“指向指针的指针”，见以下示例：

void GetMemory(char **p, int num)

{

*ip = (char *)malloc(sizeof(char) * num);

}

void Test(void)

{

char *str = NULL;

GetMemory(&str, 100); // 注意参数是 &str，而不是str

strcpy(str, "hello");

std::cout<< str << std::endl;

free(str);

}

用指向指针的指针申请动态内存

固然，咱们也能够用函数返回值来传递动态内存。这种方法更加简单，见以下示例：

char *GetMemory(int num)

{

char *ip = (char *)malloc(sizeof(char) * num);

return ip;

}

void Test(void)

{

char *str = NULL;

str = GetMemory(100);

strcpy(str, "hello");

std::cout<< str << std::endl;

free(str);

}

用函数返回值来传递动态内存

用函数返回值来传递动态内存这种方法虽然好用，可是经常有人把return语句用错了。这里强调不要用return语句返回指向“栈内存”的指针，由于该内存在函数结束时自动消亡，见以下示例：

char *GetString(void)

{

char p[] = "hello world";

return p; // 编译器将提出警告

}

void Test(void)

{

char *str = NULL;

str = GetString(); // str 的内容是垃圾

std::cout<< str << std::endl;

}

return语句返回指向“栈内存”的指针

最后，根据以上阐述，咱们总结以下使用规则供你们参考：

【规则1】用malloc或new申请内存以后，应该当即检查指针值是否为NULL。防止使用指针值为NULL的内存。

【规则2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存做为右值使用。

【规则3】避免数组或指针的下标越界，特别要小心发生“多1”或者“少1”操做。

【规则4】动态内存的申请与释放必须配对，防止内存泄漏。

【规则5】用free或delete释放了内存以后，当即将指针设置为NULL，防止产生“野指针”。

1.4指针的运算

1.4.1赋值运算

指针变量的赋值运算有如下几种形式：

1.4.1.1指针变量初始化赋值以下:

int a;

int *ip=&a;

1.4.1.2把一个变量的地址赋予指向相同数据类型的指针变量。例如：

int a;

int *ip;

ip=&a; //把整型变量a的地址赋予整型指针变量ip

1.4.1.3把一个指针变量的值赋予指向相同类型变量的另外一个指针变量。例如：

int a;

int *pa=&a;

int *pb;

pb=pa; //把a的地址赋予指针变量pb

因为pa,pb均为指向整型变量的指针变量，所以能够相互赋值。

1.4.1.4把数组的首地址赋予指向数组的指针变量。例如：

int a[5],*pa;

pa=a; //数组名表示数组的首地址，故可赋予指向数组的指针变量pa

也可写为：

pa=&a[0]; //数组第一个元素的地址也是整个数组的首地址也可赋予pa

固然也可采起初始化赋值的方法：

int a[5],*pa=a;

以上是一些基本的数组赋值方法，后面咱们会详细讨论指针在数组中的使用。

1.4.1.5把字符串的首地址赋予指向字符类型的指针变量。例如：

char *pc;

pc="c language";

或用初始化赋值的方法写为：

char *pc=" c language ";

这里应说明的是并非把整个字符串装入指针变量，而是把存放该字符串的字符数组的首地址装入指针变量。

1.4.1.6把函数的入口地址赋予指向函数的指针变量。例如：

int (*pf)();

pf=f; //f为函数名

1.4.2加减运算

对于指向数组的指针变量，能够加上或减去一个整数n。设ip是指向数组a的指针变量，则ip+n,ip-n,ip++,++ip,ip--,--ip 运算都是合法的。指针变量加或减一个整数n的意义是把指针指向的当前位置(指向某数组元素)向前或向后移动n个位置。应该注意，数组指针变量向前或向后移动一个位置和地址加1或减1 在概念上是不一样的。由于数组能够有不一样的类型，各类类型的数组元素所占的字节长度是不一样的。如指针变量加1，即向后移动1 个位置表示指针变量指向下一个数据元素的首地址。而不是在原地址基础上加1。看以下例子：

char a[20];

int*ip=a;

...

ip++;

在上例中，指针ip的类型是int*,它指向的类型是int，它被初始化为指向整形变量a。接下来的第3句中，指针ip被加了1，编译器是这样处理的：它把指针ip的值加上了sizeof(int)，在32位程序中，是被加上了4。因为地址是用字节作单位的，故ip所指向的地址由原来的变量a的地址向高地址方向增长了4个字节。

因为char类型的长度是一个字节，因此，原来ptr是指向数组a的第0号单元开始的四个字节，此时指向了数组a中从第4号单元开始的四个字节。再看以下例子：

char a[20];

int*ip=a;

...

ip+=5;

在这个例子中，ip被加上了5，编译器是这样处理的：将指针ip的值加上5乘sizeof(int)，在32位程序中就是加上了5乘4=20。因为地址的单位是字节，故如今的ip所指向的地址比起加5后的ip所指向的地址来讲，向高地址方向移动了20个字节。在这个例子中，没加5前的ip指向数组a的第0号单元开始的四个字节，加5后，ptr已经指向了数组a的合法范围以外了。虽然这种状况在应用上会出问题，但在语法上倒是能够的。这也体现出了指针的灵活性。

若是上例中，ip是被减去5，那么处理过程大同小异，只不过ip的值是被减去5乘sizeof(int)，新的ip指向的地址将比原来的ip所指向的地址向低地址方向移动了20个字节。

总结一下，一个指针ipold加上一个整数n后，结果是一个新的指针ipnew，ipnew的类型和ipold的类型相同，ipnew所指向的类型和ipold所指向的类型也相同。ipnew的值将比ipold的值增长了n乘sizeof(ipold所指向的类型)个字节。就是说，ipnew所指向的内存区将比ipold所指向的内存区向高地址方向移动了n乘sizeof(ipold所指向的类型)个字节。

一个指针ipold减去一个整数n后，结果是一个新的指针ipnew，ipnew的类型和ipold的类型相同，ipnew所指向的类型和ipold所指向的类型也相同。ipnew的值将比ipold的值减小了n乘sizeof(ipold所指向的类型)个字节，就是说，ipnew所指向的内存区将比ipold所指向的内存区向低地址方向移动了n乘sizeof(ipold所指向的类型)个字节。

1.4.3关系运算

指向同一个数组中的不一样元素的两个指针能够进行各类关系运算。例如：

ip1==ip2表示ip1和ip2指向同一数组元素

ip1>ip2表示ip1处于高地址位置

ip1<ip2表示ip2处于低地址位置

指针变量还能够与0比较。设ip为指针变量，则ip==0代表ip是空指针，它不指向任何变量；ip!=0表示ip不是空指针。空指针是由对指针变量赋予0值而获得的。例如：

#define NULL 0

int *ip=NULL;

对指针变量赋0值和不赋值是不一样的。指针变量未赋值时，能够是任意值，是不能使用的。不然将形成意外错误。而指针变量赋0值后，则可使用，只是它不指向具体的变量而已。

1.4.4取地址运算符‘&’和取内容运算符‘*’

取地址运算符&是单目运算符，其结合性为自右至左，其功能是取变量的地址。

取内容运算符*是单目运算符，其结合性为自右至左，用来表示指针变量所指的变量。在*运算符以后跟的变量必须是指针变量。须要注意的是指针运算符*和指针变量说明中的指针说明符* 不是一回事。在指针变量说明中，‘*’是类型说明符，表示其后的变量是指针类型。而表达式中出现的‘*’则是一个运算符用以表示指针变量所指的变量。以下例子：

int a=12;

int b;

int *p;

int **ptr;

p=&a; //&a的结果是一个指针，类型是int*，指向的类型是int，指向的地址是a的

//地址。

*p=24; //*p的结果，在这里它的类型是int，它所占用的地址是p所指向的地址。

ptr=&p; //&p的结果是个指针，该指针的类型是p的类型加个*，在这里是int **。该

//指针所指向的类型是p的类型，这里是int*。该指针所指向的地址就是指针

//p本身的地址。

*ptr=&b;//*ptr是个指针，&b的结果也是个指针，且这两个指针的类型和所指向的类型//是同样的，因此用&b来给*ptr赋值就是毫无问题的了。

**ptr=34;//*ptr的结果是ptr所指向的东西，在这里是一个指针，对这个指针再作一次*

//运算，结果就是一个int类型的变量。

1.4.5关于括号组合

在解释组合说明符时，标识符右边的方括号和圆括号优先于标识符左边的“*”号，而方括号和圆括号以相同的优先级从左到右结合。但能够用圆括号改变约定的结合顺序。

阅读组合说明符的规则是“从里向外”。从标识符开始，先看它右边有无方括号或园括号，若有则先做出解释，再看左边有无*号。若是在任什么时候候遇到了闭括号，则在继续以前必须用相同的规则处理括号内的内容。

1.5指针表达式

一个表达式的最后结果若是是一个指针，那么这个表达式就叫指针表式。因此指针表达式也具备指针所具备的四个要素:指针的类型,指针所指向的类型,指针指向的内存区,指针自身占据的内存。