//相同数据类型的元素集合，在空间地址上连续存储；
目录
一维数组
数组的定义
一般形式：
存储类型 数据类型 数组名[元素个数]；// 是数组的标志
例如：int a [5]; ——定义了一个有5个元素为整数类型的数组
数组名：是一个标志符，也要遵守标识符的命名规则，数组名是一个常量
含义：
1、代表数组的首地址——gets（ ）、puts（ ）
2、代表整个数组——sizeof（ ）
[ ]:变址符,可以访问对应元素的地址
元素个数：整形常量，不要定义和初始化的时候写常量变量来充当元素个数
数组的初始化
一般形式：
存储类型 数据类型 数组名 [元素个数] ={元素1，元素2，元素3....}；元素之间用逗号隔开，用花括号全部括起来
初始化的三种写法：
1、全部初始化：有多少个元素个数，就赋值多少个值
例如：int a[5]={12,34,56,78,90};2、局部初始化：前面依次赋值，后面没有赋值的自动补0
例如：int a[5] = {12,34};3、省略初始化：省略的是元素个数，根据后面的初始化赋值来开辟对应的空间地址，不会有空间的浪费，要注意数组越界问题
例如：int a[ ]={12，34}；---这个数组只有两个元素的空间地址
数组的赋值
能通过循环赋值，或一个一个赋值
(一个一个赋值)例如：a[0] = 1;
a[1] = 2;
a[2] = 3;
循环赋值请看数组的遍历
数组的调用
数组名 [下标]；下标从零开始
例如：printf（“%d”,a[1]）;
数组的遍历
循环赋值
例如：
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[5] = {0};
int len = sizeof(a) / sizeof(int);
printf("请输入%d个数组元数\n",len);
for (int i = 0; i < len; i++)
{
scanf("%d",&a[i]);
}
for (int i = 0; i < len; i++)
{
printf("a[%d] = %d\n",i,a[i]);
}
return 0;
}
结果：
数组的清零
清零的三种写法：
1、局部初始化（常用）
例如：int a[5] = {0};
2、使用循环一个一个的赋值为零
例如：
#include <stdio.h> int main(int argc, char *argv[]) { int a[5] = {0}; int len = sizeof(a) / sizeof(int); printf("请输入%d个数组元数\n",len); for (int i = 0; i < len; i++) { a[i] = 0; } for (int i = 0; i < len; i++) { printf("a[%d] = %d\n",i,a[i]); } return 0; }结果：
3、用memset()函数清0
memset(清空的对象，赋值，字节大小)
例如：
#include <stdio.h> #include <string.h> int main(int argc, char *argv[]) { int a[5]; int len = sizeof(a) / sizeof(int); memset(a,0,sizeof(a)); for (int i = 0; i < len; i++) { printf("a[%d] = %d\n",i,a[i]); } return 0; }结果：
字符串数组
普遍性与特殊性
字符数组具有一般数组的普遍性，也有自己的特殊性
普遍性：定义、初始化、赋值、调用、遍历都是一样特殊性：字符串会以'\0‘结尾，可以直接用双引号括起来
例如：
#include <stdio.h> #include <string.h> int main(int argc, char *argv[]) { char a[] = {'h','e','l','l','o'}; char b[] = "hello"; printf("a(普遍性)=%ld\n",sizeof(a)); printf("b(特殊性)=%ld\n",sizeof(b)); return 0; }结果：
char a[]={'h','e','l','l','o'};//普遍性
char b[]="hello";//特殊性
字符串的相关函数
#include <string.h>---头文件
求字符串的有效长度——strlen( )
有效字符：不包括反斜杠0；和字节大小不是一个概念
strlen(字符串的首地址)；
返回值：求到的字符串的有效长度
例如：
#include <stdio.h> #include <string.h> int main(int argc, char *argv[]) { char a[5] = {0}; int len = sizeof(a) / sizeof(char); scanf("%s",a); int len1 = strlen(a); printf("len1=%d\n",len1); return 0; }结果：
字符串的复制——strcpy( )
strcpy(字符串1，字符串2)；
把字符串2赋值给字符串1
返回值：复制之后的字符串1的首地址例如：
#include <stdio.h> #include <string.h> int main(int argc, char *argv[]) { char a[6] = {0}; char b[6] = {0}; int len = sizeof(a) / sizeof(char); scanf("%s",a); scanf("%s",b); strcpy(a,b); printf("a=%s\n",a); printf("b=%s\n",b); return 0; }结果：
字符串的连接——strcat( )
strcat(字符串1，字符串2)；
//把字符串2从字符串1第一个'\0'开始连接
把字符串2连接到字符串1后
返回值：连接之后的字符串1的首地址例如：
#include <stdio.h> #include <string.h> int main(int argc, char *argv[]) { char a[32] = {0}; char b[32] = {0}; scanf("%s",a); scanf("%s",b); strcat(a,b); printf("a=%s\n",a); printf("b=%s\n",b); return 0; }结果：
字符串的比较——strcmp( )
strcmp(字符串1，字符串2)；
//依次比较每一个字符，一旦遇到不一样的，返回结果停止比较
有3种结果：
字符串1 > 字符串2
字符串1 < 字符串2
字符串1 == 字符串2
返回值：
字符串1 > 字符串2 她们的差值
字符串1 < 字符串2 她们的差值
字符串1 == 字符串2 她们的差值
例如：
#include <stdio.h> #include <string.h> int main(int argc, char *argv[]) { char a[32] = {0}; char b[32] = {0}; scanf("%s",a); scanf("%s",b); int c = strcmp(a,b); printf("a=%s\n",a); printf("b=%s\n",b); printf("strcmp=%d\n",c); return 0; }结果1：字符串1 > 字符串2
结果2：字符串1 < 字符串2
结果3：字符串1 == 字符串2
字符串查找——strstr( )
strstr(字符串1，字符串2)；
//从字符串1中查找字符串2第一次的地址
返回值：返回第一次出现查找的字符串的地址例如：
#include <stdio.h> #include <string.h> int main(int argc, char *argv[]) { char a[32] = {0}; char b[32] = {0}; scanf("%s",a); scanf("%s",b); char *c = strstr(a,b); printf("strstr=%s\n",c); return 0; }结果：
二维数组
二维数组的定义
一般形式：
存储类型 数据类 数组名 [行标] [列标];
例如： int a [3] [4];
数组的大小=数据类型 * 行标 * 列标
含义：
1、代表整个数组
2、代表首行地址---a=&a【0】；a[0]=&a[0][0];
例如：结构：
#include <stdio.h> int main(int argc, char *argv[]) { char a[3][8]={"hello","world","nihao"}; printf("%s\n",&a[0][0]); printf("%s\n",a[0]); printf("%s\n",a[1]); printf("a首地址=%p\n",&a); printf("a[0]首行地址=%p\n",&a[0]); printf("a[0][4]=%c\n",a[0][4]); return 0; }结果：
二维数组的初始化
初始化的三种写法：
1、全部初始化：有多少个元素个数，就赋值多少个值
例如：int a[3] [2]={12,34,56,78,90,100};2、局部初始化：
前面依次赋值，后面没有赋值的自动补0
例如：int a[3][2] = {12,34,56,78};
以{ }为结束，{ }后补
例如：int a[3][2]={{12}{34}{56,78}};
3、省略初始化：省略的是元素个数，根据后面的初始化赋值来开辟对应的空间地址，不会有空间的浪费，要注意数组越界问题
例如：int a[ ]={12，34}；---这个数组只有两个元素的空间地址
二维数组的调用
调用一个元素：数组名【行标】【列标】
调用一行元素：数组名【行标】--只针对字符串
二维数组的赋值
也只能一个一个赋值；
如果要进行一行一行的赋值，需要用到strcpy（）
例如：
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char a[3][8]={"hello","world","nihao"};
a[1][1]='y';
printf("a[1]=%s\n",a[1]);
strcpy(a[0],a[2]);
printf("a[0]=%s\n",a[0]);
return 0;
} 结果：
二维数组的遍历
一个一个遍历：
例如：
#include <stdio.h> #include <string.h> int main(int argc, char *argv[]) { char a[3][8]={"hello","world","nihao"}; for(int i = 0; i < 3; i++) { for(int j = 0; j < 8; j++) { printf("%c",a[i][j]); } putchar('\n'); } return 0; }结果：
一行一行遍历（字符二维数组）：
例如：
#include <stdio.h> #include <string.h> int main(int argc, char *argv[]) { char a[3][8]={"hello","world","nihao"}; for(int i = 0; i < 3; i++) { puts(a[i]); } return 0; }结果：
二维数组的清零
1、局部初始化
例如：
#include <stdio.h> #include <string.h> int main(int argc, char *argv[]) { char a[3][8]={0}; for(int i = 0; i < 3; i++) { for(int j = 0; j < 8; j++) { printf("%c",a[i][j]); } } return 0; }结果：
2、循环的嵌套赋值为0例如：
#include <stdio.h> #include <string.h> int main(int argc, char *argv[]) { char a[3][8]={"hello","world","nihao"}; for(int i = 0; i < 3; i++) { for(int j = 0; j < 8; j++) { memset(a,0,sizeof(a)); printf("%c",a[i][j]); } } return 0; }结果：
3、memset例如：
#include <stdio.h> #include <string.h> int main(int argc, char *argv[]) { char a[3][8]={"hello","world","nihao"}; for(int i = 0; i < 3; i++) { for(int j = 0; j < 8; j++) { memset(a,0,sizeof(a)); printf("%c",a[i][j]); } } return 0; }结果：
扫一扫
1120
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
