6.4 指针与函数

6.4.1 指针作为函数参数

用指针作为函数参数实现地址调用，必须满足以下条件：

• 函数的形式参数是指针变量。
• 函数的实际参数是内存的地址，具体来说可以是数组名、变量的地址、用变量地址初始化的指针。
• 形式指针类型和实参地址类型必须相同。

满足以上条件后,这样的函数调用在使用上有以下特点。

• 实参传递给形参的是内存的地址，所以形参指针指向是参变量。
• 形参指针通过间接引用直接访问实参变量，包括改变实参变量的值。
• 函数调用后，可以保留对实参变量的操作结果，如果有多个实参，就可以有多个实参变量在函数调用中得到修改。

//用地址调用的方式改变交换值 
#include<iostream>
using namespace std;
void swap (int* a,int* b)
{
    int t;
    t = *a;
    *a = *b;
    *b = t; 
}
int main()
{
    int x(5),y(10);
    swap(&x,&y);
    return 0;
}

以上程序也可以用指针变量作为实参，效果是一样的，相关语句是

int x(5),y(10);
int* px = &x,*py = &y;
swap(px,py);

6.4.2 引用作为函数参数

引用的主要应用就是作为函数的形式参数。
引用作为函数的形式参数具有以下特点：

• 引用作为形式参数时，实际参数是相同类型的变量（不是地址）。
• 引用作为形式参数时，参数传递属于地址传递。
• 引用作为形式参数时，在函数中并不产生实际参数的副本，形式参数的引用和实际参数的变量实际上是同一个实体。
• 函数对引用的操作，也是对实参变量的操作，函数··调用可以改变实际参数的值。

//用引用作为形式参数，交换两个实际参数 
#include<iostream>
using namespace std;
void swap (int& a,int& b)  //引用作为形式参数 
{
    int t;
    t = a;
    a = b;
    b = t; 
}
int main()
{
    int x(5),y(10);
    swap(x,y);
    return 0;
}

用指针作为形式参数和引用作为形式参数是非常相似的。

• 都属于地址调用。
• 在函数调用时都不建立实参的副本，而是对实参的数据直接进行操作。
• 指针作为形式参数需要在函数中定义指针变量，引用作为形式参数不需要新建任何实体，所以用引用不需要占用新的内存，执行效率更高。

6.4.3. 常指针和指针常量

3.1 常指针

常指针是指向常量的指针，就是规定指针所指向的内容不可以通过指针的简介引用来改变。
常指针定义的格式如下：
const<类型名>*<指针名>;
例如：
const int* ptint;
其中，指针ptint的类型是(const int*)，也就是指向一个恒定的整型数。但是，这个整型数本身是可以改变的，只是不可以通过指针ptint的间接引用来改变。而ptint也可以用不同的地址对它赋值。
类似地，也可以定义常引用，格式为：
const<类型名>&<引用名>;

3.2 指针常量

指针常量，也就是指针本身的内容是常量，不可以改变。指针常量声明的格式为：
<类型名>const*<指针名>=<初值>;
例如：
char ch,*const ptch=&ch;
这时，指针ptch是用ch地址初始化的常量，不可以改为其它地址，但是可以通过ptch的间接引用来改变ch的值。

6.4.4 指针函数和函数指针

4.1 指针函数

返回指针的函数称为指针函数。例如：
int* fun(int k);
注意：不能返回函数中局部变量的地址，必要时使用堆空间。

4.2 函数指针

函数名本身就是地址。指向函数的指针成为函数指针，定义函数指针的语法格式为
<类型名>（*指针名）（形参列表）；
int (*fptr) (int,int)
上面的语句定义了一个函数指针fptr，它可以指向带两个整型参数且返回值类型为整型的任何函数

6.5 指针与字符串

字符串常量存放在内存的常量区域，有自己固定的首地址。如果将字符串常量的首地址看作指针，这种指针既是常指针，也是指针常量，即字符串的内容是不能改变的，而且首地址也是不能改变的。

6.5.1 字符串处理的两种方式

数组方式是将字符串存入字符数组后，再进行处理。一般可以在声明数组的时候用字符串来初始化。例如：
char string_array[] = "What's a nice day!";
指针方式是用字符串常量来初始化一个字符指针，例如：
char* string_pt = "What's a nice day!";
这样的字符数组和字符指针都可以当作字符串使用，也可以进行字符串的各种操作。但是两者在一些具体操作上还是有不同的。

表6-1

在表中，基于数组形式的字符串有两种操作不允许。因为数组名是指针常量，不可以放在等号左边。基于指针的字符串有一操作不允许，因为指针s_pt已经用字符串首地址初始化了，再通过cin来修改指针所指的值当然是不允许的。

6.5.2 字符串操作函数

以后补充。。。

6.6 指针与数组

6.6.1 通过指针访问一维数组

一维数组名就是数组的地址，因此，一维数组名可看做指针，具有以下特点：

• 指针的类型是指向数组元素的指针，因此，数组名也是数组第一个元素的地址，对于数组A来说，数组名A和&A[0]具有相同的类型和相同的指。
• 通过数组名的间接引用运算，如*A，就可以访问A[0]。
• 数组名所包含的地址是不可改变的，是指针常量。

要通过指针访问一维数组，必须首先声明一个和数组类型相同的指针，并且用数组名来对指针进行初始化，例如：
int A[10]; int* p = A;
然后，就可以通过数组名或所定义的指针变量，用以下方式访问数组元素：

• 数组名和下标，如A[0]、A[1]。
• 指针和下标，如pa[0]、pa[1]。
• 指针加偏移量的间接引用，如*(pa+0)、*(pa+1)。
• 数组名加偏移量的间接引用，如*(A+0)、*(A+1)。
• 指针自加后的间接引用，如*pa++。注意，这种方式会改变指针的值。

但是，不允许A++，因为数组名是指针常量。

6.6.2 指针数组

若数组元素是某种类型的指针，称这样的数组为指针数组。
指针数组声明的格式如下：
<类型>*<数组名>[常量表达式];
例如：
char* member_name[10];
实际用的最多的是指向字符的指针：用这些元素指向一些不同长度的字符串。例如：
char* membber_name[] = {"Merry","John","Hill"};

6.6.3 指针数组作 main 函数的形参

以后补充....

6.6.4 二维数组与指针

二维数组可以看成是一维数组的一维数组，二维数组名虽然也是地址（指针），但是却与一维数组名有不同的类型。
对于一维数组A[5]，数组名A的值，就是数组第一个元素A[0]的地址。指针的类型是指向数组元素的指针。A+1就是元素A[1]的地址。即A = &A[0]。
对于二维数组B[3][4]，数组名B的值，则是其中第一个一维数组B[0]的地址。指针的类型是指向一维数组的指针。B+1就是下一个一维数组B[1]的指针。即B = &B[0]；B + 1 = &B[1]。
在定义指向一维数组的指针时，必须指出一维数组的大小。指向一维数组的指针的格式如下：
<类型名>(*指针变量名)[一维数组大小];
例如：
char (*ptch)[4] = B;
这样定义后，ptch就是指向B[0]的指针，ptch+1就是指向一维数组B[1]的指针。
对于指向一维数组的指针，具有以下特征：

• 二维数组名是指向一维数组的指针，而不是指向数组元素的指针。
• 指向一维数组指针加1的结果，是指向下一个一维数组的指针。
• 指向一维数组的指针的间接引用的结果仍然是地址，即*ptch仍是地址，只是地址的类型变了，变为一维数组其中的元素的地址。

用指向一维数组指针访问数组元素的一般公式是*(*(指针名+i)+j)：(指针名+i)是二维数组第 i 行的地址，*(指针名+i)是第 i 行第 0 列元素的地址，(*(指针名+i)+j)是第 i 行第 j 列元素的地址，*(*(指针名+i)+j)是第 i 行第 j 列的元素的值。
一般来说，访问二维数组的程序都需要使用双重循环。借助于指向一维数组指针的概念，可以用单循环访问二维数组。

//用单循环程序，求二维数组元素的平均值 
#include<iostream>
using namespace std;
int main(void)
{
    int A[3][4] = {32,42,12,25,56,76,46,53,76,96,82};
    int (*p)[4] = A;  //指向一维数组指针的初始化 
    int sum,j;
    float ave;
    sum = 0;
    j = sizeof A/sizeof**A;    // 计算出数组元素个数 
    for(int i=0;i<j;i++)
        sum = sum+*(*p+i);
    ave = (float)sum/j;
    cout << "数据的平均值 = " << ave << endl ; 
    return 0;
}

这个程序把A看成一维数组，一维数组的首地址是*p（实际是A），其余数组元素的地址是*p + i，再对这样的指针做间接引用(*(*p+i))，就可以访问整个二维数组。
注意，当A是二维数组名时，如下格式不存在：
int** p = A;

6.6.5 指针与结构体

在实际应用中，当结构体成员较多时，需要在堆内存中进行存储，这就需要使用指向结构体的指针。
声明了指向结构的指针后，必须对指针初始化。指针的初始化有两种方法：
• 可以将结构变量的地址赋给结构指针，使用“ & ”操作，得到结构变量的地址，这个地址就是结构的第一个成员的地址。例如：

struct student           //声明新的数据类型 
{   
    long num;           //学号 
    char name[20];      //姓名 
    float score;        //成绩 
};
student stu = {20041118,"Li Li",81};  //定义结构变量并初始化 
student* ps = &stu;                   //定义结构指针并初始化

• 使用new操作在堆中给结构指针分配空间。例如：
student* ps = new student; //定义结构指针用动态地址初始化
用结构指针访问结构成员时，用箭头操作符代替原来的点操作符对结构体成员进行操作。例如，将学生的成绩输出显示，语句如下：
cout << ps->score;
其中，ps->score等价于(*ps).score 。

C++学习——指针和引用（进阶）