指针的进阶
1.字符指针
void test(int arr[])
{
int sz=sizeof(arr)/sizeof(arr[0]);
printf("%d\n", sz);
}
int main()
{
int arr[10] = {0};
test(arr);
return 0;
}
这个代码在64位计算机中是8/4=2
在32位计算机中的是4/4=1
int main()
{
char ch='w';
char *pc=&ch;
printf("%c\n",*pc);
return 0;
}代码输出w
int main()
{
char arr[]="abcdef";
char *pc=arr;
printf("%s\n",arr);
printf("%s\n",pc);
}
打印的都是abcdef
int main()
{
char *p = "abcdef";
printf("%s\n", p);
}
下面这个例子说明，*p字符串是不能够修改的。加上const就行了。
int main()
{
const char *p="abcedf";
//*p='W';
printf("%s",p);
return 0;
}
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abcdef";
char * p1 = "abcdef";
char * p2 = "abcdef";
if (arr1 == arr2)
{
printf("hehe\n");
}
else
{
printf("haha\n");
}
return 0;
}
haha
因为地址不相同
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abcdef";
char * p1 = "abcdef";
char * p2 = "abcdef";
if (p1==p2)
{
printf("hehe\n");
}
else
{
printf("haha\n");
}
return 0;
}
我条件改变了，p1==p2
直接就是hehe
因为字符串相同了
2.数组指针
//数组指针-指针
int main()
{
int *p=NULL;//p是整型指针-指向整形的指针-可以存放整型的地址
char *pc=NULL;//pc是字符的指针-指向字符的指针-可以存放字符的地址
//数组的指针-指向数组的指针 -存放数组的地址
//int arr[10]={0};
//arr-首元素地址
//&arr-数组的地址
int arr[10]={1,2,3,4,5,6,7,8,9,10};
int(*p)[10]=&arr;//数组的地址存起来
//上面的p就是数组指针
return 0;
}
int main()
{
char *arr[5];
char *(*pa)[5]=&arr;//【5】pa指向的数组是5个元素
//pa指向的数组的元素类型是char *
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 i=0;
for(i=0;i<10;i++){
printf("%d ",(*pa)[i]);
}
return 0;
}
int main()
{
int arr[10]={1,2,3,4,5,6,7,8,9,10};
int (*pa)[10]=&arr;
int i=0;
for(i=0;i<10;i++){
printf("%d ",*(*pa+i));//*pa=arr
}
return 0;
}
int main()
{
int arr[10]={1,2,3,4,5,6,7,8,9,10};
int *p=arr;
int i=0;
for(i=0;i<10;i++){
printf("%d ",*(p+i));
}
}
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");
}
}
int main()
{
int arr[3][5]={{1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7}};
print1(arr,3,5);//arr -数组名 -数组名就是首元素地址
}
//参数是数组的形式
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},{3,4,5,6,7}};
print1(arr,3,5);
print2(arr,3,5);
return 0;
}
int arr[5]; //arr是一个5个元素的整形数组
int *parr1[10];//parr1 是一个数组，数组有10个元素，每个元素的类型是int *,parr1是指针数组
int (*parr2)[10];//parr2是一个指针，该指针指向一个数组，数组有10个元素，每个元素的类型是int parr2是数组指针
int (*parr3[10])[5];//parr3是一个数组，该数组有10个元素，每个元素是一个数组指针。
该数组指针指向的数组有5个元素。每个元素是int
前倾回顾：
int main()
{
//字符指针
char ch='w';
char *p=&ch;
const char *p2="abcdef";
//指针数组-数组-存放指针的数组
int *arr[10];
char *ch[5];
//数组指针
//int *p3;//整型指针-指向整型的指针
//char *p4;//字符指针-指向字符的
int arr[5];//数组
int (*pa)[5]=&arr2;//取出数组的地址,pa就是一个数组指针
return 0;
}
3.指针数组
//指针数组 是数组，用来存放指针的
int main(){
int arr[10]={0};
char ch[5]={0};
int *parr[4];//存放整型指针的数组-指针数组
char * pch[5];//存放字符指针的数组-指针数组
}
int main()
{
int a = 10;
int b=20;
int c = 30;
int d = 40;
int *arr[4] = { &a,&b,&c,&d };
int i = 0;
for (i = 0; i < 4; i++)
{
printf("%d\n", *arr[i]);
}
return 0;
}
int main()
{
int arr1[] = {1,2,3,4,5};
int arr2[] = { 2,3,4,5,6 };
int arr3[] = { 3,4,5,6,7 };
int *parr[] = { arr1,arr2,arr3 };
for (int i = 0; i < 3; i++)//3列
{
for (int j = 0; j < 5; j++)//5行
{
printf("%d ", parr[i][j]);//输出
}
}
printf("\n");
}
}
4.数组传参和指针传参
void test(int arr[])
{}
void test(int arr[10])
{}
void test(int *arr)
{}
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])
{}
void test1(int arr[][5])
{}
//void test2(int arr[3][])//err
//{}
int main()
{
int arr[3][5] = { 0 };
test(arr);//二维数组传参
test1(arr);
//test2(arr);
}
//void test(int arr[3][5])
//{}
//void test1(int arr[][5])
//{}
void test2(int arr[3][])//err
{}
void test3(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);
}
一级指针传参
void print(int *p,int sz) {
for (int i = 0; i < sz; i++) {
printf("%d ", *(p + i));
}
}
int main() {
int arr[] = { 1,2,3,4,5,6,7,8,9};
int* p = arr;
int sz=sizeof(arr)/sizeof(arr[0]);
//一级指针p,传给函数
print(p,sz);
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);
test2(pc);//ok
return 0;
}
二级指针传参
void test(int** ptr)
{
printf("%d\n", **ptr);
}
int main()
{
int a = 10;
int* p = &a;
int** pp = &p;
test(pp);
test(&p);
return 0;
}
void test(int **p)
{}
int main()
{
int* ptr;
int** pp = &ptr;
test(pp);
int* arr[10];
test(arr);//指针数组
return 0;
}
5.函数指针
//数组指针-是指向数组的指针
//函数指针-是指向函数的指针-存放函数地址的一个指针
int Add(int x, int y) {
return x + y;
}
int main() {
int a = 0;
int b = 0;
scanf("%d%d", &a, &b);
int sum = Add(a, b);
printf("%d\n", sum);
return 0;
}
int Add(int x, int y) {
return x + y;
}
int main() {
int a = 10;
int b = 20;
int arr[10] = {0};
//&arr;
//arr;
//printf("%d\n", Add(a,b));
//&函数名和函数名都是函数的地址
printf("%p\n", &Add);
printf("%p\n", Add);
return 0;
}
int Add(int x, int y) {
return x + y;
}
int main() {
/*int a = 10;
int b = 20;
int arr[10] = { 0 };
int (*p)[10] = &arr;*/
//&arr;
//arr;
//printf("%d\n", Add(a,b));
//printf("%p\n", &Add);
//printf("%p\n", Add);
int (*pa)(int,int) = Add;
printf("%d\n",(*pa)(2, 3));//5
return 0;
}
结果是5
