这里写目录标题
- 字符指针
- 字符指针与常量字符串的区别：
- 指针数组
- 数组指针
- 两者的区别：
- &数组名 ，sizeof(arr)
- 数组指针的使用
- 数组参数，指针参数
- 一维数组传参
- 整型数组：
- 整型指针数组：
- 一级指针传参
- 二级指针传参
字符指针
字符指针：char*
一般用法：
#include<stdio.h>
int main()
{
char ch = 'w';
char* p = &ch; // 将字符变量ch的地址放在了字符指针p中
return 0;
}
另一种表示方法：
#include<stdio.h>
int main()
{
const char* p = "hello csdn.";
printf("%c\n", *p);//打印字符'h'
printf("%s\n", p);//打印字符串"hello csdn."
return 0;
}
字符指针p中存放的是字符串的首元素地址,即字符’h’的地址。
字符指针与常量字符串的区别：
#include <stdio.h>
int main()
{
char str1[] = "hello csdn.";
char str2[] = "hello csdn.";
char *str3 = "hello csdn.";
char *str4 = "hello csdn.";
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;
}
运行结果：
指针数组
数组指针
整型指针是指向整型的指针,字符指针是指向字符的指针，数组指针应该就是指向数组的指针了.
数组指针也是一样，我们只需取出数组的地址，并将其存入数组指针即可。
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
int(*p)[10] = &arr;
//&arr - 数组的地址
return 0;
}
数组的类型是int [10]
两者的区别：
首先p是一个指针，所以p必须要先与 * 结合，而[ ]的优先级要高于 * ，所以我们要加上( )以便让p与 * 先结合。
&数组名 ，sizeof(arr)
数组名代表整个数组的地址的情况其实只有两种：
- &数组名。
- 数组名单独放在sizeof内部，即sizeof(数组名)。
除此之外，所有的数组名都是数组首元素地址。
#include<stdio.h>
int main()
{
int arr[5] = { 1, 2, 3, 4, 5 };
int* p1 = arr;//数组首元素的地址
int(*p2)[5] = &arr;//数组的地址
printf("%p\n", p1);
printf("%p\n", p2);
printf("%p\n", p1+1);
printf("%p\n", p2+1);
return 0;
}
运行结果：
数组指针的使用
数组指针有一个简单的使用案例，那就是打印二维数组：
#include<stdio.h>
void print(int(*p)[5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)//行数
{
int j = 0;
for (j = 0; j < col; 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 } };
print(arr, 3, 5);//传入二维数组名，即二维数组首元素地址，即二维数组第一行的地址
return 0;
}
p+i:是第i行的首地址.
*(p+i):是第i行第0列元素的地址.
*(p+i)+j:是第i行第j列元素的地址.
*(*(p+i)+j):是第i行第j列元素所对应的值.
数组参数，指针参数
一维数组传参
#include<stdio.h>
void test1(int arr[10])//数组接收
{}
void test1(int *arr)//指针接收
{}
void test2(int *arr[20])//数组接收
{}
void test2(int **arr)//指针接收
{}
int main()
{
int arr1[10] = { 0 };//整型数组
int *arr2[20] = { 0 };//整型指针数组
test1(arr1);
test2(arr2);
}
整型数组：
当向函数传入整型数组的数组名时，我们有以下几种参数可供接收：
- 数组传参数组接收，我们传入的是整型数组，那我们就用整型数组接收。
- 传入的数组名本质上是数组首元素地址，所以我们可以用指针接收。数组的元素类型是整型，我们接收整型元素的地址用int * 的指针即可。
整型指针数组：
当向函数传入整型指针数组的数组名时，我们有以下几种参数可供接收：
- 数组传参数组接收，我们传入的是整型指针数组，那我们就用整型指针数组接收。
- 指针接收，数组的元素是int * 类型的，我们接收int * 类型元素的地址用二级指针int ** 即可。
注意：一维数组传参，函数形参设计时[ ]内的数字可省略。
一级指针传参
#include<stdio.h>
void print(int* p, int sz)//一级指针接收
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(p + i));
}
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int sz = sizeof(arr) / sizeof(arr[0]);
int* p = arr;//一级指针
print(p, sz); // 直接print (arr ,sz) 也可以
return 0;
}
二级指针传参
#include<stdio.h>
void test(int** p)//二级指针接收
{}
int main()
{
int a = 10;
int* pa = &a;
int** paa = &pa;
test(paa);//二级指针
return 0;
}
函数的参数可以传递什么形式？
以下三种：
#include<stdio.h>
void test(int** p)
{}
int main()
{
int a = 10;
int* pa = &a;
test(&pa);//可以传入一级指针的地址
int** paa = &pa;
test(paa);//可以传入二级指针
int* arr[10];
test(arr);//可以传入一级指针数组的数组名
//...
return 0;
}
