我的C++成长之路（-） 学习阶段 -03 指针与引用

指针与应用是非常重要的，我学习完之后又重新看了一遍：

指针是C和C++都具有的直接操作内存地址的数据类型，赋予了开发人员直接操作内存地址的手段

引用是一个与指针相关联的概念，应用是C++引入的特性，灵活的使用可以使程序简洁、高效。

理解指正：什么事指针？计算机在存储数据的时候，操作系统会将存储器划分为一个个小的存储单元，并且编号，这些编号就是每个存储单元的地址。如图所示，存储单元存储的是char型字符，每个存储单元都有一个地址。



指针能指向任何具有地址的对象，当然指针本身也是有地址的，所以指针也可以指向指针。如果一个指针变量的值存放的是另外一个指针变量的地址，那么这个指针成为二级指针



指针变量的声明：在使用指针变量需要先声明指针。语法：

数据类型* 指针变量名 或 数据类型 * 指针变量名或 数据类型 *指针变量名 我通常的习惯是： 数据类型 *指针变量名;

地址运算符：* 、 &

* 称为指针运算符或间接引用符，作用是取得指针指向的变量的内容，当然内容也有可能是指针变量。& 称为取地址的运算符，作用是获取变量的地址

在声明指针之后，得到一个用于存储地址的指针变量，系统会自动存入一个随机数，这时无法去顶指针指向那个存储单元，不能使用，如果此时指向的是系统核心部分，那么使用的使用会出现意想不到的错误。必须赋值后再使用

指针的赋值：声明时候同时初始化

存储类型 数据类型 *指针变量名 = 初始地址；

或者 声明后单独赋值 指针变量名 = 地址；

指针运算： 指针是一种数据类型，因此和其他数据类型一样可以参数运算如赋值运算、算术运算（和普通的数据类型有些区别）、关系运算（只有一种等于关系，指2个指针类型相同并指向同一块内存地址）

const 指针：const是修身变量的限定符号用来表示常量，同事也可以用来修饰指针

常量指针：指向常量的指针 const 数据类型 *指针变量名；表示该指针指向的对象是常量

指针常量：指针本身是常量 数据类型 * const 指针变量名；

常量指针常量：常量指针和指针常量的合体 const 数据类型 * const指针变量名;

void指针：c和c++都有的一种指针类型，可以指向任何一种数据类型。使用时将其强制类型转换后，void类型便可以访问任何数据类型的指针变量了

指针数组：如果一个数组的每一个元素都是指针变量，那么就是指针数组，显然数组的每一个元素都是同一类型的指针语法：数据类型T *指针数组名[下标表达式]

在数组中，数组名就是第一个元素的地址，及 array 和 &array[0]的等价的

声明一个指针变量指向此数组：

long array[array_size];// array_size为数组大小

long *parray = array;

测试文件 Test.cpp

#include <iostream>

using namespace std;

#define V_LINES 4

#define H_LINES 7

int main(int argc, char* argv[])

{

/* 指针操作数组

char szEnglishCharacter[V_LINES][H_LINES] = {

{'A','B','C','D','E','F','G'},

{'H','I','J','K','L','M','N'},

{'O','P','Q',' ','R','S','T'},

{'U','V','W',' ','X','Y','Z'}

};//定义二维数组，存放26个字母

char *pszCharacter [V_LINES] = {NULL};// 声明数组指针存放数组首行地址

for (int i=0; i<V_LINES; i++)

pszCharacter[i] = szEnglishCharacter[i];// 将二维数组每行首地址分配给指针

for (int i=0; i<V_LINES; i++)

for(int j=0; j<H_LINES; j++)

cout << pszCharacter[i][j] << " ";// 输出字符数据

cout << endl;// 换行

*/

return 0;

}

指针与函数：指针不仅可以作为函数的参数，还可以作为函数的返回值。

继续看下一个实例：

#include <iostream>

#include <time.h>

#include <iomanip>

using namespace std;

#define ARR_SIZE 100

long getMax(long [], long);// 传递数组返回最大值

long getMaxWithPointer(long *, long);// 传递指针返回最大值

long swap_value(long *, long *);// 声明交换函数原型

int main(int argc, char *argv[])

{

long lArray[ARR_SIZE];

srand((unsigned)time(NULL));

cout<<"产生随机数组："<<endl;

for(int nCnt=0; nCnt<ARR_SIZE; nCnt++)

{

lArray[nCnt] = rand();

if(nCnt %5 == 0 && nCnt != 0)

cout<<endl;// 输出5行，换行

cout<<setw(10)<<lArray[nCnt]<<"";// 输出元素并设置输出宽度为10

}

long *plArray = lArray;// 将指针指向数组

cout<<endl<<"用数组传递得到的最大值："<<getMax(lArray, ARR_SIZE)<<endl;

cout<<"用指针传递得到的最大值："<<getMaxWithPointer(plArray, ARR_SIZE)<<endl;

///////////////

long t1(100), t2(200);

cout<<"交换前t1="<<t1<<", t2="<<t2<<endl;

swap_value(&t1, &t2);

cout<<"交换后t1="<<t1<<", t2="<<t2<<endl;

return 0;

return 0;

}

long getMax(long lArray[], long lArraySize)

{

long lMax = 0;

for(int i=0; i<lArraySize; i++)

if(lMax < lArray[i]) lMax = lArray[i];// 如果当前值比最大值大，则交换

return lMax;

}

long getMaxWithPointer(long *plArray, long lArraySize)

{

long lMax = 0;

for(int i=0; i<lArraySize; i++)

if(lMax < *(plArray + i)) lMax = *(plArray + i);// 如果当前值比最大值大，则交换

return lMax;

}

// 定义交换函数

long swap_value(long *t1, long *t2)

{

*t1 = *t1 + *t2;

*t2 = *t1 - *t2;

*t1 = *t1 - *t2;

return 0;

}

// 局部变量与全局变量

#include <iostream>

using namespace std;

char str[5] = {'A', 'A', 'A', 'A', 'A'};

char *SetStr(char [], long);

char *GetStr();

int main(int argc, char *argv[])

{

char *pStr = SetStr(str, 5);// 调用SetStr函数

cout<<pStr<<endl;

pStr = GetStr();

cout<<pStr<<endl;

return 0;

}

char *SetStr(char str[], long strSize)

{

for(long i=0; i<strSize; i++)

str[i] = 'B';

return str;// 设置字符数组的值，返回全局性变量指针，没有问题。

}

char *GetStr()

{

char str[5] = {'A', 'A', 'A', 'A', 'A'};

return str;// 返回局部性变是不可取的，结果无法预测

}

// 函数指针的应用

#include <iostream>

using namespace std;

void swap_value(long *, long *);// 声明函数原型

int main(int argc, char *argv[])

{

long test1(200), test2(100);// 定义变量

long *pT1 = &test1, *pT2 = &test2;// 定义2个指针指向变量test1,test2

void (*pFuc)(long *, long *);//声明函数指针

pFuc = swap_value;//给函数指针赋值

(*pFuc)(pT1, pT2);// 利用函数指针调用函数

cout<<test1<<","<<test2<<endl;

return 0;

}

// 定义函数

void swap_value(long *t1, long *t2)

{

*t1 = *t1 + *t2;

*t2 = *t1 - *t2;

*t1 = *t1 - *t2;

}

//////////////////////////////////////

#include <iostream>

using namespace std;

void print_teacher();// 声明函数原型

void print_student();

void print_body(void (*pFunc)());//声明带有函数指针的函数原型

int main(int argc, char *argv[])

{

void (*print_message)();// 函数指针

int nChoose(0);

cout<<"请选择：1为老师，2为学生。"<<endl;

cin>>nChoose;

switch(nChoose)

{

case 1: print_message = print_teacher;break;

case 2: print_message = print_student;break;

default:cout<<"输入错误"<<endl;exit(1);

}

print_body(print_message);

return 0;

}

// 定义打印老师的函数

void print_teacher()

{

cout<<"老师姓名：张三"<<endl;

}

// 定义打印学生的函数

void print_student()

{

cout<<"学生姓名：李四"<<endl;

}

void print_body(void (*pFunc)())//传入函数指针

{

pFunc();

}

引用

#include <iostream>

using namespace std;

// 操作引用

int main(int argc, char *argv[])

{

int iValue;// 定义一个int型变量

int& rValue = iValue;// 声明这个int型变量的引用为rValue;

iValue = 0;

cout << "输出变量值 iValue = " <<iValue <<endl;

cout << "输出引用的变量值 rValue = " << rValue << endl;

rValue = 100;// 操作引用

cout << "输出变量值 iValue = " <<iValue <<endl;

cout << "输出引用的变量值 rValue = " << rValue << endl;

//输出他们的地址

cout << &iValue << endl;

cout << &rValue << endl;

return 0;

}

接下来为了节约时间，没有做过多的说明，只是简单的贴上代码，我能看懂就行了。

案例：

#include <iostream>

using namespace std;

void swap(int& rInt1, int& rInt2);// 前向引用声明

int main(int argc, char *argv[])

{

int a(10), b(20);

cout << "a = " << a << ", b = " << b << endl;

swap(a, b);

cout << "a = " << a << ", b = " << b << endl;

return 0;

}

void swap(int& rInt1, int& rInt2)

{// 参数声明为引用传递

rInt1 = rInt1 + rInt2;

rInt2 = rInt1 - rInt2;

rInt1 = rInt1 - rInt2;

}

/////////

#include <iostream>

using namespace std;

int& GetMaxForArray(int arr[ ], int nSize);// 声明函数原型，利用引用作为函数返回值

int main(int argc, char *argv[])

{

int nArray[5] = {4,5,32,22,33};

int max = GetMaxForArray(nArray, 5);

cout << max << endl;

return 0;

}

int& GetMaxForArray(int arr[], int nSize)

{

int nIndex(0), nMax(0);

for(int nCnt(0); nCnt<nSize; nCnt++)

{

if(nMax < arr[nCnt]) nMax = arr[nCnt];

nIndex = nCnt;

}

return arr[nIndex];// 将数组中的最大值作为引用返回

}