c++基础三 （数组——指针）

新的方式  int *p=nullper （最好使用这种方式）

空指针的作用：防止指针指向随机的、不正确的、没有明确限制的地址，防止指针指向了一个地址是不确定的变量，此时去解引用就是去访问了一个不确定的地址，所以结果是不可知的（也就是野指针）

处理野指针的方法：

把指针变量赋为空指针：

数组名是常指针  不可修改
• 数组名是数组的首地址

 指针可以使用++、--、+、-      

数组名是一个常指针 不可修改

一维数组和指针：

1. 可以对指针 *** 作来访问元素
2. 用数组名：  a==&a[0]     a+1==&a[1]      a+2==&a[2]......
3. 用取地址符：&a[0]    &a[1]

数组地址表示方法：

int a[10] = {0}; int *p; p = a;p = &a[0];//这两种是等价的指针指向数组首地址 访问数组的方式： 1.直接访问数组 a[5]; 2.使用指针 *p ==a[0] *(p+1)==a[1] 3.修改数组的值 a[5]=10; *(p+5)=10;
1. const int *p  ，int const *p2   指向常量的指针  （的值不能变，指向可以变）

 int *const p3    指针常量  （值能变，指向不可以变）（&的本质） 

• const *  左边  常量指针
• * const  右边  指针常量

判别方法：看const 位于 * 的位置

int a[10] = { 0 }; int b[10] = { 1 * 10 }; const int *p = a; cout << *p << endl; *p = 20; // *p值不能改变(报错) a[0] = 2; //数组可以修改 p = b; // 指向可以改变 int const* p = a; *p = 20;//常量指针 值不能改变(报错) p = b; //常量指针 指向可以改变 a[0] = 2; //数组可以修改 int a[10] = { 0 }; int b[10] = { 1 * 10 }; int * const p = a; cout << *p << endl; *p = 20;//指针常量 值可以改变 a[0] = 30;//数组的值可以修改 p = b; //指针常量 指向不可以改变（报错）

	int a[10] = { 1,2,3,4,5,6,7,8,9 };
	int* p[10];//指针数组  含有 10个 int型指针
	p[0] = &a[0]; //p[0]指向a[0]的地址
	p[1] = &a[1]; //p[1]指向a[1]的地址
	cout << *(p[0]) << endl;//输出a[0]的值
	cout << *(p[0] + 1) << endl;//输出a[2]的值
	cout << *(p[1]) << endl;//输出a[2]的值

存储一个字符串列表
    const char *p[4] = { "aaaa","bbbb","cccc","dddd" };
	for (int i = 0; i < 4; i++)
	{
		cout << p[i] << endl;//输出字符串
        cout<<*(p[i])<< endl;//输出单个字符
	}

a+i == p+i       

1.指针数组： int  *p[10]== int *(p[10])  因为[ ]的优先级大于 * 所以p和[ ]结合

        指向：10个int 型的指针

2.数组指针： int (*p)[10]    相当于 int p[][10]  二维数组就是数组指针

        指向：数组为10个int型的元素 

3.二维数组拆解：

       a[i][j] =*(a[i]+j) = *(*(a+i)+j) =(*(a+i))[j] 

a[i] == p[i] == *(a+i) == *(p+i)

1. a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j)
int main() { int a[5][5] = {0,1,2,3,4,5,6,7,8,9}; int(*pa)[5];//数组指针 pa = a; cout << pa << endl; //代表a[0][0]的地址 cout << *pa << endl; //代表a[0][0]的地址 cout << pa[0]+1 << endl; //代表a[0][1]的地址 cout << pa +1<< endl; //代表a[1][0]的地址 cout << **pa << endl; //代表a[0][0]的值 cout << a[0][0] << endl; //代表a[0][0]的值 cout << *(pa[0]) << endl;//代表a[0][0]的值 cout << *(pa[0] +1) << endl;//代表 a[0][1]的值 cout << pa[0][1] << endl; //代表 a[0][1]的值 cout << a[0][1] << endl; //代表 a[0][1]的值 system("pause"); return 0; }
2. 字符数组：和普通数组用法一样，char a[]="zxcvbnm";

地址表：

字符指针:  指向字符串的指针,      char* p="sdasdasda"'

int a=10;    int *p= &a;   int **q=&p;

指向同一块区域

常量区只能读不能修改

两者的区别：

1. 存储位置不同，字符串指针放在//对这两个进行赋值 char a[5], *p=a; 1.因为a是数组名，所以不能用a来赋值，可以用a的下标赋值 a[1] = 10; for (int i = 0; i < 10; i++) { a[i] = i; } 2.可以用p来赋值 *p = 'p';//单个赋值 p = "pppppp";//因为字符串返回的是首地址，所以用p来接收
2. 字符数组 ：可读可修改       字符指针：
3. 用指针 

char数组名，char指针以及用引号括起的字符串常量都被解释为字符串第一个字符的地址。

所以可以用指针名l

用已定义大小的数组

1. 用未定义大小的数组
void text(int *a) { cout << a << endl; } void text(int a[]) { cout << a << endl; } void text(int a[10]) { cout << a << endl; } int a[10] = {1,2,3,4,5,6,7,8,9}; text(a);
2.  数组作函数参数时，会把数组退化为指针

注意：给函数传递数组，数组会自动地退化为一个指向改数组首地址元素的指针。因此要同时传递数组的位置进入函数，比如起始位置或者终止位置。

 数组下表转换时会退化成 指针

//做函数形参时 void tect(char a[], char p[5]) { cout << sizeof(a) << endl; cout << sizeof(p) << endl; } char a[5]; char p[5]; tect(a, p);// 结果为 4 4 把数组转化为指针 //数组下表转换 p[1] = *(p + 1);//当元素为p[1]时 编译器会转化为*(p + 1)
1. 任何指针都可以转化为 void *

void* 可以转化为任何指针