网站建设代码编译的问题及解决方案,天元建设集团有限公司第六分公司,成都业务网络推广平台,我要自学网网站建设与管理C语言入门课程学习笔记9 第41课 - 指针#xff1a;一种特殊的变量实验-指针的使用小结 第42课 - 深入理解指针与地址实验-指针的类型实验实验小结 第43课 - 指针与数组#xff08;上#xff09;实验小结 第44课 - 指针与数组#xff08;下#xff09;实验实验小结 第45课 … C语言入门课程学习笔记9 第41课 - 指针一种特殊的变量实验-指针的使用小结 第42课 - 深入理解指针与地址实验-指针的类型实验实验小结 第43课 - 指针与数组上实验小结 第44课 - 指针与数组下实验实验小结 第45课 - 指针与函数实验实验小结 第46课 - 指针与堆空间实验实验小结 第47课 - 指针专题经典问题剖析小结 第41课 - 指针一种特殊的变量 实验-指针的使用
#include stdio.hint main()
{int var 0;int another 0;int* pVar NULL;printf(1. var %d\n, var);printf(1. pVar %p\n, pVar);pVar var; // 使用指针保存变量的地址*pVar 100; // *pVar 等价于 var var 100;printf(2. var %d\n, var);printf(2. pVar %p\n, pVar);pVar another; // 改变了 pVar 的指向使得 pVar 保存 another 的地址*pVar 1000; // another 1000;printf(3. another %d\n, another);printf(3. pVar %p\n, pVar);printf(4. add %d\n, var another *pVar); // 100 1000 1000 2100return 0;
}
/*
1. var 0
1. pVar 0000000000000000
2. var 100
2. pVar 000000000061FE14
3. another 1000
3. pVar 000000000061FE10
4. add 2100
*/ 小结 第42课 - 深入理解指针与地址 实验-指针的类型
#include stdio.hint main()
{int i 10;float f 10;int* pi f; // WARNING int* 指向了floatfloat* pf f; // OKprintf(pi %p, pf %p\n, pi, pf);printf(*pi %d, *pf %f\n, *pi, *pf);pi i; // WARNING *pi 110; // OOPSprintf(pi %p, *pi %d\n, pi, *pi);return 0;
} 实验
#include stdio.hint calculate(int n, long long* pa, long long* pm)
{int ret 1;if( (1 n) (n 20) ){int i 0;*pa 0;*pm 1;for(i1; in; i)// 01...n{ //1*1*...*n*pa *pa i;*pm *pm * i;}}else{ret 0;}return ret;
}int main()
{long long ar 0;long long mr 0;if( calculate(5, ar, mr) )printf(ar %lld, mr %lld\n, ar, mr);//15 1*2*3*4*5120return 0;
} 实验
#include stdio.hvoid func(int* p)
{*p 100; // 修改内存中 4 字节的数据即修改一个整型变量的值
}void swap(int* pa, int* pb)//通过指针交换变量
{int t 0;t *pa;*pa *pb;*pb t;
}int main()
{int var 0;int a 1, b 2;printf(1. var %d\n, var);func( var );printf(2. var %d\n, var);//100printf(3. a %d, b %d\n, a, b);swap(a, b);printf(4. a %d, b %d\n, a, b);return 0;
}
小结 第43课 - 指针与数组上 实验
#include stdio.hint main()
{int a[] {1, 2, 3, 4, 0};int* p a; // a 的类型为 int*, a[0] int*int (*pa) [5] a;//指向数组的指针 注意指针类型printf(%p, %p\n, p, a);p;//p1 p1*sizeof(p)*p 100; // a[1] 100;printf(%d, %d\n, *p, a[1]);printf(%p, %p\n, a, a);//????值一样 但是意思不一样数组的地址 数组首元素的地址p pa; // WARNING !!!! warning: assignment to int * from incompatible pointer type int (*)[5] p a;while( *p ){printf(%d\n, *p);p;}return 0;
}
/*
000000000061FDF0, 000000000061FDF0
100, 100
000000000061FDF0, 000000000061FDF0
1
100
3
4
*/
小结 第44课 - 指针与数组下 实验
#include stdio.hint main()
{int a[] {1, 2, 3, 4, 5};int* p a;int i 0;// a[i] *(ai) *(pi) p[i]for(i0; i5; i){printf(%d, %d\n, a[i], *(a i));}for(i0; i5; i){printf(%d, %d\n, a[i], p[i]);}for(i0; i5; i){printf(%d, %d\n, p[i], *(p i));}printf(a %p, p %p\n, a, p);//值相同printf(a %p, p %p\n, a, p);//值不同return 0;
} 实验
#include stdio.hint main()
{int a[] {1, 2, 3};int* p a;int v *p;//int v*p,p;char* s NULL;printf(%p\n, D.T.Software);printf(%p\n, D.T.Software);printf(v %d, *p %d\n, v, *p);printf(First %c\n, *D.T.Software);s D.T.Software;while( *s ) printf(%c, *s);printf(\n);return 0;
}
/*
0000000000404000
0000000000404000
v 1, *p 2
First D
D.T.Software
*/
小结 第45课 - 指针与函数 实验
#include stdio.hint add(int a, int b)
{return a b;
}int mul(int a, int b)
{return a * b;
}int calculate(int a[], int len, int(*cal)(int, int))
{int ret a[0];int i 0;for(i1; ilen; i){ret cal(ret, a[i]);}return ret;
}int main()
{int a[] {1, 2, 3, 4, 5};int (*pFunc) (int, int) NULL;pFunc add;printf(%d\n, pFunc(1, 2));//3printf(%d\n, (*pFunc)(3, 4));//7pFunc mul;printf(%d\n, pFunc(5, 6));//30printf(%d\n, (*pFunc)(7, 8));//56printf(1 ... 5 %d\n, calculate(a, 5, add));//15printf(1 * ... * 5 %d\n, calculate(a, 5, mul));//120return 0;
} 实验
#include stdio.hint demo(int arr[], int len) // int demo(int* arr, int len)//数组求和
{int ret 0;int i 0;printf(demo: sizeof(arr) %d\n, sizeof(arr));// 8 退化为指针了while( i len ){ret *arr;i;}return ret;
}int main()
{int a[] {1, 2, 3, 4, 5};// int v *a;printf(return value: %d\n, demo(a, 5));//return 0;
}
小结 第46课 - 指针与堆空间 实验
#include stdio.hint main()
{char c 0;int i 0;float f 2.0f;double d 3.0;void* p NULL;double* pd NULL;int* pi NULL;/* void* 指针可以保存任意类型的地址 */p c;p i;p f;p d;printf(%p\n, p);// void* 类型的指针无法访问内存中的数据// printf(%f\n, *p);/* void* 类型的变量可以直接合法的赋值给其他具体数据类型的指针变量 */pd p;pi p;// void* 是例外其他指针类型的变量不能相互赋值// pd pi;return 0;
} 实验
#include stdio.h
#include stdlib.hint main()
{int* p malloc(4); // 从堆空间申请 4 个字节当作 int 类型的变量使用if( p ! NULL ) // 如果申请失败 p 为 0 即空值{*p 100;printf(%d\n, *p);//100free(p);}p malloc(4 * sizeof(int));if( p ! NULL ){int i 0;for(i0; i4; i){p[i] i * 10;}for(i0; i4; i){printf(%d\n, p[i]);}free(p);}return 0;
}
/*
100
0
10
20
30
*/
小结 第47课 - 指针专题经典问题剖析 #include stdio.h
#include stdlib.hint main()
{int a 0;int b 1;int* p a; //p指向aint** pp p;//pp指向p**pp 2; // a 2;*pp b; // p b; *p 3; // b 3;printf(a %d, b %d\n, a, b);return 0;
}#include stdio.h
#include stdlib.hint main()
{int a[] {1, 2, 3, 4};int* pa a;int b[2][2] {{1, 2}, {3, 4}};// int** pb b; // b 的类型绝对不是 int** warning: initialization of int ** from incompatible pointer type int (*)[2]int (*pnb) [2] b; // b 的类型是 int(*)[2]printf(a %p, pa %p\n, a, pa);// printf(b %p, pb %p\n, b, pb);printf(b %p, pnb %p\n, b, pnb);return 0;
}
/*
a 000000000061FE00, pa 000000000061FE00
b 000000000061FDF0, pnb 000000000061FDF0
*/ #include stdio.h
#include stdlib.hint getDouble(double** pp, unsigned n)
{int ret 0;double* pd malloc(sizeof(double) * n);if( pd ! NULL ){printf(pd %p\n, pd);*pp pd;ret 1;}return ret;
}int main()
{double* p NULL;if( getDouble(p, 5) ){printf(p %p\n, p);free(p);}return 0;
}
/*
pd 00000000006E5CB0
p 00000000006E5CB0
*/ #include stdio.h
#include stdlib.hint main()
{int b[2][2] {{1, 2}, {3, 4}};int (*pnb) [2] b; // b 的类型是 int(*)[2]*pnb[0] 10;//*(pnb[0])*pnb[1] 30;printf(b[0][0] %d\n, b[0][0]);printf(b[0][1] %d\n, b[0][1]);//30printf(b[1][0] %d\n, b[1][0]);printf(b[1][1] %d\n, b[1][1]);return 0;
}
/*
b[0][0] 10
b[0][1] 2
b[1][0] 30
b[1][1] 4
*/ #include stdio.h
#include stdlib.hint main()
{int b[2][2] {{1, 2}, {3, 4}};int (*pnb) [2] b; // b 的类型是 int(*)[2]*pnb[0] 10;
int * kpnb[0] 1;//?? pnb[0] sizeof(*pnb[0])对了 *k 20;// *pnb[1] 30;
printf(sizeof(pnb) %d\n, sizeof(pnb));
printf(sizeof(pnb[0]) %d\n, sizeof(pnb[0]));
printf(sizeof(*pnb) %d\n, sizeof(*pnb));
printf(sizeof(*pnb[0]) %d\n, sizeof(*pnb[0]));
printf(pnb%p\n,pnb);
printf(pnb[0]%p\n,pnb[0]);
printf(pnb[0]1%p\n,pnb[0]1);printf(sizeof(b) %d\n, sizeof(b));
printf(sizeof(int[2]) %d\n, sizeof(int[2]));printf(b[0][0] %d\n, b[0][0]);printf(b[0][1] %d\n, b[0][1]);//30printf(b[1][0] %d\n, b[1][0]);printf(b[1][1] %d\n, b[1][1]);return 0;
}
/*
sizeof(pnb) 8
sizeof(pnb[0]) 8
sizeof(*pnb) 8
sizeof(*pnb[0]) 4
pnb000000000061FE00
pnb[0]000000000061FE00
pnb[0]1000000000061FE04
sizeof(b) 16
sizeof(int[2]) 8
b[0][0] 10
b[0][1] 20
b[1][0] 3
b[1][1] 4
*/ #include stdio.h
#include stdlib.hint* func()
{int var 100;return var;
}int main()
{int* p func(); // OOPS!!!!// p 指向了不合法的地址这个地址处没有变量存在// p 是一个野指针保存不合法地址的指针都是野指针printf(*p %d\n, *p);*p 200; // 改变 func 函数中局部变量 var 的值是不是非常奇怪printf(*p %d\n, *p);return 0;
}小结
