devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言基础（五）—— 数组、数组地址（步长+1）、字符串输入输出、随机数_c语言 数组地址

作者：小丑西瓜9 | 2024-02-06 16:29:33

赞

踩

c语言 数组地址

1. 概述

在程序设计中，为了方便处理数据把具有相同类型的若干变量按有序形式组织起来——称为数组。

数组就是在内存中连续的相同类型的变量空间。同一个数组所有的成员都是相同的数据类型，同时所有的成员在内存中的地址是连续的。

数组属于构造数据类型：

  • 一个数组可以分解为多个数组元素：这些数组元素可以是基本数据类型或构造类型。

  1. int a[10];  
  2. struct Stu boy[10];

  • 按数组元素类型的不同，数组可分为：数值数组、字符数组、指针数组、结构数组等类别。

  1. int a[10];
  2. char s[10];
  3. char *p[10];
  4. struct Stu boy[10];

通常情况下，数组元素下标的个数也称为维数，根据维数的不同，可将数组分为一维数组、二维数组、三维数组、四维数组等。通常情况下，我们将二维及以上的数组称为多维数组。

2. 一维数组

2.1 一维数组的定义和使用

  • 数组名字符合标识符的书写规定(数字、英文字母、下划线)

  • 数组名不能与其它变量名相同，同一作用域内是唯一的

  • 方括号[]中常量表达式表示数组元素的个数

  1. int a[3]表示数组a有3个元素
  2. 其下标从0开始计算，因此3个元素分别为a[0],a[1],a[2]

  • 定义数组时[]内最好是常量，使用数组时[]内即可是常量，也可以是变量

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     int a[10];//定义了一个数组，名字叫a，有10个成员，每个成员都是int类型
  6.     //a[0]…… a[9]，没有a[10]
  7.     //没有a这个变量，a是数组的名字，但不是变量名，它是常量
  8.     a[0] = 0;
  9.     //……
  10.     a[9] = 9;
  11.  
  12.     int i = 0;
  13.     for (i = 0; i < 10; i++)
  14.     {
  15.         a[i] = i; //给数组赋值
  16.     }
  17.  
  18.     //遍历数组，并输出每个成员的值
  19.     for (i = 0; i < 10; i++)
  20.     {
  21.         printf("%d ", a[i]);
  22.     }
  23.     printf("\n");
  24.  
  25.     return 0;
  26. }

2.2 一维数组的初始化

在定义数组的同时进行赋值，称为初始化。全局数组若不初始化，编译器将其初始化为零。局部数组若不初始化，内容为随机值。

  1. int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//定义一个数组，同时初始化所有成员变量
  2. int a[10] = { 1, 2, 3 };//初始化前三个成员，后面所有元素都设置为0
  3. int a[10] = { 0 };//所有的成员都设置为0
  4.     
  5. //[]中不定义元素个数，定义时必须初始化
  6. int a[] = { 1, 2, 3, 4, 5 };//定义了一个数组，有5个成员

2.3 数组名和数组地址

数组名是一个地址的常量，代表数组中首元素的地址。

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//定义一个数组，同时初始化所有成员变量
  6.  
  7.     printf("a = %p\n", a);
  8.     printf("&a[0] = %p\n", &a[0]);
  9.  
  10.     int n = sizeof(a); //数组占用内存的大小，10个int类型，10 * 4  = 40
  11.     int n0 = sizeof(a[0]);//数组第0个元素占用内存大小，第0个元素为int，4
  12.  
  13.     int i = 0;
  14.     //数组长度：sizeof(a) / sizeof(a[0])
  15.     for (i = 0; i < sizeof(a) / sizeof(a[0]); i++)
  16.     {
  17.         printf("%d ", a[i]);
  18.     }
  19.     printf("\n");
  20.  
  21.     return 0;
  22. }
int a[10]
数组名a ,等价于第0个元素的地址( 首元素地址)
数组名是常量,不能被赋值
&a[0] 第0个元素的地址
&a 整个数组地址

在数值上，&a[0]，a，&a 相等。&a + 1，整个数组地址加1，跨过一个数组。

2.4 一维数组的最值（求最大或最小）

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     int a[] = {  1, -2, 3,- 4, 5, -6, 7, -8, -9, 10 };//定义一个数组，同时初始化所有成员变量
  6.  
  7.     int i = 0;
  8.     int max = a[0];
  9.     for (i = 1; i < sizeof(a) / sizeof(a[0]); i++)
  10.     {
  11.         if (a[i] > max)
  12.         {
  13.             max = a[i];
  14.         }
  15.     }
  16.     printf("数组中最大值为：%d\n", max);
  17.  
  18.     return 0;
  19. }

2.5 一维数组的逆置（翻转数组值）

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     int a[] = {  1, -2, 3,- 4, 5, -6, 7, -8, -9, 10 };//定义一个数组，同时初始化所有成员变量
  6.  
  7.     int i = 0;
  8.     int j = sizeof(a) / sizeof(a[0]) -1;
  9.     int tmp;
  10.  
  11.     while (i < j)
  12.     {
  13.         tmp = a[i];
  14.         a[i] = a[j];
  15.         a[j] = tmp;
  16.         i++;
  17.         j--;
  18.     }
  19.  
  20.     for (i = 0; i < sizeof(a) / sizeof(a[0]); i++)
  21.     {
  22.         printf("%d ", a[i]); //打印翻转后的值
  23.     }
  24.     printf("\n");
  25.  
  26.     return 0;
  27. }

2.6 冒泡法排序

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     int a[] = { 2, 5, 3, 7, -1 };//定义一个数组，同时初始化所有成员变量
  6.  
  7.     int i = 0;
  8.     int j = 0;
  9.     int n = sizeof(a) / sizeof(a[0]); //数组长度
  10.     int tmp;
  11.  
  12.     //1、流程
  13.     //2、试数
  14.     for (i = 0; i < n-1; i++)
  15.     {
  16.         for (j = 0; j < n - i -1 ; j++)//内循环的目的是比较相邻的元素，把大的放到后面
  17.         {
  18.             if (a[j]  > a[j + 1])
  19.             {
  20.                 tmp = a[j];
  21.                 a[j] = a[j+1];
  22.                 a[j+1] = tmp;
  23.             }
  24.         }
  25.     }
  26.  
  27.     for (i = 0; i < n; i++)
  28.     {
  29.         printf("%d ", a[i]);
  30.     }
  31.     printf("\n");
  32.  
  33.     return 0;
  34. }

3. 二维数组

3.1 二维数组的定义和使用

二维数组定义的一般形式是：

类型说明符 数组名[常量表达式1][常量表达式2]

其中常量表达式1表示第一维下标的长度，常量表达式2 表示第二维下标的长度。

例如：

int a[3][4];

  • 命名规则同一维数组

  • 定义了一个三行四列的数组，数组名为a其元素类型为整型，该数组的元素个数为3×4个，即：

二维数组a是按行进行存放的，先存放a[0]行，再存放a[1]行、a[2]行，并且每行有四个元素，也是依次存放的。

  • 二维数组在概念上是二维的：其下标在两个方向上变化，对其访问一般需要两个下标。

  • 在内存中并不存在二维数组，二维数组实际的硬件存储器是连续编址的，也就是说内存中只有一维数组，即放完一行之后顺次放入第二行，和一维数组存放方式是一样的。

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     //定义了一个二维数组，名字叫a
  6.     //由3个一维数组组成，这个一维数组是int [4]
  7.     //这3个一维数组的数组名分别为a[0],a[1],a[2]
  8.     int a[3][4];
  9.  
  10.     a[0][0] = 0;
  11.     //……
  12.     a[2][3] = 12;
  13.  
  14.     //给数组每个元素赋值
  15.     int i = 0;
  16.     int j = 0;
  17.     int num = 0;
  18.     for (i = 0; i < 3; i++)
  19.     {
  20.         for (j = 0; j < 4; j++)
  21.         {
  22.             a[i][j] = num++;
  23.         }
  24.     }
  25.  
  26.     //遍历数组，并输出每个成员的值
  27.     for (i = 0; i < 3; i++)
  28.     {
  29.         for (j = 0; j < 4; j++)
  30.         {
  31.             printf("%d, ", a[i][j]);
  32.         }
  33.         printf("\n");
  34.     }
  35.  
  36.     return 0;
  37. }

3.2 二维数组的初始化

  1. //分段赋值     int a[3][4] = {{ 1, 2, 3, 4 },{ 5, 6, 7, 8, },{ 9, 10, 11, 12 }};
  2.     int a[3][4] = 
  3.     { 
  4.         { 1, 2, 3, 4 },
  5.         { 5, 6, 7, 8, },
  6.         { 9, 10, 11, 12 }
  7.     };
  8.  
  9.     //连续赋值
  10.     int a[3][4] = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12  };
  11.  
  12.     //可以只给部分元素赋初值，未初始化则为0
  13.     int a[3][4] = { 1, 2, 3, 4  };
  14.  
  15.     //所有的成员都设置为0
  16.     int a[3][4] = {0};
  17.  
  18.     //[]中不定义元素个数，定义时必须初始化
  19.     int a[][4] = { 1, 2, 3, 4, 5, 6, 7, 8};

3.3 二维数组名和数组地址

数组名是一个地址的常量，代表数组中首元素的地址。

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     //定义了一个二维数组，名字叫a
  6.     //二维数组是本质上还是一维数组，此一维数组有3个元素
  7.     //每个元素又是一个一维数组int[4]
  8.     int a[3][4] = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12  };
  9.  
  10.     //数组名为数组首元素地址，二维数组的第0个元素为一维数组
  11.     //第0个一维数组的数组名为a[0]
  12.     printf("a = %p\n", a);
  13.     printf("a[0] = %p\n", a[0]);
  14.     
  15.     //测二维数组所占内存空间，有3个一维数组，每个一维数组的空间为4*4
  16.     //sizeof(a) = 3 * 4 * 4 = 48
  17.     printf("sizeof(a) = %d\n", sizeof(a));
  18.  
  19.     //测第0个元素所占内存空间，a[0]为第0个一维数组int[4]的数组名，4*4=16
  20.     printf("sizeof(a[0]) = %d\n", sizeof(a[0]) );
  21.  
  22.     //测第0行0列元素所占内存空间，第0行0列元素为一个int类型，4字节
  23.     printf("sizeof(a[0][0]) = %d\n", sizeof(a[0][0]));
  24.  
  25.     //求二维数组行数
  26.     printf("i = %d\n", sizeof(a) / sizeof(a[0]));
  27.  
  28.     // 求二维数组列数
  29.     printf("j = %d\n", sizeof(a[0]) / sizeof(a[0][0]));
  30.  
  31.     //求二维数组行*列总数
  32.     printf("n = %d\n", sizeof(a) / sizeof(a[0][0]));
  33.  
  34.     return 0;
  35. }
int a[2][3];

a[0][0] ： 第0行第0个元素
&a[0][0]: 第0行第0个元素的地址 = 01
a[0] : 第0行一维数组的数组名，a[0] = &a[0][0] = 01
&a[0] : 第0行的地址 = 01
a : 二维数组数组名，代表二维数组，也代表首行地址 &a[0]
&a : 二维数组地址

3.4 练习

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     //二维数组：  五行、三列
  6.     //行代表人：  老大到老五
  7.     //列代表科目：语、数、外
  8.     float a[5][3] = { { 80, 75, 56 }, { 59, 65, 71 }, { 59, 63, 70 }, { 85, 45, 90 }, { 76, 77, 45 } };
  9.  
  10.     int i, j, person_low[3] = { 0 };
  11.     float s = 0, lesson_aver[3] = { 0 };
  12.  
  13.     for (i = 0; i < 3; i++)
  14.     {
  15.         for (j = 0; j < 5; j++)
  16.         {
  17.             s = s + a[j][i];
  18.             if (a[j][i] < 60)
  19.             {
  20.                 person_low[i]++;
  21.             }
  22.         }
  23.  
  24.         lesson_aver[i] = s / 5;
  25.         s = 0;
  26.     }
  27.  
  28.     printf("各科的平均成绩:\n");
  29.     for (i = 0; i < 3; i++)
  30.     {
  31.         printf("%.2f\n", lesson_aver[i]);
  32.     }
  33.         
  34.     printf("各科不及格的人数:\n");
  35.     for (i = 0; i < 3; i++)
  36.     {
  37.         printf("%d\n", person_low[i]);
  38.     }
  39.         
  40.     return 0;
  41. }

4. 多维数组

多维数组的定义与二维数组类似，其语法格式具体如下：

  1. 数组类型修饰符 数组名 [n1][n2]…[nn];
  2. //例如：
  3. int a[3][4][5];
  4. /*
  5. 定义了一个三维数组，数组的名字是a，数组的长度为3，每个数组的元素又是一个二维数组，这个二维数组的长度是4，并且这个二维数组中的每个元素又是一个一维数组，这个一维数组的长度是5，元素类型是int。
  6. */
  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     //int a[3][4][5] ;//定义了一个三维数组，有3个二维数组int[4][5]
  6.     int a[3][4][5] = { { { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10 }, { 0 }, { 0 } }, { { 0 }, { 0 }, { 0 }, { 0 } }, { { 0 }, { 0 }, { 0 }, { 0 } } };
  7.  
  8.     int i, j, k;
  9.     for (i = 0; i < 3; i++)
  10.     {
  11.         for (j = 0; j < 4; j++)
  12.         {
  13.             for (k = 0; k < 5; k++)
  14.             {
  15.                 //添加访问元素代码
  16.                 printf("%d, ", a[i][j][k]);
  17.             }
  18.             printf("\n");
  19.         }
  20.     }
  21.     return 0;
  22. }

5. 字符数组与字符串

5.1 字符数组与字符串区别

  • C语言中没有字符串这种数据类型，可以通过char的数组来替代；

  • 字符串一定是一个char的数组，但char的数组未必是字符串；

  • 数字0(和字符‘\0’等价)结尾的char数组就是一个字符串，但如果char数组没有以数字0结尾，那么就不是一个字符串，只是普通字符数组，所以字符串是一种特殊的char的数组。

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     char c1[] = { 'c', ' ', 'p', 'r', 'o', 'g' }; //普通字符数组
  6.     printf("c1 = %s\n", c1); //乱码，因为没有’\0’结束符
  7.  
  8.     //以‘\0’(‘\0’就是数字0)结尾的字符数组是字符串
  9.     char c2[] = { 'c', ' ', 'p', 'r', 'o', 'g', '\0'}; 
  10.     printf("c2 = %s\n", c2);
  11.  
  12.     //字符串处理以‘\0’(数字0)作为结束符，后面的'h', 'l', 'l', 'e', 'o'不会输出
  13.     char c3[] = { 'c', ' ', 'p', 'r', 'o', 'g', '\0', 'h', 'l', 'l', 'e', 'o', '\0'};
  14.     printf("c3 = %s\n", c3);
  15.  
  16.     return 0;
  17. }

5.2 字符串的初始化

  1. #include <stdio.h>
  2.  
  3. // C语言没有字符串类型，通过字符数组模拟
  4. // C语言字符串，以字符‘\0’, 数字0
  5. int main()
  6. {
  7.     //不指定长度, 没有0结束符，有多少个元素就有多长
  8.     char buf[] = { 'a', 'b', 'c' };
  9.     printf("buf = %s\n", buf);    //乱码
  10.  
  11.     //指定长度，后面没有赋值的元素，自动补0
  12.     char buf2[100] = { 'a', 'b', 'c' };
  13. char buf[1000]={“hello”};
  14.     printf("buf2 = %s\n", buf2);
  15.  
  16.     //所有元素赋值为0
  17.     char buf3[100] = { 0 };
  18.  
  19.     //char buf4[2] = { '1', '2', '3' };//数组越界
  20.  
  21.     char buf5[50] = { '1', 'a', 'b', '0', '7' };
  22.     printf("buf5 = %s\n", buf5);
  23.  
  24.     char buf6[50] = { '1', 'a', 'b', 0, '7' };
  25.     printf("buf6 = %s\n", buf6);
  26.  
  27.     char buf7[50] = { '1', 'a', 'b', '\0', '7' };
  28.     printf("buf7 = %s\n", buf7);
  29.  
  30.     //使用字符串初始化，编译器自动在后面补0，常用
  31.     char buf8[] = "agjdslgjlsdjg";
  32.  
  33.     //'\0'后面最好不要连着数字，有可能几个数字连起来刚好是一个转义字符
  34.     //'\ddd'八进制字义字符，'\xdd'十六进制转移字符
  35.     // \012相当于\n
  36.     char str[] = "\012abc";
  37.     printf("str == %s\n", str);
  38.  
  39.     return 0;
  40. }

5.3 字符串的输入输出

由于字符串采用了'\0'标志，字符串的输入输出将变得简单方便。

scanf从键盘读取字符串':

缺点: 遇到空格就会提前结束读取, 如果存放读取字符的空间不足,继续向后存放,会造成内存污染

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     char str[100];
  6.    
  7.     printf("input string1 : \n");
  8.     scanf("%s", str);//scanf(“%s”,str)默认以空格分隔
  9.     printf("output:%s\n", str);
  10.  
  11.     return 0;
  12. }

scanf %s格式读取，遇到\n结束，遇到空格结束

5.3.1 gets()

#include <stdio.h>
char *gets(char *s);
功能：从标准输入读入字符，并保存到s指定的内存空间，直到出现换行符或读到文件结尾为止。
参数：
s：字符串首地址
返回值：
成功：读入的字符串
失败：NULL

gets(str)与scanf(“%s”,str)的区别：

  • gets(str)允许输入的字符串含有空格

  • scanf(“%s”,str)不允许含有空格

注意：由于scanf()和gets()无法知道字符串s大小，必须遇到换行符或读到文件结尾为止才接收输入，因此容易导致字符数组越界(缓冲区溢出)的情况。

  1. char str[100];
  2. printf("请输入str: ");
  3. gets(str);
  4. printf("str = %s\n", str);

5.3.2 fgets()

#include <stdio.h>
char *fgets(char *s, int size, FILE *stream);
功能：从stream指定的文件内读入字符，保存到s所指定的内存空间，直到出现换行字符、读到文件结尾或是已读了size- 1个字符为止，最后会自动加上字符 '\0' 作为字符串结束。
参数：
s：字符串
size：指定最大读取字符串的长度（size - 1）
stream：文件指针，如果读键盘输入的字符串，固定写为stdin
返回值：
成功：成功读取的字符串
读到文件尾或出错： NULL

fgets()在读取一个用户通过键盘输入的字符串的时候，同时把用户输入的回车也做为字符串的一部分。通过scanf和gets输入一个字符串的时候，不包含结尾的“\n”，但通过fgets结尾多了“\n”。fgets()函数是安全的，不存在缓冲区溢出的问题。

  1. char str[100];
  2. printf("请输入str: ");
  3. fgets(str, sizeof(str), stdin);
  4. printf("str = \"%s\"\n", str);

5.3.3 puts()

#include <stdio.h>
int puts(const char *s);
功能：标准设备输出s字符串，在输出完成后自动输出一个'\n'。
参数：
s：字符串首地址
返回值：
成功：非负数
失败：-1 
  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     printf("hello world");
  6.     puts("hello world");
  7.  
  8.     return 0;
  9. }

5.3.4 fputs()

#include <stdio.h>
int fputs(const char * str, FILE * stream);
功能：将str所指定的字符串写入到stream指定的文件中， 字符串结束符 '\0' 不写入文件。
参数：
str：字符串
stream：文件指针，如果把字符串输出到屏幕，固定写为stdout标准输出(屏幕)
返回值：
成功：0
失败：-1

fputs()是puts()的文件操作版本，但fputs()不会自动输出一个'\n'。

  1. printf("hello world");
  2. puts("hello world");
  3. fputs("hello world", stdout);

5.3.5 strlen()

5) strlen()
#include <string.h>
size_t strlen(const char *s);
功能：计算指定指定字符串s的长度， 不包含字符串结束符‘\0’
参数：
s：字符串首地址
返回值：字符串s的长度，size_t为unsigned int类型 
  1. char str[] = "abc\0defg";
  2. int n = strlen(str);
  3. printf("n = %d\n", n);

5.4 字符串追加

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     char str1[] = "abcdef";
  6.     char str2[] = "123456";
  7.     char dst[100];
  8.  
  9.     int i = 0;
  10.     while (str1[i] != 0)
  11.     {
  12.         dst[i] = str1[i];
  13.         i++;
  14.     }
  15.  
  16.     int j = 0;
  17.     while (str2[j] != 0)
  18.     {
  19.         dst[i + j] = str2[j];
  20.         j++;
  21.     }
  22.     dst[i + j] = 0; //字符串结束符
  23.  
  24.     printf("dst = %s\n", dst);
  25.  
  26.     return 0;
  27. }

5.5 产生随机数

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.         //设置随机数种子
  6.         //获得随机数
  7.         //int  t = time(NULL);//time函数获得当前时间,,s
  8.         srand(time(NULL));//设置种子
  9.         int a = rand();//rand()获得随机数
  10.         printf("a=%d\n",a);
  11.         int b = rand();//rand()获得随机数
  12.         printf("b=%d\n", b);
  13.         system("pause");
  14.         return 0;
  15. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/63486
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号