C++中指针入门
当前位置：以往代写 > C/C++ 教程 >C++中指针入门

C++中指针入门

2019-06-13

C++中指针入门

C++中指针入门

副标题#e#

什么是指针？

其实指针就像是其它变量一样，所差异的是一般的变量包括的是实际的真实的数据，而指针是一个指示器，它汇报措施在内存的哪块区域可以找到数据。这是一个很是重要的观念，有许多措施和算法都是环绕指针而设计的，如链表。

开始进修

如何界说一个指针呢？就像你界说一个其它变量一样，只不外你要在指针名字前加上一个星号。我们来看一个例子：下面这个措施界说了两个指针，它们都是指向整型数据。

int * pNumberOne;
int * pNumberTwo;

你留意到在两个变量名前的“p”前缀了吗？这是措施员凡是在界说指针时的

一个习惯，以提高便措施的阅读性，暗示这是个指针。此刻让我们来初始化这两个指针：

pNumberOne = &some_number;
pNumberTwo = &some_other_number;

&号读作“什么的地点”，它暗示返回的是变量在内存中的地点而不是变量自己的值。在这个例子中，pNumberOne 便是some_number的地点，所以此刻pNumberOne指向some_number。 假如此刻我们在措施中要用到some_number，我们就可以利用pNumberOne。

我们来进修一个例子：

在这个例子中你将学到许多，假如你对指针的观念一点都不相识，我发起你多看几遍这个例子，指针是个很巨大的对象，但你会很快把握它的。

这个例子用以加强你对上面所先容内容的相识。它是用C编写的(注：原英文版是用C写的代码，译者从头用C++改写写了所有代码，并在DEV C++ 和VC++中编译通过！）

#include <iostream.h>

void main()
{
// 声明变量：

int nNumber;
int *pPointer;

// 此刻给它们赋值：

nNumber = 15;
pPointer = &nNumber;

//打印出变量nNumber的值：

cout<<"nNumber is equal to :"<< nNumber<<endl;

// 此刻通过指针改变nNumber的值：

*pPointer = 25;

//证明nNumber已经被上面的措施改变

//从头打印出nNumber的值:

cout << "nNumber is equal to :" << nNumber << endl;
}

通读一下这个措施，编译并运行它，务必大白它是奈何事情的。假如你完成了，筹备好，开始下一小节。

陷井！

试一下，你能找出下面这段措施的错误吗？

#include <iostream.h>

int *pPointer;

void SomeFunction();

{
int nNumber;
nNumber = 25;

//让指针指向nNumber:

pPointer = &nNumber;
}

void main()
{
SomeFunction(); //为pPointer赋值

//为什么这里失败了?为什么没有获得25

cout<<"Value of *pPointer: "<<*pPointer<<endl;
}

这段措施先挪用了SomeFunction函数，建设了个叫nNumber的变量，接着让指针pPointer指向了它。但是问题出在哪儿呢？当函数竣事后，nNumber被删掉了，

因为这一个局部变量。局部变量在界说它的函数执行完后城市被系统自动删掉。也就是说当SomeFunction 函数返回主函数main()时，这个变量已经被删掉，但pPointer还指着变量曾经用过的但此刻已不属于这个措施的区域。假如你还不大白，你可以再读读这个措施，留意它的局部变量和全局变量，这些观念都很是重要。

但这个问题怎么办理呢？谜底是动态分派技能。留意这在C和C++中是差异的。由于大大都措施员都是用C++，所以我用到的是C++中常用的称呼。


#p#副标题#e#

动态分派

动态分派是指针的要害技能。它是用来在不愿界说变量的环境下分派内存和让指针去指向它们。尽量这么说大概会让你疑惑，其实它真的很简朴。下面的代码就是一个为一个整型数据分派内存的例子：

int *pNumber;
pNumber = new int;

第一行声明一个指针pNumber。第二行为一个整型数据分派一个内存空间，并让pNumber指向这个新内存空间。下面是一个新例，这一次是用double双精型：

double *pDouble;
pDouble = new double;

这种名目是一个法则，这样写你是不会错的。

但动态分派又和前面的例子有什么差异呢？就是在函数返回或执行完毕时，你分派的这块内存区域是不会被删除的所以我们此刻可以用动态分派重写上面的措施：

#include <iostream.h>

int *pPointer;

void SomeFunction()
{

// 让指针指向一个新的整型

pPointer = new int;
*pPointer = 25;
}

void main()
{
SomeFunction(); // 为pPointer赋值

cout<<"Value of *pPointer: "<<*pPointer<<endl;
}

#p#分页标题#e#

通读这个措施，编译并运行它，务必领略它是奈何事情的。当SomeFunction挪用时，它分派了一个内存，并让pPointer指向它。这一次，当函数返回时，新的内存区域被保存下来，所以pPointer始终指着有用的信息，这是因为了动态分派。可是你再仔细读读上面这个措施，固然它获得了正确功效，可仍有一个严重的错误。

分派了内存，别忘了接纳

太巨大了，怎么会尚有严重的错误！其实要纠正并不难。问题是：你动态地分派了一个内存空间，可它毫不会被自动删除。也就是说，这块内存空间会一直存在，直到你汇报电脑你已经利用完了。可功效是，你并没有汇报电脑你已不再需要这块内存空间了，所以它会继承占据着内存空间造成挥霍，甚至你的措施运行完毕，其它措施运行时它还存在。当这样的问题积聚到必然水平，最终将导致系统瓦解。所以这是很重要的，在你用完它今后，请释放它的空间，如：

delete pPointer;

这样就差不多了，你不得不小心。在这你终止了一个有效的指针（一个确实指向某个内存的指针）。下面的措施，它不会挥霍任何的内存：

#include <iostream.h>

挪用时，它分派了一个内存，并让pPointer指向它。这一次，当函数返回时，新的内存区域被保存下来，所以pPointer始终指着有用的信息，这是因为了动态分派。可是你再仔细读读上面这个措施，固然它获得了正确功效，可仍有一个严重的错误。

分派了内存，别忘了接纳

太巨大了，怎么会尚有严重的错误！其实要纠正并不难。问题是：你动态地分派了一个内存空间，可它毫不会被自动删除。也就是说，这块内存空间会一直存在，直到你汇报电脑你已经利用完了。可功效是，你并没有汇报电脑你已不再需要这块内存空间了，所以它会继承占据着内存空间造成挥霍，甚至你的措施运行完毕，其它措施运行时它还存在。当这样的问题积聚到必然水平，最终将导致系统瓦解。所以这是很重要的，在你用完它今后，请释放它的空间，如：delete pPointer;

这样就差不多了，你不得不小心。在这你终止了一个有效的指针（一个确实指向某个内存的指针）。

下面的措施，它不会挥霍任何的内存：

#include <iostream.h>

int *pPointer;

void SomeFunction()
{

// 让指针指向一个新的整型

pPointer = new int;
*pPointer = 25;
}

void main()
{
SomeFunction(); //为pPointer赋值

cout<<"Value of *pPointer: "<<*pPointer<<endl;

delete pPointer;
}

只有一行与前一个措施差异，但就是这最后一行十分地重要。假如你不删除它，你就会制造一起“内存裂痕”，而让内存逐渐地泄漏。(译者:如果在措施中挪用了两次SomeFunction，你又该如何修改这个措施呢？请读者本身思考)

#p#副标题#e#

通报指针到函数

通报指针到函数长短常有用的，也很容易把握。假如我们写一个措施，让一个数加上5,看一看这个措施完整吗？：

#include <iostream.h>

void AddFive(int Number)
{
Number = Number + 5;
}

void main()
{
int nMyNumber = 18;

cout<<"My original number is "<<nMyNumber<<endl;
AddFive(nMyNumber);
cout<<"My new number is "<<nMyNumber<<endl;

//获得了功效23吗？问题出在哪儿？

}

问题出在函数AddFive里用到的Number是变量nMyNumber的一个副本而通报给函数，而不是变量自己。因此， " Number = Number + 5" 这一行是把变量的副本加了5，而原始的变量在主函数main()里依然没变。试着运行这个措施，本身去体会一下。要办理这个问题，我们就要通报一个指针到函数，所以我们要修改一下函数让它能接管指针：把’void AddFive(int Number)’ 改成 ‘void AddFive(int*Number)’　。下面就是悔改的措施，留意函数挪用时要用＆号，以暗示通报的是指针：

#include <iostream.h>
void AddFive(int* Number)
{
*Number = *Number + 5;
}

void main()
{
int nMyNumber = 18;

cout<<"My original number is "<<nMyNumber<<endl;
AddFive(&nMyNumber);
cout<<"My new number is "<<nMyNumber<<endl;
}

试着本身去运行它，留意在函数AddFive的参数Number前加*号的重要性：它汇报编译器，我们是把指针所指的变量加5。而不并指针本身加5。

最后，假如想让函数返回指针的话，你可以这么写：

int * MyFunction();

在这句里，MyFunction返回一个指向整型的指针。

指向类的指针

指针在类中的操纵要分外小心，你可以用如下的步伐界说一个类：

class MyClass

{
public:
int m_Number;
char m_Character;
};

接着你就可以界说一个MyClass 类的变量了：

MyClass thing;

你应该已经知道奈何去界说一个指针了吧：

MyClass *thing;

接着你可以分派个内存空间给它：

thing = new MyClass;

留意，问题呈现了。你规划奈何利用这个指针呢，凡是你大概会写’thing.m_Number’，可是thing是类吗，不，它是一个指向类的指针，它自己并

不包括一个叫m_Number的变量。所以我们必需用另一种要领：就是把’.'(点号）换成 -> ,来看下面的例子：

#p#分页标题#e#

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;
}

#p#副标题#e#

指向数组的指针

你也可以让指针指向一个数组，按下面的要领操纵：

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

措施会建设一个指针pArray，让它指向一个有六个元素的数组。别的一种要领，不消动态分派：

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

留意，&MyArray[0] 也可以简写成 MyArray ，都暗示是数组的第一个元素地点。但假如写成pArray = &MyArray大概就会出问题，功效是 pArray 指向的是指向数组的指针（在一维数组中尽量与&MyArray[0]相等），而不是你想要的，在多维数组中很容易堕落。

在数组中利用指针

一旦你界说了一个指向数组的指针，你该奈何利用它呢？让我们来看一个例子，一个指向整型数组的指针：

#include <iostream.h>

void main()
{
int Array[3];
Array[0] = 10;
Array[1] = 20;
Array[2] = 30;

int *pArray;
pArray = &Array[0];

cout<<"pArray points to the value %d\n"<<*pArray<<endl;

}

假如让指针指向数组元素中的下一个，可以用pArray++.也可以用你应该能想到的pArray + 1，城市让指针指向数组的下一个元素。要留意的是你在移动指针时，措施并不查抄你是否已经移动地超出了你界说的数组，也就是说你很大概通过上面的简朴指针加操纵而会见到数组以外的数据，而功效就是，大概会使系统瓦解，所以请分外小心。

虽然有了pArray + 1，也可以有pArray － 1，这种操纵在轮回中很常用，出格是while轮回中。

另一个需要留意的是，假如你界说了一个指向整型数的指针：int*pNumberSet ，你可以把它看成是数组，如：pNumberSet[0] 和 *pNumberSet是相等的，pNumberSet[1]与*(pNumberSet + 1)也是相等的。

在这一节的最后提一个告诫：假如你用 new 动态地分派了一个数组，

int *pArray;

pArray = new int[6];

别忘了接纳，

delete[] pArray;

这一句是汇报编译器是删除整个数组而纷歧个单独的元素。千万记着了。

后话

尚有一点要小心，别删除一个基础就没分派内存的指针，典范的是假如没用new分派，就别用delete:

void main()
{
int number;
int *pNumber = number;

delete pNumber; // 错误 - *pNumber 没有用new动态分派内存.
}

#p#副标题#e#

常见问题解答

Q：为什么我在编译措施时总是在 new 和 delete语句中呈现’symbolundefined’ 错误？

A：new 和 delete都是C++在C上的扩展，这个错误是说编译器认为你此刻的措施是C而不C++，虽然会堕落了。看看你的文件名是不是.cpp末了。

Q：new 和 malloc有什么差异？

A：new 是C++中的关健字，用来分派内存的一个尺度函数。假如没有须要，请不要在C++中利用malloc。因为malloc是C中的语法，它不是为面向工具的C++而设计的。

Q：我可以同时利用free 和 delete吗？

A：你应该留意的是，它们各自所匹配的操纵差异。free只用在用malloc分派的内存操纵中，而delete只用在用new分派的内存操纵中。引用（写给某些有本领的读者）

#p#分页标题#e#

这一节的内容不是我的这篇文章的中心，只是供某些有本领的读者参考。有些读者常常问我关于引用和指针的问题，这里我简腹地接头一下。在前面指针的进修中，我们知道（＆）是读作“什么的地点”，但在下面的措施中，它是读作“什么的引用”

int& Number = myOtherNumber;
Number = 25;

引用有点像是一个指向myOtherNumber的指针，差异的是它是自动删除的。所以他比指针在某些场所更有用。与上面等价的代码是：

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

指针与引用另一个差异是你不能修改你已经界说好的引用，也就是说你不能改变它在声明时所指的内容。举个例子：

int myFirstNumber = 25;
int mySecondNumber = 20;
int &myReference = myFirstNumber;

myReference = mySecondNumber;//这一步能使myReference 改变吗？

cout<<myFristNumber<<endl;//功效是20照旧25？

当在类中操纵时，引用的值必需在结构函数中设定，例：

CMyClass::CMyClass(int &variable) : m_MyReferenceInCMyClass(variable)
{
// constructor code here
}

总结

这篇文章开始大概会较难把握，所以最好是多读几遍。有些读者临时还不能领略，在这儿我再做一个扼要的总结：

指针是一个指向内存区域的变量，界说时在变量名前加上星号（*）（如：int *number）。

你可以获得任何一个变量的地点，只在变量名前加上＆（如：pNumber =&my_number）。

你可以用’new’ 要害字动态分派内存。指针的范例必需与它所指的变量范例一样（如：int *number 就不能指向 MyClass）。

你可以通报一个指针到函数。必需用’delete’删除你动态分派的内存。

你可以用&array[0]而让指针指向一个数组。

你必需用delete[]而不是delete来删除动态分派的数组。

文章到这儿就差不多竣事了，但这些并不就是指针所有的对象，像指向指针的指针等我还没有先容，因为这些对象对付一个初学指针的人来说还太巨大了，我不能让读者一开始就被太巨大的对象而吓走了。好了，到这儿吧，试着运行我上面写的小措施，也多本身写写措施，你必定会进步不小的！

    关键字：

在线提交作业