指针二
一、练习题
1.小端模式：低位储存在低字节，高位储存在高字节，从高向低读取
一位十六进制对应四位二进制
两位十六进制对应一个字节
int num = 0xabcd1234;
int* pn = #
short* p = (short*)pn;
printf("%x
", *p);
printf("%x
", *(p + 1));
int arr[5] = { 1,2,3,5,6 };
int* p = &arr[0];
int* p1 = p++;
//printf("%p
", p);
//printf("%p
", p1);
cout << *(p1 + 2) << endl;//3
int** pp = &p;
int* p2 = (int*)((int)(*pp) + 4);
cout << *p2 << endl;//3
/*
*pp取的是int* p ==>就是p的地址
*/
注意：究竟是指针加减还是整数加减
short sh[5] = { 1,2,3,4,5 };
short* psh = sh;
printf("%x
", *psh);//1
int* p = (int*)psh;
printf("%x
", *p);//20001
printf("%x
", *(p + 1));//40003
二、指针数组的关系
指针数组：是数组，指针类型的数组
本质上是数组，元素类型是指针
int a, b, c;
a = 1;
b = 2;
c = 3;
int *pa, *pb, *pc;
pa = &a;
pb = &b;
pc = &c;
//arr:指针数组 长度：3 元素类型：int*
int* arr[3] = { pa,pb,pc };
cout << *(*arr) << endl;
cout << *arr[0] << endl;
cout << arr[0][0] << endl;
//p[n]=p+n
cout << *(arr[1]) << endl;
//arr[1]=*(arr+1)
cout << *(*(arr + 1)) << endl;
cout << arr[1][0] << endl;
数组指针：是指针，指向数组的指针
本质上是指针：元素类型是数组
typedef int(*parr)[3];//parr指的是整个int(*parr)[3]，使用的时候还需要取一个名字
typedef int Arr[3];
int main()
{
Arr arr1 = { 1,2,3 };
Arr* p1 = &arr1;
parr p2 = &arr1;
//定义了两个数组指针
int arr[3] = { 1,2,3 };
//数组元素类型：int
//数组本身类型：int[3]
//指针指向的类型：int[3]
//指针本身的类型：int(* )[3]
int(*p)[3] = &arr;
//数组指针 （*p）是一个整体，数组名
cout << (*p)[0] << endl;//
cout << **p << endl;//
cout << p[0][0] << endl;//
//需要两层取内容，因为第一层是取的整个数组的arr的内容
//第二层取的是arr[0]里的内容
return 0;
}
课后习题
1，画图
char arr[3][10] = {
{"abcd"},
{"ABCD"},
{" 12345"}
};
//printf("%s", arr[2]);
char* p0 = arr[0];
cout << p0[1]<< endl;
char* p1 = arr[1];
char* p2 = arr[2];
char* parr[3] = { p0,p1,p2 };
char* (*pp)[3] = &parr;
//名字叫（*pp)的char*类型的数组
char(*pb)[3][10] = &arr;
//名字叫（*pb)的char类型的数组
cout << pb[0][1] << endl;
cout<<pb[0][1][2]<<endl;
cout << pp[0][1] << endl;
cout << pp[0][1][2] << endl;
//画图
2
double** (*p)[3][4][5] = nullptr;
cout << sizeof(p) << endl;/*对应的类型double**（*）[3][4][5] (指针) p是一个指针 四个字节 而且是一个数组指针
（*p）表示这个指针叫p ， 指向double** [3][4][5]这个指针类型的数组*/
cout << sizeof(*p) << endl;//double** [3][4][5](数组)
//一共有3*4*5=60的元素，字节=60*4=240
cout << sizeof(**p) << endl;//double** [4][5](数组)
//字节数=4*5*4=80
cout << sizeof(***p) << endl;//double** [5](数组)
//字节数=5*4=20
cout << sizeof(****p) << endl;//double**(指针)
//字节数=4
cout << sizeof(*****p) << endl;//double*(指针)
//字节数=4
cout << sizeof(******p) << endl;//double(浮点型)
//字节数=8
//1.求结果
//2.写出每一次sizeof（），括号里的对应的类型
二维数组可以视为多个一维数组
常量 const是一个修饰符
常量与指针
指针指向一个常量
可以改变指向，但是由于指向的是一个常量，所以不能通过指针改变指向的内容
C语言和c++中const的区别
C语言：（假）可以通过指针绕过变量本身的const
c++：真，永远不能改变
const int num = 10;
const int* p1 = #
int const* p2 = #
//*p1=20 不允许（c++）
//说明const在c++中是真的
//*p1=20 允许（c）
//说明在c语言中const是假的
const int num = 10;
//在C语言中,可以通过下面操作
int* p = #
*p = 20;
//在c++中，不能通过下面操作
int* p = #
*p = 20;
指针与常量
指针本身是一个常量
不可以改变指向，必须初始化
因为常量是必须初始化的
可以通过指针去改变指向的内容
int num = 10;
int* const p = #
//这是一个指针常量
int a = 0;
//p=&a==>不行
*p = 20;//可以
//因为*p指向的是int类型
//而p是被修饰的指针
常量指针常量
自己是常量，指向的也是常量
不能改变指向（必须初始化）
不能通过指针修改被指向的内容
int num = 10;
const int* const p = #
//这是一个常量指针常量
int a = 0;
//p=&a ==>不行
//*p = 20;//不可以
//因为指针，int整型都是常量不能改变。
//不能改变指向
//但是可以通过改变num来改变p
num=20;