C语言指针进阶（1）的代码笔记（初始版）

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

//指针数组（本质是数组） -- 一种存放指针的数组
//数组指针（本质是指针） -- 一种指向数组的指针 - 存放的是数组的地址

//int main()
//{
//	//指针数组
//	int* arr[10];
//	//数组指针
//	int arr[5];
//	int(*p)[5] = &arr;
//
//	return 0;
//}


//int arr[10];
// arr 和 &arr 有什么区别？


//数组名大部分情况下是数组首元素的地址
//但有2个例外：
//1.sizeof(数组名) - sizeof内部放一个数组名的时候，数组名表示整个数组，计算得到的是数组的总大小
//2.&arr - 这里的数组名是指整个数组，取出的是整个数组的地址，从地址的角度来讲和数组首元素的地址是一样的，但意义不同



//int main()
//{
//	int arr[10] = { 0 };
//	printf("%d\n", sizeof(arr));// 40
//	printf("%p\n", arr);// int*
//	printf("%p\n", arr+1);// 4
//
//	printf("%p\n", &arr[0]);// int*
//	printf("%p\n", &arr[0]+1);// 4
//
//	printf("%p\n", &arr);// int(*)[10]
//	printf("%p\n", &arr+1);
//	int(*p)[10] = &arr;// p是一个数组指针
//	//int (*)[10]
//
//	return 0;
//}


//int main()
//{
//	int i = 0;
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	
//	int(*p)[10] = &arr;
//	// p --- &arr
//	// *p --- *&arr
//	// *p --- arr
//	虽然对，但不推荐
//	//for (i = 0; i < sz; i++)
//	//{
//	//	printf("%d ", *((*p) + i));
//	//}
//
//	虽然对，但不推荐
//	//for (i = 0; i < 10; i++)
//	//{
//	//	printf("%d ", (*p)[i]);
//	//}
//
//	使用指针来访问
//	// int* p = arr;
//	//for (i = 0; i < sz; i++)
//	//{
//	//	printf("%d ", *(p + i));
//	//}
//
//	//下标的形式访问数组
//	/*for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}*/
//	return 0;
//}


//一维数组传参，形参是数组
//void print(int arr[], int sz)
//{
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	printf("\n");
//}

一维数组传参，形参是指针
//void print(int *arr, int sz)
//{
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		/*printf("%d ", arr[i]);*/
//		printf("%d ", *(arr + i));
//	}
//	printf("\n");
//}
//
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	print(arr, sz);
//	
//	return 0;
//}

//二维数组传参，参数是数组 // 有点问题  // 问题解决
//void print(int arr[3][5], int r, int c)
//{
//	int i = 0;
//	for (i = 0; i < r; i++)
//	{
//		int j = 0;
//		for (j = 0; j < c; j++)
//		{
//			printf("%d ", arr[i][j]);
//		}
//		printf("\n");
//	}
//}

二维数组传参，参数是指针 
//void print( int (*arr)[5], int r, int c) //    有点问题 // 问题解决
//{
//	int i = 0;
//	for (i = 0; i < r; i++)
//	{
//		int j = 0;
//		for (j = 0; j < c; j++)
//		{
//			/*printf("%d ", arr[i][j]);*/
//			printf("%d ", *(*(arr + i) + j));
//		}
//		printf("\n");
//	}
//}
//
//int main()
//{
//	int arr[3][5] = { 1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7 };
//	//二维数组的数组名，也表示首元素的地址
//	//二维数组的首元素是第一行
//	//首元素的地址就是第一行的地址，是一个一维数组的地址
//	print(arr, 3, 5);
//	return 0;
//}

//int Add(int x, int y)
//{
//	return x + y;
//}

&函数名得到的是函数的地址
Add 和 &Add 表示的含义是一样的
//int main()
//{/*
//	printf("%p\n", Add);
//	printf("%p\n", &Add);*/
//	int (* pt)(int , int) = Add;// 函数的地址要存起来，就得放在【函数指针变量】中
//
//	/*int ret = (*pt)(3, 5);*/  //使用指针访问函数
//	/*int ret = Add(3, 5);*/
//	int ret = pt(3, 5);    //使用指针访问函数
//	printf("%d\n", ret);
//	return 0;
//}

//char* test(int c, float* pf)
//{
//	return 0;
//}
//
//int main()
//{
//	char* (*pt)(int, float*) = test; 
//
//	return 0;
//}

//
//typedef int* ptr_t;
//typedef void(*pf_t)(int); //将void(*)(int)类型重新起个别名叫pf_t
//
//
//typedef void(*pf_t2)(int); //pf_t2是类型名
//void(*pf)(int); //pf是函数指针变量的名字

两段有趣的代码
代码1
//int main()
//{	//void (*)() 第一部分，一个没有参数和返回类型为void的函数指针
//	//(第一部分) 0 第二部分，把 0 强制类型转化为函数指针
//	//第三部分，调用0地址处的函数
//
//	//下面代码是一次函数调用
//	(*(void (*)()) 0)();
//
//
//	//代码2
//	void (*signal(int, void(*)(int)) )(int);
//	//上述的代码是一个函数的声名
//	// 函数的名字是signal
//	// signal函数的第一个参数为int类型，第二个是void(*)(int)类型的函数指针
//	//第一部分，void(*)(int) 为一个参数为int，返回类型为viod的函数指针
//	//第二部分，signal函数的返回类型也是一个函数指针，该函数指针指向的函数参数是int，返回类型是void
//	// 
//	// 
//	//	//void (* signal(int, void(*)(int)))(int)
//	return 0;
//}


//
//函数指针数组
//数组的每一个元素都是函数指针
//这里要求函数指针数组中的每一个函数指针的参数和返回类型一致

//int Add(int x, int y)
//{
//	return x + y;
//}
//
//int Sub(int x, int y)
//{
//	return x - y;
//}
//
//int Mul(int x, int y)
//{
//	return x * y;
//}
//
//int Div(int x, int y)
//{
//	return x / y;
//}

//int main()
//{
//	//存放函数指针的数组 -- 函数指针数组
//	int (*pf[4])(int, int) = { Add, Sub, Mul, Div };// 这个就是一个函数指针数组
//	int i = 0;
//	for (i = 0; i < 4; i++)
//	{
//		int ret = pf[i](8, 4);
//		printf("%d ", ret);// 12 4 24 2
//	}
//	return 0;
//}


int Add(int x, int y)
{
	return x + y;
}

int Sub(int x, int y)
{
	return x - y;
}

int Mul(int x, int y)
{
	return x * y;
}

int Div(int x, int y)
{
	return x / y;
}

写一个计算器能完成整数的 + - * /
增加: << >> & | ^ && || 
 计算器的普通版本 (利用普通的switch case来实现计算器)
//void menu()
//{
//	printf("******************************\n");
//	printf("******1. Add    2. Sub  ******\n");
//	printf("******3. Mul    4. Div  ******\n");
//	printf("******     0. exit  **********\n");
//	printf("******************************\n");
//}
//
//int main()
//{
//	int input = 0;
//	int x = 0;
//	int y = 0;
//	int ret = 0;
//	do
//	{
//		menu();
//		printf("请输入:>\n");
//		scanf("%d", &input);
//		
//		switch (input)
//		{
//		case 1:
//			 printf("请输入两个操作数:>\n");
//			 scanf("%d %d", &x, &y);
//			 ret = Add(x, y);
//			 printf("%d\n", ret);
//			 break;
//		case 2:
//			printf("请输入两个操作数:>\n");
//			scanf("%d %d", &x, &y);
//			ret = Sub(x, y);
//			printf("%d\n", ret);
//			break;
//		case 3:
//			printf("请输入两个操作数:>\n");
//			scanf("%d %d", &x, &y);
//			ret = Mul(x, y);
//			printf("%d\n", ret);
//			break;
//		case 4:
//			printf("请输入两个操作数:>\n");
//			scanf("%d %d", &x, &y);
//			ret = Div(x, y);
//			printf("%d\n", ret);
//			break;
//		case 0:
//			printf("退出计算器\n");
//			break;
//		default:
//			printf("选择错误\n");
//			break;
//		}
//
//
//	} while (input);
//	return 0;
//}

//计算器升级版(省去了switch case语句，让代码没有那么臃肿)
//void menu()
//{
//	printf("******************************\n");
//	printf("******1. Add    2. Sub  ******\n");
//	printf("******3. Mul    4. Div  ******\n");
//	printf("******     0. exit  **********\n");
//	printf("******************************\n");
//}
//
//int main()
//{
//	int input = 0;
//	int x = 0;
//	int y = 0;
//	int ret = 0;
//	                           // NULL可以用数字0 1 2 3代替，主要起一个占位的作用，但用NULL是最合适的
//	int (*pfArr[5])(int, int) = { NULL, Add, Sub, Mul, Div };
//	          
//                                // 0    1    2    3    4  下标
//	//这种形式的运用也叫 转移表 - 函数指针的数组
//	do
//	{
//		menu();
//		printf("请输入:>\n");
//		scanf("%d", &input);
//		if (input == 0)
//		{
//			printf("退出计算器\n");
//			break;
//		}
//		else if (input >= 1 && input <= 4)
//		{
//			printf("请输入两个操作数:>\n");
//			scanf("%d %d", &x, &y);
//			ret = pfArr[input](x, y);
//			printf("%d\n", ret);
//		}
//		else
//		{
//			printf("选择错误\n");
//		}
//		
//
//	} while (input);
//	return 0;
//}

这些笔记日后会完善