专业专注 2007-05-17 19:40 发表评论

专业专注 2007-05-06 23:34 发表评论

所属类别：VC++
推荐指数：★★★☆
文档人气：402
本周人气：34
发布日期：2006-6-25

　　何为指针？

　　指针基本上和其它的变量一样，唯一的一点不同就是指针并不包含实际的数据，而是包含了一个指向内存位置的地址，你可以在这个地址找到某些信息。这是一个很重要的概念，并且许多程序或者思想都是将指针作为它们的设计基础，例如链表。

　　 开始

　　如何定义一个指针？呃，就像定义其它的变量一样，不过你还需要在变量名之前添加一个星号。例如，下面的代码创建了两个指向整数的指针：

int* pNumberOne; 　　 int* pNumberTwo;

　　注意到变量名的前缀“p”了吗？这是编写代码的一个习惯，用来表示这个变量是一个指针。

　　现在，让我们把这些指针指向一些实际的值吧：

pNumberOne = &some_number; 　　 pNumberTwo = &some_other_number;

　　 “&”标志应该读作“the address of(……的地址)”，它的作用是返回一个变量的内存地址，而不是这个变量本身。那么在这个例子中，pNumberOne就是some_number的地址，亦称作pNumberOne指向some_number。

　　现在，如果我们想使用some_number的地址的话，那么我们就可以使用pNumberOne了。如果我们希望经由pNumberOne而使用some_number的值的话，我们可以用*pNumberOne。“*”应该读作“the memory location pointed to by(由……指向的内存位置)”，它用来取得指针所指向的值。不过指针声明的情况例外，如“int *pNumber”。

　　 到现在都学到什么了(一个例子)：

　　咻！要理解的东西太多了，所以在此我建议，如果你还是不理解以上的概念的话，那么最好再通读一遍；指针是一个复杂的主题，要掌握它是要花些时间的。

　　这里有一个示例，解说了上面讨论的那些概念。它是由C编写成，并不带有C++的那些扩展。

#include 　　 void main() 　　 { 　　 // 声明变量： 　　 int nNumber; 　　 int *pPointer; 　　 // 现在，给它们赋值： 　　 nNumber = 15; 　　 pPointer = &nNumber; 　　 // 打印nNumber的值： 　　 printf("nNumber is equal to : %d\n", nNumber); 　　 // 现在，通过pPointer来控制nNumber： 　　 *pPointer = 25; 　　 // 证明经过上面的代码之后，nNumber的值已经改变了： 　　 printf("nNumber is equal to : %d\n", nNumber); 　　　 }

　　请通读并编译以上代码，并确信你已经弄懂了它是如何工作的。然后，当你准备好了以后，就往下读吧！

　　 陷阱！

　　看看你是否能指出以下程序的缺陷：

#include 　　 int *pPointer; 　　 void SomeFunction() 　　 { 　　 int nNumber; 　　 nNumber = 25; 　　 // 使pPointer指向nNumber： 　　 pPointer = &nNumber; 　　 } 　　 void main() 　　 { 　　 SomeFunction(); // 让pPointer指向某些东西 　　 // 为什么这样会失败？ 　　 printf("Value of *pPointer: %d\n", *pPointer); 　　 }

这个程序首先调用SomeFunction函数，在其中创建了一个名为nNumber的变量，并且使pPointer指向这个变量。那么，这就是问题之所在了。当函数结束的时候，由于nNumber是一个本地变量，那么它就会被销毁。这是因为当语句块结束的时候，块中定义的本地变量都会被销毁。这就意味着当SomeFunction返回到main()的时候，那个变量就已经被销毁了，所以pPointer将会指向一个不再属于本程序的内存位置。如果你不懂这一点，那么你应该去读一读有关本地变量、全局变量以及作用域的东西，这些概念非常重要。

那么，如何解决这个问题呢？答案是使用一种名为动态分配的技术。请注意：在这一点上，C和C++是不同的。既然大多数开发者正在使用C++，那么下面的代码就使用C++来编写。

　　动态分配

　　 动态分配也许可以算是指针的关键技术了。它被用于在没有定义变量的情况下分配内存，然后由一个指针指向这段内存。虽然这个概念好像很让人糊涂，其实它很简单。以下的代码解说了如何为一个整数分配内存空间：

int *pNumber; 　　 pNumber = new int;

　　第一行代码声明了一个指针pNumber，第二行代码分配了一个整数的空间，并使pNumber指向这一段新分配的内存。下面是另外一个例子，这一次使用了一个double：

double *pDouble; 　　 pDouble = new double;

　　这些规则是相同的T，所以你应该可以很容易地掌握。

　　动态分配和本地变量的不同点是：你分配的内存在函数返回和语句块结束的时候不会被释放，所以，如果你用动态分配来重新编写上面的代码，那么它就会正常工作了：

#include 　　 int *pPointer; 　　 void SomeFunction() 　　 { 　　 // 使pPointer指向一个new的整数 　　 pPointer = new int; 　　 *pPointer = 25; 　　 } 　　 void main() 　　 { 　　　 SomeFunction(); // 让pPointer指向某些东西 　　　 printf("Value of *pPointer: %d\n", *pPointer); 　　 }

　　请通读并编译以上的示例代码，并确信你已经弄懂了它为何如此工作。当调用SomeFunction的时候，它分配了一段内存，并使pPointer指向这段内存。这一次当函数返回的时候，这段new的内存就会完好保留，所以pPointer仍然指向某些有用的内容。这就是动态分配了！请确信你已经搞懂了这一点，然后继续阅读关于这段代码中的一个严重错误。

　　 来得明白，去得明白

　　还有一个复杂的因素，并且是十分严重的——虽然它很好补救。问题是你分配的内存在离开的时候虽然仍然完好，但是这段内存永远也不会自动销毁。这就是说，如果你不通知电脑结束使用的话，这段内存就会一直存在下去，这样做的结果就是内存的浪费。最终，系统就会因为内存耗尽而崩溃。所以，这是相当重要的一个问题。当你使用完内存之后，释放它的代码非常简单：

　　 delete pPointer;

　　这一切就这么简单。不管怎样，在你传递一个有效的指针——亦即一个指向一段你已经分配好的内存指针，而不是那些老旧的垃圾内存——的时候，你都需要无比细心。尝试delete一段已经释放的内存是十分危险的，这可能会导致你的程序崩溃。

　　好了，下面又是那个例子，这一次它就不会浪费内存了：

#include 　　 int *pPointer; 　　 void SomeFunction() 　　 { 　　 // 使pPointer指向一个new的整数 　　 pPointer = new int; 　　 *pPointer = 25; 　　 } 　　 void main() 　　 { 　　 SomeFunction(); // 让pPointer指向某些东西 　　 printf("Value of *pPointer: %d\n", *pPointer); 　　 delete pPointer; 　　 }

唯一的一行不同也就是最本质的一点。如果你不将内存delete掉，你的程序就会得到一个“内存泄漏”。如果出现了内存泄漏，那么除非你关闭应用程序，否则你将无法重新使用这段泄漏的内存。

　　向函数传递指针

　　 向函数传递指针的技术非常有用，但是它很容易掌握(译注：这里存在必然的转折关系吗？呃，我看不出来，但是既然作者这么写了，我又无法找出一个合适的关联词，只好按字面翻译了)。如果我们要编写一段程序，在其中要把一个数增加5，我们可能会像这么写：

#include 　　 void AddFive(int Number) 　　 { 　　 Number = Number + 5; 　　 } 　　 void main() 　　 { 　　 int nMyNumber = 18; 　　 printf("My original number is %d\n", nMyNumber); 　　 AddFive(nMyNumber); 　　 printf("My new number is %d\n", nMyNumber); 　　 }

　　可是，这段程序AddFive中的Number是传递到这个函数中的nMyNumber的一份拷贝，而不是nMyNumber本身。因此，“Number = Number + 5”这一行则是向这份拷贝加上了5，而main()中的原始变量并没有任何变化。你可以运行这个程序试着证明这一点。

　　对于这个程序，我们可以向函数传递这个数字内存地址的指针。这样，我们就需要修改这个函数，使之能接收一个指向整数的指针。于是，我们可以添加一个星号，即把“void AddFive(int Number)”改为“void AddFive(int* Number)”。下面是这个修改过了的程序，注意到我们已经将nMyNumber的地址(而不是它本身)传递过去了吗？此处改动是添加了一个“&”符号，它读作(你应该回忆起来了)“the address of(……的地址)”。

#include 　　 void AddFive(int* Number) 　　 { 　　 *Number = *Number + 5; 　　 } 　　 void main() 　　 { 　　 int nMyNumber = 18; 　　 printf("My original number is %d\n", nMyNumber); 　　 AddFive(&nMyNumber); 　　 printf("My new number is %d\n", nMyNumber); 　　 }

你可以试着自己编写一个程序来证明这一点。注意到AddFive函数中Number之前的“*”的重要性了吗？这就是告知编译器我们要在指针Number指向的数字上加5，而不是向指针本身加5。

最后要注意的一点是，你亦可以在函数中返回指针，像下面这个样子：

int * MyFunction();

在这个例子中，MyFunction返回了一个指向整数的指针。

　　指向类的指针

　　 关于指针，我还有还有两点需要提醒你。其中之一是指向结构或类的指针。你可以像这样定义一个类：

class MyClass 　　 { 　　 public: 　　 int m_Number; 　　 char m_Character; 　　 };

　　然后，你可以定义一个MyClass的变量：

MyClass thing;

　
　　你应该已经知道这些了，如果还没有的话，你需要阅读一下这方面的资料。你可以这样定义一个指向MyClass的指针：

MyClass *thing;

　　就像你期望的一样。然后，你可以为这个指针分配一些内存：

thing = new MyClass;

　　这就是问题之所在了——你将如何使用这个指针？呃，通常你会这么写：“thing.m_Number”，但是对于这个例子不行，因为thing并非一个MyClass，而是一个指向MyClass的指针，所以它本身并不包含一个名为“m_Number”的变量；它指向的结构才包含这个m_Number。因此，我们必须使用一种不同的转换方式。这就是将“.”(点)替换为一个“->”(横线和一个大于号)。请看下面这个例子：

class MyClass 　　 { 　　　 public: 　　　　 int m_Number; 　　　　 char m_Character; 　　 }; 　　 void main() 　　 { 　　 MyClass *pPointer; 　　 pPointer = new MyClass; 　　 pPointer->m_Number = 10; 　　 pPointer->m_Character = 's'; 　　 delete pPointer; 　　 }

　　 指向数组的指针

　　你也可以使指针指向数组，如下：

int *pArray; 　　 pArray = new int[6];

　　这将创建一个指针pArray，它会指向一个6个元素的数组。另一种不使用动态分配的方法如下：

int *pArray; 　　 int MyArray[6]; 　　 pArray = &MyArray[0];

　　请注意，你可以只写MyArray来代替&MyArray[0]。当然，这种方法只适用于数组，是C/C++语言的实现使然(译注：你也可以把函数名赋值给一个相应的函数指针)。通常出现的错误是写成了“pArray = &MyArray;”，这是不正确的。如果你这么写了，你会获得一个指向数组指针的指针(可能有些绕嘴吧？)，这当然不是你想要的。

　　 使用指向数组的指针

　　如果你有一个指向数组的指针，你将如何使用它？呃，假如说，你有一个指向整数数组的指针吧。这个指针最初将会指向数组的第一个值，看下面这个例子：

#include 　　 void main() 　　 { 　　 int Array[3]; 　　 Array[0] = 10; 　　 Array[1] = 20; 　　 Array[2] = 30; 　　 int *pArray; 　　 pArray = &Array[0]; 　　 printf("pArray points to the value %d\n", *pArray); 　　　 }

　　要想使指针移到数组的下一个值，我们可以使用pArray++。我们也可以——当然你们有些人可能也猜到了——使用pArray + 2，这将使这个数组指针移动两个元素。要注意的一点是，你必须清楚数组的上界是多少(在本例中是3)，因为在你使用指针的时候，编译器不能检查出来你是否已经移出了数组的末尾。所以，你可能很容易地使系统崩溃。下面仍然是这个例子，显示了我们所设置的三个值：

#include 　　 void main() 　　 { 　　 int Array[3]; 　　 Array[0] = 10; 　　 Array[1] = 20; 　　 Array[2] = 30; 　　 int *pArray; 　　 pArray = &Array[0]; 　　 printf("pArray points to the value %d\n", *pArray); 　　 pArray++; 　　 printf("pArray points to the value %d\n", *pArray); 　　 pArray++; 　　 printf("pArray points to the value %d\n", *pArray); 　　 }

　　同样，你也可以减去值，所以pArray - 2就是pArray当前位置的前两个元素。不过，请确定你是在操作指针，而不是操作它指向的值。这种使用指针的操作在循环的时候非常有用，例如for或while循环。

　　请注意，如果你有了一个指针(例如int* pNumberSet)，你也可以把它看作一个数组。比如pNumberSet[0]相当于*pNumberSet，pNumberSet[1]相当于*(pNumberSet + 1)。

　　关于数组，我还有最后一句警告。如果你用new为一个数组分配空间的话，就像下面这个样子：

int *pArray; 　　 pArray = new int[6];

　　那么必须这样释放它：

delete[] pArray;

　　请注意delete之后的[]。这告知编译器它正在删除一个整个的数组，而不是单独的一个项目。你必须在使用数组的时候使用这种方法，否则可能会获得一个内存泄漏。
　　最后的话

　　最后要注意的是：你不能delete掉那些没有用new分配的内存，像下面这个样子：

void main() 　　 { 　　　 int number; 　　　 int *pNumber = number; 　　　 delete pNumber; // 错误：*pNumber不是用new分配的 　　 }

　　 常见问题及FAQ

　　 Q：为什么在使用new和delete的时候会得到“symbol undefined”错误？

　　 A：这很可能是由于你的源文件被编译器解释成了一个C文件，因为new和delete操作符是C++的新特性。通常的改正方法是使用.cpp作为你的源文件扩展名。

　　 Q：new和malloc的区别是什么？

　　 A：new是C++特有的关键词，并且是标准的分配内存方法(除了Windows程序的内存分配方法之外)。你绝不能在一个C C++程序中使用malloc，除非绝对必要。由于malloc并不是为C++面向对象的特色设计的，所以使用它为类对象分配内存就不会调用类的构造函数，这样就会出现问题。由于这些原因，本文并不对它们进行讨论，并且只要有可能，我亦会避免使用它们。 　　Q：我能一并使用free和delete吗？

　　 A：你应该使用和分配内存相配套的方法来释放内存。例如，使用free来释放由malloc分配的内存，用delete来释放由new分配的内存。

　　 引用

　　从某种角度上来说，引用已经超过了本文的范围。但是，既然很多读者问过我这方面的问题，那么我在此对其进行一个简要的讨论。引用和指针十分相似，在很多情况下用哪一个都可以。如果你能够回忆起来上文的内容——我提到的“&”读作“the address of(……的地址)”，在声明的时候例外。在声明的这种情况下，它应该读作“a reference to(……的引用)”，如下：

int& Number = myOtherNumber; 　　 Number = 25;

　　引用就像是myOtherNumber的指针一样，只不过它是自动解析地址的，所以它的行为就像是指针指向的实际值一样。与其等价的指针代码如下：

int* pNumber = &myOtherNumber; 　　 *pNumber = 25;

　　指针和引用的另一个不同就是你不能更换引用的内容，也就是说你在声明之后就不能更换引用指向的内容了。例如，下面的代码会输出20：

int myFirstNumber = 25; 　　 int mySecondNumber = 20; 　　 int &myReference = myFirstNumber; 　　 myReference = mySecondNumber; 　　 printf("%d", myFristNumber);

　　当在类中的时候，引用的值必须由构造函数设置，像下面这种方法一样：

CMyClass::CMyClass(int &variable) : m_MyReferenceInCMyClass(variable) 　　 { 　　　 // 这里是构造代码 　　 }

　　 总结

　　这一主题最初是十分难以掌握的，所以你最好读上它个至少两遍——因为大多数人不能立即弄懂。下面我再为你列出本文的重点：

　　 1、指针是一种指向内存中某个位置的变量，你可以通过在变量名前添加星号(*)来定义一个指针(也就是int *number)。

　　 2、你可以通过在变量名前添加“&”来获得它的内存地址(也就是pNumber = &my_number)。

　　 3、除了在声明中以外(例如int *number)，星号应该读作“the memory location pointed to by(由……指向的内存位置)”。

　　 4、除了在声明中以外(例如int &number)，“&”应该读作“the address of(……的地址)”。

　　 5、你可以使用“new”关键字来分配内存。

　　 6、指针必须和它所指向的变量类型相配套，所以int *number不应该指向一个MyClass。

　　 7、你可以向函数传递指针。

　　 8、你必须使用“delete”关键字来释放你分配的内存。

　　 9、你可以使用&array[0]来获得一个数组的指针。

　　 10、你必须使用delete[]来释放动态分配的数组，而不是简单的delete。

　　这并非一个完全的指针指南，其中有一点我能够涉及到的其它细节，例如指针的指针；还有一些我一点也未涉及到的东西，例如函数指针——我认为作为初学者的文章，这个有些复杂了；还有一些很少使用的东西，在此我亦没有提到，省得让这些不实用的细节使大家感到混乱。 　　就这样了！你可以试着运行本文中的程序，并自己编写一些示例来弄懂关于指针的问题吧。

专业专注 2006-08-05 15:15 发表评论