C++学习笔记（四）--指针

1.指针(变量的地址)：
　　指针变量：存放指针（地址）的变量
　　直接存取（访问）：按变量地址取值
　　间接存取（访问）：将变量的地址放入指针变量中
　　定义指针变量：基类型 *指针变量名

2.与指针有关的运算符：
　　&：取地址运算符
　　*：指针运算符（间接访问运算符）；
　　int *pointer_1,*pointer_2;
　　int a = 1, b = 2;
　　pointer_1 = &a;
　　pointer_2 = &b;
　　pointer_2 = &*pointer_1;//*,&优先级一样，自右至左结合，所以是先取a的值，再取a的地址&a给指针变量pointer_2
　　若有*&a，表示的是先取a的地址，再取a的值。

3.谨记：函数传参：实参->形参 之间的数据是单向传递的“值传递方式”，指针变量也遵守这一原则，调用函数时，不会改变实参指

针变量的值，但可以改变实参指针变量所指向的值。所以可以利用指针来改变主调函数中多个变量的值，不用指针变量来实现这个是

很难实现这一点的。

4.数组元素的指针就是数组元素的地址

　　int a[10];
　　int *pointer;
　　pointer = a[0];与pointer = a; 等价都表示数组的第一个元素的地址。

　　如果初始：pointer = a; 以下都为此前提，那么：
　　pointer+1 = a+1 = a[1] //实际地址看类型，pointer+1*n 或者 a+1*n 或者&a[1]
　　所以有pointer+i = a+i = a[i] pointer+i*n a+i*n &a[i] 例：int型n=4;

　　所以可以看出[]是变址运算符，对a[i]的处理是这样的：先按a+i*n计算数组元素的地址，然后由此地址找出所指向的单元的

值
　　指向数组元素的指针变量也可以带下标，如：pointer[i]与*（pointer+i）等价。
　　所以引用数组元素有两种方法：
　　a.下标法：a[i];
　　b.指针法：*（a+i）或者*（pointer+i）；使用这种方法能使目标程序质量高（占运行内存小，运行速度快）
　　·注意：指针变量可以指向有效的数组元素，也可以指向数组以后的内存单元。例：
　　int a[10], *p = a;
　　cout <<*(p+10);//编译不会提示出错。

　　5.如果先使p=a，即p指向数组a的首元素：
　　（1）.p++(或p+=1):使p指向下一元素，即a[1],如果用*p，则得到a[1]的值；
　　（2）.*p++: ++与*优先级相同，右结合，相当于*(p++)，所以是先取*p的值，再使p++。
　　例如：
　　for(p=a;p<a+10;p++)
　　cout <<*p ; //可改写为：
　　for(p=a;p<a+10; )
　　cout <<*p++;
　　（3）.*(p++):先取*p值，p再加1
　　*(++p):先p加1，再取*p值，二者区别仅在于p++ 与 ++p 的含义。
　　（4）.（*p）++:先取*p的值，再使取得的值加1.
　　（5）.如果p当前指向a[i]:
　　*(p--): 先取*p的值，即a[i],再使指针变量p指向a[i-1];
　　*(++p): 先使指针变量自增1，指向a[i+1],再取*p的值a[i+1];
　　*(--p): 先使指针变量自减1，指向a[i-1],再取*p的值a[i-1];

6.使用指针变量作函数参数接收数组地址
因为数组作形参时接收的也是实参数组的首地址，所以可以用指针变量来接收以数组为实参的参数，例如：
　　void select(int array[]);//实际上可以表示为
　　void select(int *array );/*编译器实际上是将数组名作为指针变量来处理的。所以实际上，在函数调用时并不存在一个

　　占有存储空间的形参数组，只有指针变量。*/

7.多维数组与指针：
　　int arr[3][4];假设arr起始为2000

　　（1）C++中规定了数组名作为首地址，所以
　　arr[0]是arr[0][0]的首地址，arr[1]是arr[1][0]的首地址即&arr[1][0],
　　arr[0]+1，表示arr[0][1]的地址，arr[0]+2表示的是arr[0][2]的地址；
　　*（arr[0]+2） 表示a[0][2]的值。所以有
　　arr[i]+j 表示&arr[i][j]，
　　*(arr[i]+j) 表示arr[i][j]的值。
　　（2）arr,表示首行地址&arr[0],则a+1表示第二行起始地址&arr[1]，其值为2000+4*4=2016；
　　arr[1]+1: 表示 &arr[1][1]，所以有
　　arr[i]+j: 表示 &arr[i][j],
　　*（arr[i]+j)：表示 arr[i][j]的值，因为arr[i] = *(arr+i);所以
　　*（*（arr+i)+j）: 也表示arr[i][j]的值。
　　（3）指向数组元素的指针变量：
#include<iostream>
using namespace std;

int main(){

　　int array[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
　　int *p;
　　p = array[0];//注意此处是array[0],而不是array，要符合指针类型。
　　cout <<"--------------" <<endl;
　　for( p; p<array[0]+12;p++ )
　　cout <<*p<< ' ';
　　cout <<endl;
　　cout <<"--------------" <<endl;
　　return 0;
}
（4）指针变量指向由m个元素构成的一维数组
#include<iostream>
using namespace std;

int main(){

　　int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
　　int (*p)[4],i,j;/*(*p)[4]是一个指针变量，它指向包含4个整型元素的一维数组，()不可丢，
否则变成*p[4]，[]优先级高,变成了指针数组
*/
　　p = a;//p指向a[0];
　　cout <<"please input i,j:";
　　while(1){
　　　　cin >>i >>j;
　　　　if( i>=3||j>=4 )
　　　　cout <<"warning:i must less then 3,j must less then 4,please try a again:" <<endl;
　　　　else break;
　　}
　　cout <<"---------------------" <<endl;
　　cout <<*(*(p+i)+j);
　　cout <<endl <<"---------------------" <<endl;
　　return 0;
}

8.指向数组的指针作函数参数(一维数组名，多维数组名也可，之前有讲过)
#include<iostream>
using namespace std;

int main(){

　　void output(int (*p)[4]);
　　int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
　　output(a);//a指向a[0]
　　return 0;
}

void output(int (*p)[4]){//注意形参声明为指向一维数组的指针变量，而不是int型指针变量

　　int i,j;
　　for( i=0;i<3;i++ )
　　　　for( j=0;j<4;j++ )
　　　　　　cout <<*(*(p+i)+j) <<" ";
　　cout <<endl;
}

9.字符指针(C++中共3种方法访问一个字符串，之前已经学习过两种)
(1)用字符指针指向一个字符串
#include<iostream>
using namespace std;

int main(){

　　char *str = "I love China!";//对字符指针变量str的初始化其实是把字符串第一个元素的 地址 赋给str
　　//等价于 char *str; str = "I love China"; 输出时，系统先输出str指向的第一个字符数据，
　　//然后str+1，使之指向下一个字符，然后输出......直至遇到'\0'为止，在内存中，字符串的末尾
　　//被自动加了一个'\0'
　　cout <<str<<endl;
　　return 0;
}
(2)利用字符指针实现对字符串的存取
#include<iostream>
using namespace std;

int main(){

　　char str1[] = "I love liu_xiao_min",str2[20];
　　char *p1,*p2;
　　p1 = str1;
　　p2 = str2;
　　for( ;*p1!='\0';p1++,p2++ )
　　*p2 = *p1;//其实string str1 = "I love liu_xiao_min",str2;str2 = str1;最简单快捷
　　*p2 = '\0';
　　p1 = str1;
　　p2 = str2;
　　cout <<p1 <<endl;
　　cout <<p2 <<endl;
　　return 0;
}

10.函数与指针
(1)用函数指针变量调用函数(原理：一个函数被编译时被分配一个入口地址。这个函数入口地址就称为函数的指针)
函数指针定义：
函数类型 (*指针变量名)(函数形参表);
例：
#include<iostream>
using namespace std;

int main(){

　　int max( int x, int y );
　　int (*p)( int, int );//(*p)括号不能漏
　　int a,b,n;
　　p = max; //函数名代表函数入口地址
　　cin >>a >>b;
　　m = p( a,b );
　　cout <<"max=" <<m<<endl;
　　return 0;
}
int max( int x, int y ){

　　int z;
　　if( x>y )
　　　　z = x;
　　else
　　　　z = y;
　　return z;
}

(2)用指向函数的指针作函数参数
类似：float intern(float a, float b, float (*fun)(float));

11.指针函数（函数返回值为指针的函数）
指针函数定义：
函数类型 *函数名（参数表列）;
例：
#include<iostream>
using namespace std;

int main(){
　　int *a(int a);
　　int i = 10;
　　cout <<a( 10 ) <<endl;
　　return 0;
}

int *a( int a ){

　　return &a;
}

12.指针数组（一个数组，其元素全部为指针类型数据）

一维指针数组：
类型名 *数组名[数组长度];

例：int *a[3]； //注意与int (*a)[3];的区别，后者是指向含有3个整型元素的一维数组的指针变量

#include<iostream>
#include<cstring>
using namespace std;

int main(){

void sort( char *name[], int n );//指针数组做函数参数
void print( char *name[], int n );

　　char *name[] = { "BASIC","FORTRAN","C++","Pascal","COBOL" };//指针数组
　　int n = 5;
　　sort( name,n );
　　print( name,n );
　　return 0;
}

void sort( char *name[], int n ){ //选择法排序

　　char *temp;
　　int i,j,k;
　　for( i=0;i<n-1;i++ ){
　　　　k = i;
　　　  for( j=i+1;j<n;j++ ){
　　　　if( strcmp( name[k],name[j] )>0 )//name[x]中存放各个字符串的首地址
　　　　　　k = j;
　　　　}
　　　　if( k!=i ){
　　　　temp = name[i];name[i] = name[k];name[k] = temp;
　　　　}
　　}
}

void print( char *name[] , int n ){

　　int i;
　　for( i=0;i<n;i++ )
　　cout <<name[i] <<endl;
　　}
输出：
BASIC
C++
COBOL
FORTRAN
Pascal

13.指向指针的指针（指向 指针数据 的指针）
如12所述，数组name[x]是一个指针数组，此时设一个指针变量p，它指向指针数组元素的元素，则p就是指向指针型数据的指

针变量。
定义一个指向指针数据的指针：
char *(*p);//可以写成 char **p;
分析：
char *p:表示指向字符型数据的指针变量(即字符指针变量)。
char *（*p）：表示p指向的是字符指针数据
例：
#include<iostream>
using namespace std;

int main(){

　　char **p;//定义指向 字符指针数据 的指针变量p
　　char *name[] = { "BASIC","FORTRAN","C++","Pascal","COBOL" };
　　p = name + 2; //指向name[2]
　　cout <<*p <<endl;//输出name[2]中指针指向的字符串的值
　　cout <<**p <<endl;//输出name[2]指向的字符串中的第一个字符
　　return 0;
}
输出：
C++
C
分析：
由于*p代表name[2],它指向字符串"C++"，即在name[2]中存放了字符串"C++"的第一个字符串的地址，因此"cout <<*p <<endl;"就

是从第一个字符开始输出字符串"C++"。第二个cout中的**p是*p(值为name[2])指向的"C++"第一个字符元素的内容，即字符"C",所以

第二个cout语句输出"C".