我的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];// 将数组中的最大值作为引用返回
}