c语言 数组 amp,11－C语言指针&一维数组&字符串 - 平台梦

一、用指针遍历数组元素

1.最普通的遍历方式是用数组下标来遍历元素

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

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

3

4 int i;

5 for (i = 0; i < 4; i++) {

6 printf("a[%d] = %d \n", i, a[i]);

7 }

输出结果：

2.接下来我们用指针来遍历数组元素

先定义一个指针，指向数组的第一个元素

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

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

// 定义一个int类型的指针，并指向数组的第0个元素

int *p = a;

p的值是a[0]的地址，因此，现在我们利用指针p只能访问数组的第0个元素a[0]，用*p就可取出a[0]的值1。要想访问其他元素，就必须拿到元素的地址，可以发现每个元素的地址差值为2，因为在16位编译器环境下，一个int类型的变量占用2个字节。现在只是知道a[0]的地址值为p，怎么根据a[0]的地址获取其他元素的地址呢？其实非常简单，p+1就是a[1]的地址。注意了，这里的p+1代表着p的值加2，并不是p的值加1，比如p的值为ffc3，p+1则为ffc5，而非ffc4。依次类推，p+2就是a[2]的地址ffc7，p+3就是a[3]的地址ffc9。

我先解释一下，为什么p+1代表p的值加2，而不是加1呢？

其实，p+1不一定代表p的值加2，也可能是加1、加4或者加8。究竟加多少，这跟指针的类型有关。下图是在16位编译器环境下的情况。

聪明的你可能已经找到规律了，因为char类型的变量要占用1字节，所以p+1代表p的值加1；float类型的变量占用4字节，所以p+1代表p的值加4。从这一点，也可以很好地说明为什么指针一定要分类型，不同类型的指针，p+1的含义是不一样的。

上述代码中的p指向了int类型的数组元素a[0]，所以p+1代表p的值加2。知道怎么获取其他元素的地址了，那么就可以利用指针p遍历数组元素了。

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

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

4 //定义一个int类型的指针，并指向数组的第0个元素

5 int *p =a;6

7 inti;8 for (i = 0; i < 4; i++) {9 //利用指针运算符*取出数组元素的值

10 int value = *(p+i);11

12 printf("a[%d] = %d \n", i, value);13 }

注意第10行的代码，*(p+i)代表根据p+i的值(其实就是第i个数组元素的地址)访问对应的存储空间，并取出存储的内容(也就是取出第i个数组元素的值)，赋值给左边的value。

最后的输出效果是一样的：

。注意的是：遍历完毕后，指针变量p还是指向a[0]，因为p值一直没有变过，一直都是a[0]的地址ffc3。

补充一下，其实第10行改成下面的代码也是可以的：

int value = *(a+i);

利用上面的方法遍历完数组元素后，p一直指向元素a[0]。其实我们也可以直接修改p的值来访问数组元素，只需要改一下第10行的代码即可

// 利用指针运算符*取出数组元素的值

int value = *(p++);

p++其实就是相当于p = p + 1，直接修改了p值，而且每次是加2。因此，每执行一次p++，指针p就会指向下一个数组元素。

输出结果肯定是一样的：

。但是，遍历完毕后，指针变量p没有指向任何数组元素，因为一共执行了4次p++，最后p值为ffcb。当然，可以重新让p指向a[0]：p = &a[0];或者p = a;

注意，这里的写法是错误的

int value = *(a++);

a++相当于a=a+1，数组名a是个常量！不能进行赋值运算！

二、指针与数组的总结

p是指针，a是一个数组

1> 如果p指向了一个数组元素，则p+1表示指向数组该元素的下一个元素。比如，假设p = &a[0]，则p+1表示a[1]的地址

2> 对于不同类型的数组元素，p值的改变是不同的。如果数组元素为int类型，p+1代表着p的值加上2(16位编译器环境下)

3> 如果p的初值是&a[0]，那么

p+i和a+i都可以表示元素a[i]的地址，它们都指向数组的第i个元素。a代表数组首地址，a+i也是地址，它的计算方法与p+i相同

*(p+i)和*(a+i)都表示数组元素a[i]

虽然p+i和a+i都指向数组的第i个元素,但二者使用时还是有区别的。因为作为指针变量的p可以改变自身值，如p++,使p的值自增。而数组名a是一个代表数组首地址的常量，它的值是不能改变的，即a++是不合法的

4> 引用一个数组元素可以有两种方法:

下标法: 如a[i]

指针法: 如*(p+i) 或 *(a+i)

三、数组、指针与函数参数

1.用数组名作为函数实参时，是把实参数组的首地址传递给形参数组，两个数组共同占用同一段内存空间，这样形参数组中的元素值发生变化就会使实参数组的元素值也同时变化

1 void change(int b[]) {

2 b[0] = 10;

3 }

4

5 int main()

6 {

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

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

9

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

11 change(a);

12

13 // 查看a[0]

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

15

16 return 0;

17 }

change函数的形参是数组类型的，在第11行调用change函数时，将数组名a，也就是数组的地址传给了数组b。因此数组a和b占用着同一块内存空间。

输出结果：

2.这种地址的传递也可以用指针来实现。函数的实参和形参都可以分别使用数组或指针。这样就有4种情况:

如果一个函数的形参类型是一个指针变量，调用函数时，你可以传入数组名或者指针变量。

1 void change(int *b) {

2 b[0] = 10;

3 // 或者*b = 10;

4 }

5

6 int main()

7 {

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

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

10

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

12 change(a);

13

14 // 查看a[0]

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

16

17 return 0;

18 }

注意第1行的形参类型是个指针变量int *b，第12行将数组名a当做实参传入函数。

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

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

1 // 定义一个指针p

2 char *p;

3

4 // 定义一个数组s存放字符串

5 char s[] = "mj";

6

7 // 指针p指向字符串的首字符'm'

8 p = s; // 或者 p = &s[0];

9

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

11 printf("%c \n", *p);

12 }

执行完第8行后，内存分布如右图：

每次遍历之前先判断p当前指向的字符是否为空字符\0，如果不是空字符，就打印当前字符，然后执行p++让指针p指向下一个字符元素。

最后的输出结果：

五、用指针直接指向字符串

从前面可以看出，指针确实可以指向字符串并操作字符串。不过前面的做法是：先定义一个字符串数组存放字符串，然后将数组首地址传给指针p，让p指向字符串的首字符。

1.我们也可以直接用指针指向一个字符串，省略定义字符数组这个步骤

1 #include

2

3 int main()

4 {

5 // 定义一个字符串，用指针s指向这个字符串

6 char *s = "mj";

7

8 // 使用strlen函数测量字符串长度

9 int len = strlen(s);

10

11 printf("字符串长度：%D", len);

12 return 0;

13 }

注意第6行，我们直接用指针s指向了字符串"mj"，并没有先创建一个字符数组。看第9行，将指针s传入到strlen函数中，说明之前所学习的字符串处理函数依然可以正常使用。输出结果：

2.我们再来看看strlen函数在string.h中的声明

size_t strlen(const char *);

strlen函数中的形参是指向字符变量的指针类型，在《十、字符和字符串常用处理函数》中我们可以将一个字符数组名传进去，这一点又说明了指针与数组的密切关系，肯定有JQ。其实，调用strlen函数时，你传一个地址给它就行了，它会从这个地址开始计算字符的个数，直到遇到空字符'\0'位置，因此传入指针变量或者数组名都可以。

其他字符串处理函数也是一样的：

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

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

3 int strcmp(const char *, const char *); // 字符串比较函数

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

因此printf函数依然可以正常使用：

char *s = "mj";

printf("%s", s);

输出结果：

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

char *s;

s = "mj";

上面的指向方式也是正确的：先定义指针变量，再指向字符串。如果是字符数组就不允许这样做，下面的做法是错误的：

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指向的一个常量字符串，不允许修改它内部的字符。

六、指针处理字符串的注意

现在想将字符串"lmj"的首字符'l'改为'L'，解决方案是多种的

1.第一种方案

1 //定义一个字符串变量"lmj"

2 char a[] = "lmj";3

4 //将字符串的首字符改为'L'

5 *a = 'L';6

7 printf("%s", a);

程序正常运行，输出结果：

2.应该有人能马上想到第二种方案

1 char *p2 = "lmj";

2 *p2 = 'L';

3

4 printf("%s", p2);

看起来似乎是可行的，但这是错误代码，错在第2行。首先看第1行，指针变量p2指向的是一块字符串常量，正因为是常量，所以它内部的字符是不允许修改的。

有人可能搞蒙了，这里的第1行代码char *p2 = "lmj";跟第一种方案中的第2行代码char a[] = "lmj";不是一样的么？这是不一样的。

char a[] = "lmj";定义的是一个字符串变量！

char *p2 = "lmj";定义的是一个字符串常量！