C语言学习入门 (五) 指针

直接引用

char a;

a = 10;

程序内部是怎么操作的呢？

其实，程序对变量的读写操作，实际上是对变量所在的存储空间进行写入或取出数据。就上面的代码而言，

系统会自动将变量名a转换为变量的存储地址，根据地址找到变量a的存储空间，然后再将数据10以2进制的形式放入变量a的存储空间中。

通过变量名引用变量，由系统自动完成变量名和其存储地址之间的转换，称为变量的"直接引用"方式

间接引用

如 将变量a的地址存放在另一个变量中，比如存放在变量b中，然后通过变量b来间接引用变量a，间接读写变量a的值。这就是"间接引用"

总结一句：用来存放变量地址的变量，就称为"指针变量"。在上面的情况下，变量b就是个"指针变量"，我们可以说指针变量b指向变量a。

指针的定义

一般形式：类名标识符 *指针变量名;

int *p;

float *q;

"*"是一个说明符，用来说明这个变量是个指针变量，是不能省略的，但它不属于变量名的一部分
前面的类型标识符表示指针变量所指向的变量的类型，而且只能指向这种类型的变量

指针的初始化

int a = 10;int *p = &a; float
b = 2.3f; float *q; q = &b;

指针运算符

给指针指向的变量赋值

char a = 10;

printf("修改前，a的值：%d\n", a);

// 指针变量p指向变量a

char *p = &a;//这个* 是定义指针的说明符

// 通过指针变量p间接修改变量a的值

*p = 9;//这个* 是指针运算符，表示 把9赋值给 指针指向的地址a，也就相当于 a ＝ 9；

//这里 就是间接修改a的值

printf("修改后，a的值：%d", a);

取出指针所指向变量的值

char a = 10;

char *p;

p = &a;

char value = *p; //根据p值(即变量a的地址)访问对应的存储空间，并取出存储的内容(即取出变量a的值)，赋值给value

printf("取出a的值：%d", value);

使用注意

在指针变量没有指向确定地址之前，不要对它所指的内容赋值。下面的写法是错误的

int *p;

*p = 10; //这是错误的

应该在指针变量指向一个确定的变量后再进行赋值。下面的写法才是正确的

// 定义2个int型变量

int a = 6, b;

// 定义一个指向变量b的指针变量p

int *p;

p = &b;

// 将a的值赋值给变量b

*p = a;

例子

交换两个字符变量的地址（改变实参的值）

void swap(char *p,char *q)

{

char temp = *p;

*p = *q;

*q = temp;

}

int main(int argc,constchar *
argv[])

{

char a ='A', b ='&';

swap(&a, &b);

printf("a=%c b=%c\n”, a, b);

}

用指针指向一维数组的元素

int a[2] = {2, 3}; int *p = &a[0]; *p = 10; 那么 a[0]应该等于10

数组名a 的地址 与 它的第一个元素的地址相同， 所以 p = &a[0] 与 p = a 效果一样

指针来遍历数组元素

int ary[] = {1,2,3,4, 5};

int *q = ary;

for (int i =0; i <5; i++)

{

//数组内元素内存地址是连续的存储方式，指针移动一个对应类型单位字节数(int、char...),则指向下一个元素值

// printf("数为:%d ", *(q+i)); //地址移动

// printf("数为:%d ", *(ary+i)); //地址移动

printf("数为:%d ", *(q++));//q=q+1,指针指向的地址移动

// printf("数为：%d ", *(ary++)); //错误,常量不能赋值

}

数组、指针、函数参数

形参数组，实参指针

void change(int b[]) {

b[0] = 10;

}

int main()

{

// 定义一个int类型的数组

int a[4] = {1, 2, 3, 4};

int *p = a;

// 将数组名a传入change函数中

change(p);

// 查看a[0]

printf("a[0]=%d", a[0]);

return 0;

}

形参指针，实参数组

void change(int *b) {

b[0] = 10;

// 或者*b = 10;

b[1] = 11;

// 或 *(b+1) = 11;

}

int main()

{

// 定义一个int类型的数组

int a[4] = {1, 2, 3, 4};

// 将数组名a传入change函数中

change(a);

// 查看a[0]

printf("a[0]=%d", a[0]);

return 0;

} //可以看出，在很多情况下，指针和数组是可以相互切换使用的。但是，并不能说指针就等于数组

用指针遍历字符串的所有字符

char chs[] ="abcde";

char *p;

p = chs;

for (; *p != '\0';p++)

{

printf("data:%c ", *p);

}

printf("\n");

用指针直接指向字符串

char *p ="abcde";

strlen("abde”);

函数在string.h中的声明

size_t strlen(const char *);

char *strcpy(char *,const char *);// 字符串拷贝函数

char *strcat(char *,const char *);// 字符串拼接函数

int strcmp(constchar *, constchar *); // 字符串比较函数

它们的参数都是指向字符变量的指针类型，因此可以传入指针变量或者数组名。

指针指向字符串的其他方式

1 char s[10];

2 s ="mj"; //编译器肯定报第2行的错，因为s是个常量，代表数组的首地址，不能进行赋值运算

1 char *s ="mj";

2

3 *s = "like";

第3行代码犯了2个错误：

第3行代码相当于把字符串"like"存进s指向的那一块内存空间，由第1行代码可以看出，s指向的是"mj"的首字符'm'，
也就是说s指向的一块char类型的存储空间，只有1个字节，要"like"存进1个字节的空间内，肯定内存溢出
由第1行代码可以看出，指针s指向的是字符串常量"mj"！因此是不能再通过指针来修改字符串内容的！
就算是*s = 'A'这样"看起来似乎正确"的写法也是错误的，因为s指向的一个常量字符串，不允许修改它内部的字符。

char a[] ="lmj";定义的是一个字符串变量！
char *p = a; *p = ‘L’; 变量可以通过指针改变，常量不行
char *p2 = "lmj";定义的是一个字符串常量！

返回指针的函数

返回指针的函数的一般形式为：类型名 *函数名(参数列表)

// 将字符串str中的小写字母变成大写字母，并返回改变后的字符串

// 注意的是：这里的参数要传字符串变量，不能传字符串常量

[plain] view
plaincopyprint?





char * upper(char *str) {

// 先保留最初的地址。因为等会str指向的位置会变来变去的。

char *dest = str;

// 如果还不是空字符

while (*str != '\0') {

// 如果是小写字母

if (*str >= 'a' && *str <= 'z') {

// 变为大写字母。小写和大写字母的ASCII值有个固定的差值

*str -= 'a' - 'A';

}

// 遍历下一个字符

str++;

}

// 返回字符串

return dest;

}

int main()

{

//定义一个字符串变量

char str[] = "lmj";

// 调用函数

char *dest = upper(str);

printf("%s", dest);

printf("%s", str);

return 0;

}

指向函数的指针

定义的一般形式：函数的返回值类型 (*指针变量名)(形式参数1,形式参数2, ...);

注意：形式参数的变量名可以省略，甚至整个形式参数列表都可以省略

int sum(int a,int b)

{

return a + b;

}

int main()

{

int (*q) (int a,int b) = sum;//
(int a, int b) 可以写成(int a, int)或(int,int)或()

int result = (*q)(2,5);//调用函数

printf("\n%d", result)

return 0;

}

将函数作为参数

void get(int (*q)(int a,char b), float c)
{}