常量指针与指针常量

常量指针与指针常量

常量指针

错误的理解

本质是一个指针，该指针指向的变量不能改变。

正确的理解

常量指针：
1、本质是一个指针，不能通过该指针去改变对应变量的值。
2、被指向的变量依然可变。
3、常量指针能够指向另外的变量。

被指向的变量值可变(使用变量直接赋值的方式)

#include<stdio.h>
int main(void)
{
	/*常量指针定义方式：
	**比如一个int 类型的指针是这样定义的  int *p;
	**那么int 类型的常量指针需这样定义：const int *p;或者int const *p;
	*/
	int a=4;
	const int *p=&a;
	printf("%d\n",a);
	/*我们试图去改变a的值,看是否会报错误*/
	a=6;
	
	printf("%d\n",a);					
	return 0;		
}

结果输出正常，未报任何错误；

通过常指针去改变被指向的变量值报错

#include<stdio.h>
int main(void)
{
	/*常量指针定义方式：
	**比如一个int 类型的指针是这样定义的  int *p;
	**那么int 类型的常量指针需这样定义：const int *p;或者int const *p;
	*/
	int a=4;
	const int *p=&a;
	//p=&b;
	//print("%d",*p);
	printf("%d\n",a);
	/*我们试图去改变a的值,看是否会报错误*/
	//a=6;
	*p=6;/*通过常量指针更改a的值，编译报错*/
	
	printf("%d\n",a);					
	return 0;		
}

更改常指针的指向

#include<stdio.h>
int main(void)
{
	/*常量指针定义方式：
	**比如一个int 类型的指针是这样定义的  int *p;
	**那么int 类型的常量指针需这样定义：const int *p;或者int const *p;
	*/
	int a=4,b=5;
	const int *p=&a;
	printf("常指针*p指向a后 *p= %d\n",*p);
	p=&b;
	//printf("a=%d\n",a);
	//printf("b=%d\n",b);
	printf("常指针*p指向b后 *p= %d\n",*p);
	/*我们试图去改变a的值,看是否会报错误*/
	//a=6;
	//*p=6;/*通过常量指针更改a的值，报错*/
	
	//printf("a=%d\n",a);					
	return 0;		
}

常量指针的用法思考

1、将函数的形参申明为常量指针，防止变量在函数调用的过程中发生改变。

#include<stdio.h>
int Sum(const int *a,const int *b);
int main(void)
{
	/*常量指针定义方式：
	**比如一个int 类型的指针是这样定义的  int *p;
	**那么int 类型的常量指针需这样定义：const int *p;或者int const *p;
	*/
	int a=4,b=5;
	const int *p=&a;
	printf("常指针*p指向a后 *p= %d\n",*p);
	p=&b;
	//printf("a=%d\n",a);
	//printf("b=%d\n",b);
	printf("常指针*p指向b后 *p= %d\n",*p);
	/*我们试图去改变a的值,看是否会报错误*/
	//a=6;
	//*p=6;/*通过常量指针更改a的值，报错*/
	
	//printf("a=%d\n",a);		
    printf("a+b=%d\n",Sum(&a,&b));
	return 0;		
}
int Sum(const int *a,const int *b)
{
	//*a=1;  /*此处对常量指针a指向的内容进行改变，会报编译错误*/
	//*b=2;  /**/
	return *a+*b;
}

将形参改为非常量指针后，可正常编译执行

#include<stdio.h>
int Sum(int *a,int *b);
int main(void)
{
	/*常量指针定义方式：
	**比如一个int 类型的指针是这样定义的  int *p;
	**那么int 类型的常量指针需这样定义：const int *p;或者int const *p;
	*/
	int a=4,b=5;
	const int *p=&a;
	printf("常指针*p指向a后 *p= %d\n",*p);
	p=&b;
	
	printf("常指针*p指向b后 *p= %d\n",*p);
	/*我们试图去改变a的值,看是否会报错误*/
	//a=6;
	//*p=6;/*通过常量指针更改a的值，报错*/
	
	//printf("a=%d\n",a);		
    printf("a+b=%d\n",Sum(&a,&b));
	printf("a=%d\n",a);
	printf("b=%d\n",b);
	return 0;		
}
int Sum(int *a, int *b)
{
	*a=1;
	*b=2;
	return *a+*b;
}

不能将常指针转化为一般指针

#include<stdio.h>
typedef struct
{
	int a;
	int b;
}Sum_DataType;

int Sum(Sum_DataType *p);
int main(void)
{
	/*常量指针定义方式：
	**比如一个int 类型的指针是这样定义的  int *p;
	**那么int 类型的常量指针需这样定义：const int *p;或者int const *p;
	*/
	int a=4,b=5;
	const int *p=&a;
	Sum_DataType m={10,4};
	
	Sum_DataType const *Sum_point=&m;
	m.b=6;
	//Sum_point->b=7;   /*编译报错*/
	
	
	printf("m.b=%d\n",m.b);	
	//printf("常指针*p指向a后 *p= %d\n",*p);
	//p=&b;
	
	//printf("常指针*p指向b后 *p= %d\n",*p);
	/*我们试图去改变a的值,看是否会报错误*/
	//a=6;
	//*p=6;/*通过常量指针更改a的值，报错*/
	
	//printf("a=%d\n",a);		
    printf("a+b=%d\n",Sum(Sum_point));
	//printf("a=%d\n",a);
	//printf("b=%d\n",b);
	return 0;		
}
int Sum(Sum_DataType *p)
{
	p->a = 2;
	p->b = 4;
	return p->a+p->b;
}

常指针作用范围为类型

#include<stdio.h>
typedef struct
{
	int a;
	int b;
}Sum_DataType;

int Sum(const Sum_DataType *p);
int main(void)
{
	/*常量指针定义方式：
	**比如一个int 类型的指针是这样定义的  int *p;
	**那么int 类型的常量指针需这样定义：const int *p;或者int const *p;
	*/
	int a=4,b=5;
	const int *p=&a;
	Sum_DataType m={10,4};
	
	Sum_DataType const *Sum_point=&m;
	m.b=6;
	//Sum_point->b=7;   /*编译报错*/
	
	
	printf("m.b=%d\n",m.b);	
	//printf("常指针*p指向a后 *p= %d\n",*p);
	//p=&b;
	
	//printf("常指针*p指向b后 *p= %d\n",*p);
	/*我们试图去改变a的值,看是否会报错误*/
	//a=6;
	//*p=6;/*通过常量指针更改a的值，报错*/
	
	//printf("a=%d\n",a);		
    printf("a+b=%d\n",Sum(Sum_point));
	//printf("a=%d\n",a);
	//printf("b=%d\n",b);
	return 0;		
}
int Sum(const Sum_DataType *p)
{
	//p->a = 2;/*编译报错*/
	//p->b = 4;/*编译报错*/
	return p->a+p->b;
}

一般指针可以强制转化为常指针，编译不会报错

#include<stdio.h>
typedef struct
{
	int a;
	int b;
}Sum_DataType;

int Sum(const Sum_DataType *p);
int main(void)
{
	/*常量指针定义方式：
	**比如一个int 类型的指针是这样定义的  int *p;
	**那么int 类型的常量指针需这样定义：const int *p;或者int const *p;
	*/
	int a=4,b=5;
	const int *p=&a;
	Sum_DataType m={10,4};
	
	Sum_DataType *Sum_point=&m;
	m.b=6;
	//Sum_point->b=7;   /*编译报错*/
	
	
	printf("m.b=%d\n",m.b);	
	//printf("常指针*p指向a后 *p= %d\n",*p);
	//p=&b;
	
	//printf("常指针*p指向b后 *p= %d\n",*p);
	/*我们试图去改变a的值,看是否会报错误*/
	//a=6;
	//*p=6;/*通过常量指针更改a的值，报错*/
	
	//printf("a=%d\n",a);		
    printf("a+b=%d\n",Sum(Sum_point));
	//m->a=3;
	//printf("a=%d\n",a);
	//printf("b=%d\n",b);
	return 0;		
}
int Sum(const Sum_DataType *p)
{
	//p->a = 2;/*编译报错*/
	//p->b = 4;/*编译报错*/
	return p->a+p->b;
}

指针常量

本质是一个常量，只是常量的类型是指针，该指针一经赋值，就不能改变。

对指针常量进行赋值，编译报错

int main(void)
{
	/*指针常量定义方式：
	**比如一个int 类型的指针是这样定义的  int *p;
	**那么int 类型的常量指针需这样定义： int *const p;
	*/
	int a=4,b=5;
	int *const p=&a;
	p=&b;    /*对指针常量进行赋值*/
	printf("a=\n",a);	
	printf("b=\n",b);
	
	return 0;		
}