int* p;
char*
int main()
{
const char* pstr = "hello bit.";
printf("%s\n", pstr);
return 0;
}
hello bit.
首字符的地址放到了pstr中。*pstr="w"
;来修改首字符,因为常量字符串是无法修改的,所以要加上const
#include
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
const char *str3 = "hello bit.";
const char *str4 = "hello bit.";
if(str1 ==str2)
printf("str1 and str2 are same\n");
else
printf("str1 and str2 are not same\n");
if(str3 ==str4)
printf("str3 and str4 are same\n");
else
printf("str3 and str4 are not same\n");
return 0;
}
int main()
{
int arr1[5] = { 1,2,3,4,5 };
int arr2[5] = { 2,3,4,5,6 };
int arr3[5] = { 3,4,5,6,7 };
int* parr[3] = { arr1, arr2, arr3 };
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
//printf("%d ", parr[i][j]);
printf("%d ", *(parr[i]+j));
}
printf("\n");
}
return 0;
}
int main()
{
int arr1[5] = { 1,2,3,4,5 };
int arr2[5] = { 2,3,4,5,6 };
int arr3[5] = { 3,4,5,6,7 };
int* parr[3] = { arr1,arr2, arr2 };
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j< 5; j++)
{
//printf("%d ", parr[i][j]);//类似模拟出一个二维数组
printf("%d ",*(parr[i]+j));//这两个写法都可以
}
printf("\n");
}
return 0;
}
arr[i] = *(arr+i)
int * p1[10];
int (*p)[10];
–>数组指针:指向数组的指针int main()
{
int a = 10;
int* p = &a;
int arr[10] = {0};
//数组是首元素的地址
printf("%p\n", arr);//int*
printf("%p\n", arr+1);
printf("%p\n", &arr[0]);//int*
printf("%p\n", &arr[0]+1);
printf("%p\n", &arr);//int(*)[10]数组指针类型
printf("%p\n", &arr+1);
return 0;
}
[[章6 数组与函数#其他]]中第四点也有提及一下这点。
//形参写出数组
//void print1(int arr[], int sz)
//{
// int i = 0;
// for (i = 0; i < sz; i++)
// {
// printf("%d ", arr[i]);
// }
// printf("\n");
//}
//形参写成指针的形式
void print1(int* arr, int sz)//arr[]传入的是首元素的地址,即等价于*arr
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(arr + i));
}
printf("\n");
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//写一个函数打印arr数组的内容
int sz = sizeof(arr) / sizeof(arr[0]);
print1(arr, sz);
return 0;
}
void print1(int (*p)[10], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
//p 是整个个数组的地址
//*p 相当于拿到数组名,数组名又是首元素的地址,所以*p就是&arr[0]
//(*p + i)表数组中下标为i的元素的地址
//为了拿出该地址的元素内容,还要再解引用一次,故*(*p + i)
printf("%d ", *(*p + i));
}
printf("\n");
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//写一个函数打印arr数组的内容
int sz = sizeof(arr) / sizeof(arr[0]);
//
print1(&arr, sz);
return 0;
}
//①写成数组的形式
//void print2(int arr[3][5], int c, int r)
//{
// int i = 0;
// for (i = 0; i < c; i++)
// {
// int j = 0;
// for (j = 0; j < r; j++)
// {
// printf("%d ", arr[i][j]);
// }
// printf("\n");
// }
//}
//②写成指针的形式
void print2(int(*p)[5], int c, int r)
{
int i = 0;
for (i = 0; i < c; i++)
{
int j = 0;
for (j = 0; j < r; j++)
{
//p+i是指向第i行的
//*(p+i)相当于拿到了第i行,也相当于第i行的数组名
//数组名表示首元素的地址,*(p+i) 就是第i行第一个元素的地址
printf("%d ", *(*(p + i) + j));
//printf("%d ", p[i][j]);
}
//arr[i]
//*(arr+i)
//
//arr[i][j]
//*(arr+i)[j]
//*(*(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} };
//int (*ptr)[3][5] = &arr;
//写一个函数,打印arr数组
print2(arr, 3, 5);//三行五列,arr二维数组传入相当于降维了
return 0;
}
int arr[5];
int* parr1[10];
int(*parr2)[10] ;
int(*parr3[10])[5];
#include
void test(int arr[])//ok
{}
void test(int arr[10])//ok
{}
void test(int *arr)//ok
{}
void test2(int *arr[20])//ok
{}
void test2(int **arr)//ok
{}
int main()
{
int arr[10] = {0};
int *arr2[20] = {0};
test(arr);
test2(arr2);
}
void test(int arr[3][5])//ok
{}
void test(int arr[][5])//可以省略行,不能省略列
{}
//总结:二维数组传参,函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组,可以不知道有多少行,但是必须知道一行多少元素。
//这样才方便运算。
void test(int (*arr)[5])//ok
{}
void test(int **arr)//ok
{}
int main()
{
int arr[3][5] = {0};
test(arr);
}
#include
void print(int *p, int sz)
{
int i = 0;
for(i=0; i
#include
void test(int** ptr)
{
printf("num = %d\n", **ptr);
}
int main()
{
int n = 10;
int*p = &n;
int **pp = &p;
test(pp);
test(&p);
return 0;
}
#include
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}
int test(char* str)
{
……
}
int main(){
//函数指针变量如下
int(*pt)(char*)=test;
}
#include
int Add(int x, int y)
{
return x + y;
}
int main()
{
int arr[10];
//arr
//&arr
int (*p)[10] = &arr;//p是一个数组指针变量
printf("%p\n", &Add);
printf("%p\n", Add);
int (* pf)(int, int) = Add;//就是函数指针变量
//去掉变量名 int (* )(int, int)就是函数指针类型
// 0x0012ff40
int ret = (*pf)(2,3);//(*pf)找到函数、调用函数
//int ret = pf(2, 3);//此处*不管多少个、有没有,都没影响,但有*就要加括号内
printf("%d\n", ret);
return 0;
}
( *( void (*)() )0 )();
int main()
{
//代码1
( *( void (*)() )0 )();
//void (*)() 是函数指针类型
//void (*p)()
//( void (*)() ) 强制类型转换
//(类型)
//( void (*)() )0 对0进行强制类型的转换
}
void (* signal(int, void(*)(int)) )(int);
int main()
{
//类比别的函数声明
//int Add(int, int);
//代码2
void (* signal(int, void(*)(int)) )(int);//函数声明
//signal是一个函数的声明
//signal函数的参数,第一个是int类型的,第二个是void(*)(int)的函数指针类型
//signal函数的返回值类型也是:void(*)(int)的函数指针
//void(*)(int) signal(int, void(*)(int));//err,但含义可这样理解
//简化上面函数声明的写法如下
//typedef void(* pf_t)(int) ;//给函数指针类型void(*)(int)重新起名叫:pf_t
//pf_t signal(int, pf_t);
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()
{
//指针数组
//字符指针数组
char* arr[5];
//整形指针数组
int* arr2[4];
//int (*pf1)(int, int) = Add;
//int (*pf2)(int, int) = Sub;
//int (*pf3)(int, int) = Mul;
//int (*pf4)(int, int) = Div;
//函数指针数组
int (* pf[4])(int, int) = { Add, Sub, Mul, Div };
int i = 0;
for (i = 0; i < 4; i++)
{
int ret = pf[i](8, 2);
printf("%d\n", ret);
}
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;
}
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("请选择:>");
scanf("%d", &input);
switch (input)
{
case 1:
printf("请输入2个操作数:>");
scanf("%d%d", &x, &y);
ret = Add(x, y);
printf("ret = %d\n", ret);
break;
case 2:
printf("请输入2个操作数:>");
scanf("%d%d", &x, &y);
ret = Sub(x, y);
printf("ret = %d\n", ret);
break;
case 3:
printf("请输入2个操作数:>");
scanf("%d%d", &x, &y);
ret = Mul(x, y);
printf("ret = %d\n", ret);
break;
case 4:
printf("请输入2个操作数:>");
scanf("%d%d", &x, &y);
ret = Div(x, y);
printf("ret = %d\n", ret);
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 ret = 0;
//转移表(对于此处函数指针称谓,起一个跳转效果)
int (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };
do{
menu();
printf("请选择:>");
scanf("%d", &input);
if (input == 0)
{
printf("退出计算器\n");
}
else if (input >= 1 && input <= 4)
{
printf("请输入2个操作数:>");
scanf("%d%d", &x, &y);
ret = pfArr[input](x, y);
printf("ret = %d\n", ret);
}
else
{
printf("选择错误\n");
}
} while (input);
return 0;
}
int main()
{
//函数指针数组
int (*pfarr[4])(int, int) = {Add,Sub,Mul,Div};
int (*(* p3)[4])(int, int) = &pfarr;
//p3是一个指向函数指针数组的指针
int i = 0;
for (i = 0; i < 4; i++)
{
//①*p
//②*(p3+0)
//③p3[0]
//这三个可以等价代替
//int ret = (*p3)[i](3,4);
int ret = p3[0][i](3, 4);
printf("%d\n", ret);
}
return 0;
}
int (*(* p3)[4])(int, int)
为什么不能是写成(int*)(*p3)[4](int,int)
呢?
*p3 --> pfarr
(*p3)[i]--->pfarr[i]
void test()
{
printf("hehe\n");
}
void print_hehe(void (*p)()) //把test函数地址传递给该函数中所提供的接收指针
{
if (1)
p();//通过print_hehe来调用test函数
}
int main()
{
print_hehe(test);
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;
}
void menu()
{
printf("**************************\n");
printf("**** 1.add 2.sub ****\n");
printf("**** 3.mul 4.div ****\n");
printf("**** 0.exit ****\n");
printf("**************************\n");
}
void calc(int (*pf)(int,int))
{
int x = 0;
int y = 0;
int ret = 0;
printf("请输入2个操作数:>");
scanf("%d%d", &x, &y);
ret = pf(x, y);
printf("ret = %d\n", ret);
}
int main()
{
int input = 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;
}
void qsort( void *base, //待排序数据的起始位置,且void能接受任意类型
size_t num, //数组的元素个数
size_t width, //一个元素的字节大小-->方便找下一个元素位置
int (*cmp)(const void *e1, const void *e2 ) //函数指针
// 比较函数 待比较的两个元素的地址
);
要求qsort函数的使用者,自定义一个比较函数
// void bubble_sort(int arr[], int sz)
//自写的冒泡排序,但只能规定比较一种类型(如本题是整型)
//{
// int i = 0;
// for (i = 0; i < sz - 1; i++)
// {
// int j = 0;
// for (j = 0; j < sz-1-i; j++)
// {
// if (arr[j] > arr[j + 1])
// {
// int tmp = arr[j];
// arr[j] = arr[j + 1];
// arr[j + 1] = tmp;
// }
// }
// }
//}
void print_arr(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
//void test1()
//{
// int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
// //排序为升序
// int sz = sizeof(arr) / sizeof(arr[0]);
// bubble_sort(arr, sz);
// print_arr(arr, sz);
//}
int main()
{
test1();
//int a = 10;
//float* pf = &a;//int*
//void* pf = &a;
//pf + 1;//err
//*pf;//err
return 0;
}
int cmp_int(const void* e1, const void* e2)
{
/*if (*(int*)e1 > *(int*)e2) //这样写法太复杂了
return 1;
else if (*(int*)e1 == *(int*)e2)
return 0;
else
return -1;*/
return (*(int*)e1 - *(int*)e2);
//正常逻辑e1>e2返回大于0就是升序,把e2和e1的位置交换,逻辑相反就是降序(如下)
//return (*(int*)e2 - *(int*)e1);
}
void test2()
{
int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
//排序为升序
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_int);
print_arr(arr, sz);
}
int main()
{
test2();
return 0;
}
struct Stu
{
char name[20];
int age;
double score;
};
int cmp_stu_by_age(const void* e1, const void* e2)
{
return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
//使用qsort排序结构体
void test3()
{
struct Stu arr[3] = { {"zhangsan", 20, 55.5},{"lisi", 30, 88.0},{"wangwu", 10, 90.0} };
int sz = sizeof(arr) / sizeof(arr[0]);
//qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
test3();
return 0;
}
void Swap(char* buf1, char* buf2, int width)
{
int i = 0;
for (i = 0; i < width; i++)
{
char tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
void bubble_sort(void* base, int num, int width, int (*cmp)(const void* e1, const void* e2))
{
int i = 0;
for (i = 0; i < num - 1; i++)
{
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
//if (arr[j] > arr[j + 1])//比较
if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
{
//交换
Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
}
}
}
}
void test4()
{
int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
//排序为升序
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
print_arr(arr, sz);
}
int main()
{
test4();
return 0;
}
int main()
{
int a[] = { 1,2,3,4 };
// 0 1 2 3
int (*p)[4] = &a;
printf("%d\n", sizeof(a));//4*4 = 16
printf("%d\n", sizeof(a + 0));
//4/8 a+0是数组第一个元素的地址,是地址,大小就是4/8个字节
printf("%d\n", sizeof(*a));
//4 a表示数组首元素的地址,*a表示数组的第一个元素,sizeof(*a)就是第一个元素的大小-4
printf("%d\n", sizeof(a + 1));
//4/8 a表示数组首元素的地址,a+1数组第二个元素的地址,sizeof(a+1)就是第二个元素的地址的大小
printf("%d\n", sizeof(a[1]));
//4 计算的是第二个元素的大小
printf("%d\n", sizeof(&a));
//4/8 &a取出的是数组的地址,数组的地址也是地址呀,是地址大小就是4/8字节
printf("%d\n", sizeof(*&a));
//16 计算的整个数组的大小
printf("%d\n", sizeof(&a + 1));
//4/8 - &a是数组的地址,+1跳过整个数组,产生的4后边位置的地址
printf("%d\n", sizeof(&a[0]));
//4/8 取出的数组第一个元素的地址
printf("%d\n", sizeof(&a[0] + 1));
//4/8 数组第二个元素的地址
return 0;
}
int main()
{
char arr[] = { 'a','b','c','d','e','f' };
//[a b c d e f]
printf("%d\n", strlen(arr));
//随机值,arr数组中没有\0,所以strlen函数会继续往后找\0,统计\0之前出现的字符个数
printf("%d\n", strlen(arr + 0));
//随机值,arr+0还是数组首元素的地址
printf("%d\n", strlen(*arr));
//err - arr是数组首元素的地址,*arr是数组的首元素,‘a’-97
//虽然得到了97的地址,但我们不能访问的
printf("%d\n", strlen(arr[1]));
//err -'b' - 98
printf("%d\n", strlen(&arr));
//随机值
printf("%d\n", strlen(&arr + 1));
//随机值
printf("%d\n", strlen(&arr[0] + 1));
//随机值
printf("%llu\n", sizeof(arr));
//6
printf("%llu\n", sizeof(arr + 0));
//4/8 arr + 0是数组首元素的地址
printf("%llu\n", sizeof(*arr));
//1 - *arr是首元素,首元素是一个字符,大小是一个字节
printf("%llu\n", sizeof(arr[1]));
//1 - arr[1]是数组的第二个元素,大小是1个字节
printf("%llu\n", sizeof(&arr));
//4/8 &arr是数组的地址
printf("%llu\n", sizeof(&arr + 1));
//4/8 &arr + 1是从数组地址开始向后跳过了整个数组产生的一个地址
printf("%llu\n", sizeof(&arr[0] + 1));
//4/8 &arr[0] + 1 是数组第二个元素的地址
return 0;
}
\0
之前出现的字符个数int main()
{
char arr[] = "abcdef";
//[a b c d e f \0]
printf("%d\n", strlen(arr));//6
printf("%d\n", strlen(arr + 0));//6
//printf("%d\n", strlen(*arr));//err
//printf("%d\n", strlen(arr[1]));//err
printf("%d\n", strlen(&arr));//6
printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&arr[0] + 1));//5,从b的位置开始数
printf("%d\n", sizeof(arr));//7
printf("%d\n", sizeof(arr + 0));//4/8 arr+0是数组首元素的地址
printf("%d\n", sizeof(*arr));//1 - *arr 数组的首元素
printf("%d\n", sizeof(arr[1]));//1 arr[1]数组的第二个元素
printf("%d\n", sizeof(&arr));//4/8 - &arr数组的地址,但是数组的地址依然是地址,是地址大小就是4/8
printf("%d\n", sizeof(&arr + 1));//4/8 - &arr + 1是\0后边的这个地址
printf("%d\n", sizeof(&arr[0] + 1));//4/8 - &arr[0] + 1是数组第二个元素的地址
int main()
{
char* p = "abcdef";//p存的是a的地址
//练习①
printf("%d\n", strlen(p));
//6 -- p是存a的地址,从a开始数到\0,,共6个
printf("%d\n", strlen(p + 1));
//5 -- 从b的位置开始向后数字符
//printf("%d\n", strlen(*p));
//err -- p就是a地址,*p就是a,把a传给strlen是错误的
//printf("%d\n", strlen(p[0]));
//err -- p[0]=*p,错误如上
printf("%d\n", strlen(&p));
//随机值 -- &p取出p的地址,和abcdef无关了已经
printf("%d\n", strlen(&p + 1));
//随机值 -- 如图示①
printf("%d\n", strlen(&p[0] + 1));
//5 -- &p[0]即&(*p),就是a,+1后就是从b的位置开始向后数字符
//练习②
printf("%d\n", sizeof(p));
//4/8 p是指针变量,计算的是指针变量的大小
printf("%d\n", sizeof(p + 1));
//4/8 p+1是'b'的地址
printf("%d\n", sizeof(*p));
//1 -- *p 其实就是'a'
printf("%d\n", sizeof(p[0]));
//1 -- p[0]-> *(p+0)-> *p
printf("%d\n", sizeof(&p));
//4/8 -- &p是指针变量p在内存中的地址
printf("%d\n", sizeof(&p + 1));
//4/8 -- &p+1是跳过p之后的地址
printf("%d\n", sizeof(&p[0] + 1));
//4/8 -- &p[0]是‘a’的地址,&p[0]+1就是b的地址
int main()
{
//二维数组
int a[3][4] = { 0 };
printf("%d\n", sizeof(a));
//计算的是整个数组的大小,单位是字节3*4*4 = 48
printf("%d\n", sizeof(a[0][0]));
//4 第1行第一个元素的大小
printf("%d\n", sizeof(a[0]));
//16 -- a[0]是第一行的数组名,sizeof(a[0])就是第一行的数组名单独放在sizeof内部,计算的是第一行的大小
printf("%d\n", sizeof(a[0] + 1));
//4/8 a[0]作为第一行的数组名,并没有单独放在sizeof内部,也没有被取地址
//所以a[0]就是数组首元素的地址,就是第一行第一个元素的地址,a[0]+1就是第一行第二个元素的地址
printf("%d\n", sizeof(*(a[0] + 1)));
//4 - *(a[0] + 1))表示的是第一行第二个元素
printf("%d\n", sizeof(a + 1));
//4/8 - a表示首元素的地址,a是二维数组,首元素的地址就是第一行的地址
//所以a表示的是二维数组第一行的地址,a+1就是第二行的地址
printf("%d\n", sizeof(*(a + 1)));
//16 -- 对第二行的地址解引用访问到就是第二行
//*(a+1) -> a[1] --> sizeof(a[1])
printf("%d\n", sizeof(&a[0] + 1));
//4/8 - a[0]是第一行的数组名,&a[0]取出的就是第一行的地址
//&a[0] + 1 就是第二行的地址
printf("%d\n", sizeof(*(&a[0] + 1)));
//16 -- 对第二行的地址解引用访问到就是第二行
printf("%d\n", sizeof(*a));
//16 - a就是首元素的地址,就是第一行的地址,*a就是第一行
//*a - > *(a+0) -> a[0]
printf("%d\n", sizeof(a[3]));
//16 -- 类型:int [4]
//int a = 10;
//printf("%d\n", sizeof(a));//4
//printf("%d\n", sizeof(int));//4
return 0;
}
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int *)(&a + 1); //原本&a-->int(*)[5],故要强制类型转换成int*
printf( "%d,%d", *(a + 1), *(ptr - 1));
// 2 5
return 0;
}
//由于还没学习结构体,这里告知结构体的大小是20个字节
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少?
//已知,结构体Test类型的变量大小是20个字节
int main()
{
p=(struct Test*)0x100000
printf("%p\n", p + 0x1); ①
printf("%p\n", (unsigned long)p + 0x1); ②
printf("%p\n", (unsigned int*)p + 0x1); ③
return 0;
}
int main()
{
int a[4] = { 1, 2, 3, 4 };
int *ptr1 = (int *)(&a + 1);
int *ptr2 = (int *)((int)a + 1);
printf( "%x,%x", ptr1[-1], *ptr2);
return 0;
}
#include
int main()
{
int a[3][2] = { (0, 1), (2, 3), (4, 5) };
// 1 3 5
//此处是逗号表达式,若是二维数组则应该用大括号括起来
// {0, 1}, {2, 3}, {4, 5}
int *p;
p = a[0];
printf( "%d", p[0]); //p[0]=a[0][0]
return 0;
}
int main()
{
int a[5][5];
int(*p)[4]; //p是数组指针,指向的数组是4个元素
p = a;
printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
return 0;
}
int main()
{
int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int *ptr1 = (int *)(&aa + 1);
int *ptr2 = (int *)(*(aa + 1));
//aa表第一行的地址,+1后就是第二行的地址,一旦*接引用,就表第二行首元素地址
//*(aa + 1)也可表aa[1],即第二行的取地址,数组首元素地址
//ptr2就是指向6
printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
// 10 5
return 0;
}
#include
int main()
{
char* a[] = {"work","at","alibaba"};
//每个字符串的首元素的地址传到char*的指针数组里去
char**pa = a;
//a的每个元素都是char*
//一级指针char*的地址放到二级指针变量pa里头去
pa++;
printf("%s\n", *pa);
return 0;
}
int main()
{
char *c[] = {"ENTER","NEW","POINT","FIRST"};
char**cp[] = {c+3,c+2,c+1,c};
char***cpp = cp;
printf("%s\n", **++cpp);
//++ → 从cp[0]指向cp[1],即c+2;
//解引用,通过c+2的地址访问了POINT的首元素P,并向后打印得POINT
printf("%s\n", *--*++cpp+3);
//先算++ → 指向cp[2];
//再*解引用 → 取出cp[2]的内容c+1,
//再-- → c+1-1=c,cp[2]的原内容c+1被修改成c
//再*解引用 → 找到c的空间后,指向首元素E
//最后+3 → 指向ENTER的第四个元素E,并向后打印,得ER
printf("%s\n", *cpp[-2]+3);
//*cpp[-2]+3,即**(cpp-2)+3
//cpp-2 → cpp指向了cp[0],但并不会使得cpp改变
//解引用找到c[3]的空间,指向FIRST的首元素F
//+3 → 指向S元素,并向后打印,得ST
printf("%s\n", cpp[-1][-1]+1);
//cpp[-1][-1],即* (*(cpp-1) -1) +1
//cpp-1 → 指到cp[1]处
//*(cpp-1)→通过地址找到c+2
//*(cpp-1) -1 → c+2-1=c+1
//再解引用 → 通过c+1地址找到c[1]位置,即“NEW”,指向首元素“N”
//+1 → 指向“E”,并向后打印,得EW
return 0;
}
本章节的笔记是我先在本地obsidian中完成后,再传至CSDN中,故文中存在些链接其他文件的段落,但无法查看的情况。
说起来已经是第三次学指针。第一次囫囵吞枣,第二次还是有点稀里糊涂,第三次是因为数据结构学习有困难,回头再重过一遍C语言,又到了指针部分,有幸听到好老师细致的讲解,详细做了笔记。
每次学习指针,都有新的收获和体会。