C++之Const与指针

三.const与指针

1.C语言中的const

int main()
{
	const int n = 10;//n以变量为主
	int arr[n]{ 1,2,3 };//会出现报错，因为数组大小为常量

    const int a = 10;//a仍然是变量，值可能还会被改
	int b = 0;
	int* ip = (int*)&a;
	*ip = 100;//a=100
	b = a;//b=100
	printf(" % d % d % d", a, b, *ip);//100 100 100
    
	return 0;
}

2.C++中的const

int main()
{
	//C++，a以常量为主
	const int a = 10;//a变成常量,看见a就替换成10
	int b = 0;
	int* ip = (int*)&a;
	*ip = 100;//a=10
	b = a;//b=10
	printf(" % d % d % d", a, b, *ip);//10 10 100

	return 0;
}

3.const 与指针的关系

int main()
{
	int a = 10, b = 10;
	int* p1 = &a; // 普通指针
	const int* p2 = &a; // 指向为常性（解引用为常性)
	int const* p2 = &a;
	int* const p3 = &a; // 指针变量自身为常性
	const int* const p4 = &a; // 指向（解引用）和指针变量自身都为常性
}

int main()
{
	int a = 0;
	int* p1 = &a; // ok;
	const int* p2 = &a; // ok;
	int* const p3 = &a; // ok;
	const int* const p4 = &a; // ok;
	return 0;
}
//编译方式不同

4.常变量与指针

int main()
{
	const int a = 10;
	int* p1 = &a; // error;
	const int* p2 = &a; // ok;
	int* const p3 = &a; // error;
	const int* const* p4 = &a; // ok;
	int* p5 = (int*)&a; // ok 不安全
	return 0;
}

5.同类型指针的赋值兼容规程

int main()
{
	int a = 10, b = 20;
	int* p = &a;
	int* s1 = p; // ok;
	const int* s2 = p; // ok;
	int* const s3 = p; // ok;
	const int* const s4 = p; //ok;
}

6.常见的例题

（1）

int main()
{
	int a = 10, b = 20;
	int* p1 = &a;
	*p1 = 100;
	p1 = &b;

	const int* p2 = &a;
	*p2 = 100;//错，*p2被const修饰，不能改变
	p2 = &b;

	int* const p3 = &a;
	*p3 = 100;
	p3 = &a;//错p3被const修饰，不能改变

	const int* const p4 = &a;
	*p4 = 100;//错
	p4 = &b;//错
    //都被const修饰，都不能改变

}

（2）

 int main()
{
    //全部编译通过
	int a = 10, b = 20;
	int* p = &a;//p是a的地址
	int* s1 = p;//指针s1=指针p,是a的地址
	const int* s2 = p;//指针s2=指针p,是a的地址，并且*s2也就是a不能改变
	int* const s3 = p;//指针s3=指针p,是a的地址，并且s3也就是a的地址不能被改变
	const int* const s4 = p;//指针s4=指针p,是a的地址，并且*s4也就是a不能改变且也S4就是a的地址不能被改变

	return 0;
}

（3）

int main()
{
	int a = 10, b = 20;
	const int* p = &a;//*p不能被改变，
	int* s1 = p;//error//因为*S1的改变会改变p的值，（p指向a的地址）不安全
	const int* s2 = p;
	int* const s3 = p;//error//因为*S3的改变会改变p的值，（p指向a的地址）不安全
	const int* const s4 = p;

	return 0;
}

（4）

int main()
{
    //全部编译通过
	int a = 10, b = 20;
	int* const p = &a;
	int* s1 = p;
	const int* s2 = p;
	int* const s3 = p;
	const int* const s4 = p;

	return 0;
}

总结： 能力强的指针赋值给能力收缩的指针