指针2-

指针二

一、练习题

1.小端模式：低位储存在低字节，高位储存在高字节，从高向低读取

一位十六进制对应四位二进制

两位十六进制对应一个字节

int num = 0xabcd1234;
	int* pn = #
	short* p = (short*)pn;
	printf("%x\n", *p);
	printf("%x\n", *(p + 1));
	

int arr[5] = { 1,2,3,5,6 };
	int* p = &arr[0];
	int* p1 = p++;
	//printf("%p\n", p);
	//printf("%p\n", 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\n", *psh);//1
	int* p = (int*)psh;
	printf("%x\n", *p);//20001
	printf("%x\n", *(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"},
		{"\012345"}
	};
	//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;