demo_3_2

#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
//int main()
//{
// int *p = NULL;//p 是整型指针 - 指向整型的指针 - 可以存放整型的地址
// char* pc = NULL;//pc 是字符指针 - 指向字符型的指针 - 可以存放字符的地址
// //数组指针 - 指向数组的指针 - 存放数组的地址
// //int arr[10] = { 0 };
// //arr - 首元素地址
// //&arr[0] - 首元素的地址
// //&arr - 数组的地址
// int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// //数组的地址要存起来
// //整型指针不能存放一个数组地址
// int (*p)[10] = &arr;//数组的地址要存起来
// //p - 是一个数组指针
// system("pause");
// return 0;
//}

//int main()
//{
// char* arr[5];
// char* (*pa)[5] = &arr;
// int arr2[10] = { 0 };
// int (*pa2)[10] = &arr2;
// return 0;
//}

//int main()
//{
// int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// //int (*pa)[10] = &arr;
// int *p = arr;
//
// int i = 0;
// for (i = 0; i < 10; i++)
// {
// printf("%d ", *(p + i));
// }
// /*for (i = 0; i < 10; i++)
// {
// printf("%d ", (*pa)[i]);
// }*/
//
// //for (i = 0; i < 10; i++)
// //{
// // printf("%d ", *pa+i);//*pa == arr
// //}
//
//
// system("pause");
// return 0;
//}

//参数是数组的形式
void print1(int arr[3][5], int x, int y)
{
int i = 0;
int j = 0;
for (i = 0; i < x; i++)
{
for (j = 0; j < y; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
//参数是指针的形式
void print2(int(*p)[5], int x, int y)
{
int i = 0;
for (i = 0; i < x; i++)
{
int j = 0;
for (j = 0; j < y; j++)
{
printf("%d ",*(*(p + i) + j));
printf("%d ", (*(p + i))[j]);
printf("%d ", p[i][j]);
printf("%d ", *(p[i]+j));
//以上四种都相等
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { { 1, 2, 3, 4, 5 }, { 2, 3, 4, 5, 6 }, { 4, 5, 6, 7, 8 } };
print1(arr,3,5);//把数组 行 列都传过去
print2(arr, 3, 5);

int arr1[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int i = 0;
int* p = arr1;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
printf("%d ", *(arr1 + i));
printf("%d ", arr1[i]);//arr == *(arr+i) = *(p+i) = p[i]

}
system("pause");
return 0;
}

int main()
{
//字符指针
char ch = 'w';
char* p = &ch;//指针里面存放字符地址
const char *p2 = "abcdef";//p2是一个指针变量

//指针数组 - 数组 - 存放指针的数组
int* arr[10];
char* ch[5];

//数组指针 - 指向数组的指针
int *p3;//整型指针 - 指向整型的指针
char* p4;//字符指针 - 指向字符的指针
int arr2[5];
int (*pa[5]) = &arr2; //取出的数组地址，pa是一个数组指针


system("pause");
return 0;
}

void test(int arr[3][5])
{

}
void test1(int arr[][5])
{

}
void test2(int arr[3][])//err - 不能省略列
{

}
void test3(int* arr)//err
{

}
void test(int arr[][])//err - 行可以省略，列不饿能省略
{

}
void test4(int **arr)//err - 数组指针不能存放二级指针
{

}
void test5(int (*arr)[5])
{

}
int main()
{
int arr[3][5] = { 0 };
test(arr);//二维数组传参
test1(arr);
test2(arr);
test3(arr);
test4(arr);
test5(arr);
system("pause");
return 0;
}

void test1(int* p)
{

}
void test2(char* p)
{

}
int main()
{
int a = 10;
int* p1 = &a;
test1(&a);//ok
test1(p1);//ok
char ch = 'w';
char* pc = &ch;
test2(&ch);//ok
test2(pc);//ok
return 0;
}

void test(int **p)
{

}
int main()
{
int *ptr;
test(&ptr);//ok - 地址本身
int** pp = &ptr;
test(pp);//ok - 传指针
int* arr[10];
test(arr);//ok - 指针数组传参也可以
return 0;
}

int Add(int x, int y)
{
int z = 0;
z = x + y;
return z;
}
int main()
{
int a = 10;
int b = 20;
int arr[10] = { 0 };
//&arr - 取地址

printf("%d\n", Add(a, b));
printf("%p\n", &Add);//Add函数的地址 - 00af10E1
printf("%p\n", Add);
int (*pa)(int ,int) = Add;//函数指针和数组指针一样写法
//int (*pa)(int x,int y) = Add;
printf("%d\n",(*pa)(2, 3));
return 0;
}

void Print(char* str)
{
printf("%s\n", str);
}
int main()
{
void (*p)(char* ) = Print;//把函数指针存起来
(*p)("hello bit");//调用函数指针
return 0;
}

int Add(int x, int y)
{
int z = 0;
z = x + y;
return z;
}
int main()
{
int a = 10;
int b = 20;
int(*pa)(int,int) = Add;
printf("%d\n", (pa)(2, 3));
printf("%d\n", (*pa)(2, 3));
printf("%d\n", Add(2, 3));
printf("%d\n", (*pa)(2, 3));
}

//指针数组
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* arr[5];
//需要一个数组，这个数组可以存放4个函数的地址 - 函数指针的数组
int(*pa)(int, int) = Add;
int(*parr[4])(int, int) = {Add,Sub,Mul,Div};//函数指针的数组
int i = 0;
for (i = 0; i < 4; i++)
{
printf("%d\n",parr[i](2, 3));
}
return 0;
}

//练习：my_strcpy(char* dest, const char* src);
//1.写一个函数指针pf，能够指向my_strcpy()
//char* (*pf)(char*, const char*);
//2.写一个函数指针数组pfArr，能够存放4个my_strcpy()的函数地址
//char* (*pfArr)(char*, const char*);

//计算器
void menu()
{
printf("***********************************\n");
printf("**------1.add---------2.sub------**\n");
printf("**------3.mul---------4.div------**\n");
printf("**------5.xor---------0.exit-----**\n");
printf("***********************************\n");
}
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 Xor(int x, int y)
{
return x ^ y;
}

int main()
{
int input = 0;
int x = 0;
int y = 0;
do{
menu();
printf("请选择:>");
scanf("%d", &input);
switch (input)
{
case 1:
printf("请输入两个操作数:>");
printf("%d%d", &x, &y);
printf("%d\n",Add(x,y));
break;
case 2:
printf("请输入两个操作数:>");
printf("%d%d", &x, &y);
printf("%d\n", Sub(x,y));
break;
case 3:
printf("请输入两个操作数:>");
printf("%d%d", &x, &y);
printf("%d\n", Mul(x,y));
break;
case 4:
printf("请输入两个操作数:>");
printf("%d%d", &x, &y);
printf("%d\n", Div(x,y));
break;
case 0:
printf("退出\n");
break;
default:
printf("选择错误\n");
break;
}
} while (input);
return 0;
}

Calc(int (*pf)(int,int))
{
int x = 0;
int y = 0;
printf("请输入两个操作数:>");
printf("%d%d", &x, &y);
printf("%d\n", pf(x, y));
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
do{
menu();
printf("请选择:>");
scanf("%d", &input);
switch (input)
{
case 1:
Calc(Add);
break;
case 2:
Calc(Sub);
break;
case 3:
Calc(Mul);
break;
case 4:
Calc(Div);
break;
case 0:
printf("退出\n");
break;
default:
printf("选择错误\n");
break;
}
} while (input);
return 0;
}

//优化计算机
int main()
{
int input = 0;
int x = 0;
int y = 0;
int (*pfArr[5])(int, int) = {0,Add,Sub,Mul,Div,Xor};
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
if (input >= 1 && input <= 5)
{
printf("请输入两个操作数:>");
scanf("%d%d", &x, &y);
int ret = pfArr[input](x, y);
printf("%d\n", ret);
}
else if (input == 0)
{
printf("退出\n");
}
else{
printf("选择错误\n");
}
} while (input);
return 0;
}

int Add(int x, int y)
{
return x + y;
}
int main()
{
int arr[10] = { 0 };
int (*p)[10] = &arr;//取出数组的地址
int(*pf)(int, int);//函数指针
int(*pfArr[4])(int, int);//pfArr是一个数组 - 函数指针的数组
//ppfArr是一个指向[函数指针数组]的指针
int (*(*ppfArr)[4]) = &pfArr;
//ppfArr是一个数组指针，指针指向的数组有4个元素，
//指向的数组的每个元素的类型是一个函数指针 int(*)(int ,int)
return 0;
}

void print(char *str)
{
printf("hehe:%s\n", str);
}
void test(void (*p)(char*))
{
printf("test\n");
p("bit");
}
int main()
{
test(print);
return 0;
}

//这种只能排序用户自己定义的类型 - 整型
void BubbleSort(int arr[], int sz)
{

}
int main()
{
//冒泡排序函数
//冒泡排序函数只能排序整型数组
int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
int sz = sizeof(arr) / sizeof(arr[0]);
BubbleSort(arr, sz);
return 0;
}

//qsort - 可以排序任意类型的数据
int main()
{

return 0;
}