【c语言】学习笔记（六）：什么是指向指向常量的常量指针的指针？

1. void指针 和 NULL指针
   void指针 ： 又叫通用指针，可以指向任何类型；

#include <stdio.h>

int main()
{
        int num = 1024;
        
        int *a = &num;
        char *c = "tuck";
        
		void *b;		//可以指向任何类型 
		
		b = a; 
		printf("a = %p , b = %p\n" , a , b);
		printf("*b = %d\n" , *( int * )b);    	//将void指针强制转换成int类型 
		
		b = c;
		printf("c = %p , b = %p\n" , c , b);
        
        return 0;
}

a = 000000000062FE04 , b = 000000000062FE04
*b = 1024
c = 0000000000404000 , b = 0000000000404000

--------------------------------
Process exited after 0.02425 seconds with return value 0
请按任意键继续. . .

NULL指针：不指向任何类型
NULL指针有什么作用呢？事实上，当你不知道指针要初始化为什么地址时，可以先初始化为NULL指针，在对指针进行解引用时，先检查指针是否为NULL指针。

2. const关键字修饰

const int number = 520; 		//用const 修饰的变量，变成了只读变量 

（1）指向常量的指针：顾名思义就是一个指针，但这个指针指向的是一个常量。

#include <stdio.h>



int main()
{		
		const int a = 520; 		//a 变为了只读属性的变量 
		const int *p = &a; 		//定义了一个指向常量的指针 
		
		printf("*p = %d , p = %p\n" , *p , p);
		
		//*p = 2; 		//尝试修改指针指向的值，编译报错 ,也就是说不允许修改所指向的那个常量 
		
		const int b = 2;
		
		p = &b; 		//但是，指针本身是可以修改的。 
		
		printf("指针被修改后解引用：*p = %d\n" , *p);
		
		

        return 0;
}

*p = 520 , p = 000000000062FE14
指针被修改后解引用：*p = 2

--------------------------------
Process exited after 0.1314 seconds with return value 0
请按任意键继续. . .

（2）指向非常量的常量指针：顾名思义就是一个常量，只不过这个常量是一个指针，这意味着指针本身不能被修改，但它指向的那个变量（非常量）是可以修改的。还是上代码理解一下：

#include <stdio.h>



int main()
{		
		char a = 'A';
		
		char * const p = &a ;  		//因为是常量，所以必须在定义时就进行初始化，否则会报错 
		
		printf(" p = %p , *P = %c\n" , p , *p);
		
		char b = 'B';
		
		//p = &b; 		//尝试修改p , 编译报错 
		
		*p = 'B'; 		//但是，p指向的值（非常量）是可以被修改的 
		
		printf("修改p指针指向的值后：*p = %c\n" , *p);
		
		
		
		

        return 0;
}

 p = 000000000062FE16 , *P = A
修改p指针指向的值后：*p = B

--------------------------------
Process exited after 0.04379 seconds with return value 0
请按任意键继续. . .

（3）指向常量的常量指针
没错啦！如果上面那个理解了，这一个就是在上面的基础上，限定指向的也是一个常量。这样一来不但指针本身不能被修改，指针所指向的值也不能被修改。

const char a = 'A';
const char * const p = &a ;

（4）指向 指向常量的常量指针 的指针
对于初学者来说 ， 看到小标题有可能就有点懵， 但其实本质都是相同的，只不过在定义这个指针 的时候一定要理解清楚它的意义，先看看下面这段代码自己理解理解哈哈：

#include <stdio.h>

int main()
{		
		const char a = 'A';
		
		const char * const p = &a ;  		//因为指针是常量，所以必须在定义时就进行初始化，否则会报错 
		
		const char * const *t = &p;  		//想一想，两个const的位置为什么是这样呢？
		
		printf("p = %p , *P = %c\n" , p , *p);
		
		printf("t = %p , *t = %p , **t = %c\n" , t , *t , **t); 	//*t是一个地址，所以用%p打印
		
        return 0;
}

打印结果

p = 000000000062FE17 , *P = A
t = 000000000062FE08 , *t = 000000000062FE17 , **t = A

--------------------------------
Process exited after 0.155 seconds with return value 0
请按任意键继续. . .

好啦！现在就来看看这一个语句const char * const *t = &p;
其实我们只要记住，你要让谁变成常量属性就在谁的前面加 const，语句中char就是a这个常量的值的类型，const char就是把这个值变成常量属性，而*t则是t中存放的值也就是a的地址（即p），p是一个常量指针，故const *t。

如果上面的内容都理解了，那么你就可以疯狂套娃啦！

3. 函数中的可变参数
   大家一定都非常熟悉我们的printf 函数，毕竟我们的第一个Hello World 程序就用到了它，其实printf函数就是一个可以传入可变个参数的函数，那么我们自己如何实现可变参数呢？
   首先，要实现可变参数，得先引入一个头文件<stdarg.h> ,我们需要用到里面的四样东西：分别是一个类型va_list和三个宏va_start , va_arg , va_end;具体用法来看看下面的代码就知道啦！

#include <stdio.h>
#include <stdarg.h>

int sum(int n , ...);

int sum(int n , ...) 	//3个点代表了我们传入的多个参数（参数数量不确定，是可变的） 
{
		int i , sum = 0;
		
		va_list vap; 	//定义参数列表 
		
		va_start(vap , n); 		//初始化参数列表 
		for (i = 0 ; i < n ; i++)
		{
				sum += va_arg(vap , int);  		//获取参数的值 
		}
		va_end(vap); 		//关闭参数列表 
		
		return sum;
}

int main()
{		
		int result;
		
		result = sum(5 , 1 , 2 , 3 , 4 , 5);
		printf("result = %d\n" , result);
		

        return 0;
}

result = 15

--------------------------------
Process exited after 0.2112 seconds with return value 0
请按任意键继续. . .