数组和字符串
概述
程序设计中，为了方便处理数据，把具有相同数据类型的若干变量按有序形式组织起来---称为数组
数组就是在内存中连续的相同类型的变量空间。
同一个数组所有的成员都是相同的数据类型，同时所有的成员在内存中的地址是连续。
数组属于构造数据类型：
1）一个数组可分解为多个数组元素：数组元素可以试基本数据类型或者构造
int a[10];
struct Stu boy[10];2)按数组元素类型的不同，分为：数值数组，字符数组，指针数组，结构数组。
int a[10];
char s[10];
char *p[10];一般，数组元素下标的个数称为维数，维数不同，可将数组分为一维数组、二维数组、三维数组等，将二维及以上的数组称多为数组。
一维数组定义和使用
1）数组名使用数组、英文字母、下划线；
2）数组名在同一作用域内是唯一的；
定义数组，[]内最好为常量，使用数组是[]内可为常量，也可为变量；
#include <stdio.h>
int main()
{
int a[10];//定义了一个数组，名字叫a，有10个成员，每个成员都是int类型
//a[0]…… a[9]，没有a[10]
//没有a这个变量，a是数组的名字，但不是变量名，它是常量
a[0] = 0;
//……
a[9] = 9;
int i = 0;
for (i = 0; i < 10; i++)
{
a[i] = i; //给数组赋值
}
//遍历数组，并输出每个成员的值
for (i = 0; i < 10; i++)
{
printf("%d ", a[i]);
}
printf("\n");
return 0;
}数组初始化
初始化：定义数组的同时进行赋值。
全局数组若不初始化，编译器将其初始化为零；局部数组若不初始化，内容为随机值；
int a[10]={0,1,2,3,4,5,6,7,8,9};//定义一个数组，初始化所有成员变量
int b[10] ={0,1,2};//初始化前三成员，后面所有元素都设置为0
int c[10]={0};//所有成员都设置为0
//[]中不定义元素个数，定义时必须初始化
int d[] = {1,2,3,4,5};//定义一个数组，有5个成员数组名
数组名的值是一个指针常量，即数组第一个元素的地址，它的类型取决于数组元素的类型，如元素为int类型，则数组名类型就是“指向int的常量指针”，但数组名并不等同于指针，只有当数组名在表达式中使用时，编译器才会为它产生一个指针常量。
数组名不作为指针常量的使用的两种场合
数组名作为sizeof操作符或单目操作符&的操作数时，sizeof返回整个数组所占的字节长度而不是指向数组的指针的长度；
取一个数组名的地址所产生的是一个指向数组的指针。
int a[10];
int b [10];
int *c;
//表达式&a[0]是一个指向数组第一个元素的指针，正是数组名本身，下面语句等同于 c =a;
c = &a[0];
b = a; //非法：不能使用赋值符把一个数组元素复制到另一个数组
a = c;//非法：表达式中，a的值是个常量，不能被修改数组名是一个地址的常量，代表数组中首元素的地址。
#include<stdio.h>
int main(){
int a[10]={1,2,3,4,5,6,7,8,9,10};//定义一个数组并初始化
printf("a=%p\n",a);
printf("&a=%p\n",&a);
printf("&a[0]=%p\n",&a[0]);
//去数组名地址是一个指向数组的指针
printf("p指向的地址：%p\n",p);
printf("q指向数组的指针：%p\n",q);
//sizeof返回整个数组所占的字节长度
int n=sizeof(a);//数组占用内存的大小，10个int类型，10*4=40
int m = sizeof(a[0]);//数组第0个元素占用内存大小
printf("sizeof(a[0])=%d\n",sizeof(a[0]));
printf("sizeof(a)=%d,sizeof(&a[0]) = %d\n",sizeof(a),sizeof(&a[0]) );
int i = 0;
printf("a[10]:");
for(i=0;i<sizeof(a)/sizeof(a[0]);i++){
printf("%d", a[i]);
}
printf("\n");
return 0;
}a=000000000062FDE0 //数组名地址
&a=000000000062FDE0 //取数组名地址，是一个指向数组的指针
&a[0]=000000000062FDE0 //数组首元地址
p指向的地址：000000000062FDD0
q指向数组的指针：000000000062FDD0
sizeof(a[0])=4 //数组首元占字节数
sizeof(a)=40,sizeof(&a[0]) = 8 //整数数组所占字节数，数组名常量指针所占字节数
a[10]:12345678910
例1求一维数组的最值
include <stdio.h>
int main()
{
int a[] = { 1, -2, 3,- 4, 5, -6, 7, -8, -9, 10 };//定义一个数组，同时初始化所有成员变量
int i = 0;
int max = a[0];
for (i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
if (a[i] > max)
{
max = a[i];
}
}
printf("数组中最大值为：%d\n", max);
return 0;
}数组排序和删除元素相对简单，但插入元素比较繁杂。
例2一维数组的逆置
#include<stdio.h>
int main()
{
int a[]={1,-2,-3,-4,5,-6,7,-8,-9,10};
int i=0;
int j =sizeof(a)/sizeof(a[0])-1;
int tmp;
while(i<j)
{
//tmp相当于个空杯，用来交换a[i],a[j]的值
tmp =a[i];
a[i]=a[j];
a[j]=tmp;
i++;//a[0]->a[1]...遍历元素
j--;//a[9]->a[8]....
}
for(i=0;i<sizeof(a)/sizeof(a[0]);i++)
{
printf("%d ",a[i]);
}
return 0;
}例3冒泡法排序
#include <stdio.h>
int main()
{
int a[] = { 1, -2, 3,- 4, 5, -6, 7, -8, -9, 10 };//定义一个数组，同时初始化所有成员变量
int i = 0;
int j = 0;
int n = sizeof(a) / sizeof(a[0]);
int tmp;
//1、流程
//2、试数
for (i = 0; i < n-1; i++)
{
for (j = 0; j < n - i -1 ; j++)//内循环的目的是比较相邻的元素，把大的放到后面
{
if (a[j] > a[j + 1])
{
tmp = a[j];
a[j] = a[j+1];
a[j+1] = tmp;
}
}
}
for (i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
return 0;
}
冒泡关键思想：
- 让数组内每个元素i（除了自身）与其他元素(i+1)比较,遇到大的就交换，直到数组内元素变成有序；
- 数组元素为n,遍历次数为n*（n-1）,时间复杂度为O（n^2）;
- 关键步骤：i从（0,n-1）,j从（i+1，n-1）,a[j]>a[j+1],swap(a[j],a[j+1]);
二维数组的定义和使用
二维数组一般形式：类型说明符 数组名[常量表达式1][常量表达式2]，
eg:int a[3][4]
定义一个三行四列的数组，数组名为a，其元素类型为整型
二维数组a是按行存放，先放a[0]行，在放a[1]、a[2]行，每行4个元素依次存放
在内存中并不存在二维数组，二维数组实际的硬件存储器是连续编址，就是内存中只有一位数组，放完一行之后顺次放入第二行
#include <stdio.h>
int main()
{
//定义了一个二维数组，名字叫a
//由3个一维数组组成，这个一维数组是int [4]
//这3个一维数组的数组名分别为a[0],a[1],a[2]
int a[3][4];
a[0][0] = 0;
//……
a[2][3] = 12;
//给数组每个元素赋值
int i = 0;
int j = 0;
int num = 0;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
{
a[i][j] = num++;
}
}
//遍历数组，并输出每个成员的值
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
{
printf("%d, ", a[i][j]);
}
printf("\n");
}
return 0;
}二维数组初始化
//分段赋值
int a[3][4] ={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
int a[3][4] =
{
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8, },
{ 9, 10, 11, 12 }
};
//连续赋值
int a[3][4] = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12 };
//可以只给部分元素赋初值，未初始化则为0
int a[3][4] = { 1, 2, 3, 4 };
//所有的成员都设置为0
int a[3][4] = {0};
//[]中不定义元素个数，定义时必须初始化
int a[][4] = { 1, 2, 3, 4, 5, 6, 7, 8};数组名
再次重复：数组名 是一个地址的常量，代表数组中首元素的地址。
#include <stdio.h>
int main()
{
//定义了一个二维数组，名字叫a
//二维数组是本质上还是一维数组，此一维数组有3个元素
//每个元素又是一个一维数组int[4]
int a[3][4] = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12 };
//数组名为数组首元素地址，二维数组的第0个元素为一维数组
//第0个一维数组的数组名为a[0]
printf("a = %p\n", a);
printf("a[0] = %p\n", a[0]);
//测二维数组所占内存空间，有3个一维数组，每个一维数组的空间为4*4
//sizeof(a) = 3 * 4 * 4 = 48
printf("sizeof(a) = %d\n", sizeof(a));
//测第0个元素所占内存空间，a[0]为第0个一维数组int[4]的数组名，4*4=16
printf("sizeof(a[0]) = %d\n", sizeof(a[0]) );
//测第0行0列元素所占内存空间，第0行0列元素为一个int类型，4字节
printf("sizeof(a[0][0]) = %d\n", sizeof(a[0][0]));
//求二维数组行数
printf("i = %d\n", sizeof(a) / sizeof(a[0]));
// 求二维数组列数
printf("j = %d\n", sizeof(a[0]) / sizeof(a[0][0]));
//求二维数组行*列总数
printf("n = %d\n", sizeof(a) / sizeof(a[0][0]));
return 0;
}结果：
a = 000000000062FE20
a[0] = 000000000062FE20
sizeof(a) = 48
sizeof(a[0]) = 16
sizeof(a[0][0]) = 4
i = 3
j = 4
n = 12练习1
#include <stdio.h>
int main()
{
//二维数组： 五行、三列
//行代表人： 老大到老五
//列代表科目：语、数、外
float a[5][3] = { { 80, 75, 56 }, { 59, 65, 71 }, { 59, 63, 70 }, { 85, 45, 90 }, { 76, 77, 45 } };
int i, j, person_low[3] = { 0 }; //定义，初始化数组
float s = 0, lesson_aver[3] = { 0 };
for (i = 0; i < 3; i++)
{
for (j = 0; j < 5; j++)
{
s = s + a[j][i];//求各科成绩总分
if (a[j][i] < 60)
{
person_low[i]++;
}
}
lesson_aver[i] = s / 5;//每个科目均分
s = 0;
}
printf("各科的平均成绩:\n");
for (i = 0; i < 3; i++)
{
printf("%.2f\n", lesson_aver[i]);
}
printf("各科不及格的人数:\n");
for (i = 0; i < 3; i++)
{
printf("%d\n", person_low[i]);
}
return 0;
}多维数组
定义格式与二维数组类似
int a[3][4][5];
定义了一个三维数组，数组的名字是a，数组的长度为3，每个数组的元素又是一个二维数组，这个二维数组的长度是4，并且这个二维数组中的每个元素又是一个一维数组，这个一维数组的长度是5，元素类型是int。
例子
#include <stdio.h>
int main()
{
//int a[3][4][5] ;//定义了一个三维数组，有3个二维数组int[4][5]
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 } } };
int i, j, k;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
{
for (k = 0; k < 5; k++)
{
//添加访问元素代码
printf("%d, ", a[i][j][k]);
}
printf("\n");
}
}
return 0;
}字符数组与字符
字符串与字符数组怎么区别
C语言中本身没有字符串数据类型，可通过字符数组来实现；
字符串一定是一个字符数组，但字符类型数组未必是字符串；
C Primer Plus指出：数组的最后一个位置显示字符\0，该字符是空字符（null character），C用它来标记字符串的结束。空字符不是数字0；它非打印字符，其ASCII码的值为(或等同于)0。该字符字符的存在意味着数组单元数必须至少要比存储的字符数多1。
char x[]="abcdefg"; //字符串
char y[]={'a','b','c','d','e','f','g'};//字符数组，编译器不会在数组末尾添加结束符
printf("sizeof(x):%d\n",sizeof(x));//8
printf("sizeof(x):%d\n",sizeof(y));//7
printf("strlen(x):%d\n",strlen(x));//7
printf("strlen(x):%d\n",strlen(y));//7以‘\0’结尾的字符数组是一个字符串，但如果字符数组没有以数字0结尾，则不是一个字符串，只是普通字符数组，所以字符串是一种特殊的字符数组。
#include<stdio.h>
int main(){
char c1[]={'c',' ','p','r','o','g'};//普通字符数组
printf("c1=%s\n", c1);//乱码，因为没有'\0'结束符；GCC4.9.3没有报错，？
//以'\0'结尾的字符数组是字符串
char c2[]={'c',' ','p','r','o','g','\0'};
printf("c2=%s\n", c2);
//字符串处理以'\0'作为结束符，后面的字符不会输出
char c3[]={'c',' ','p','r','\0','o','g'};
printf("c3=%s\n", c3);
return 0;
} 结果：
c1=c prog
c2=c prog
c3=c pr字符串与字符
字符串常量"x"与字符常量'x'不同，区别一：'x'属于基本类型（char）而"x"则属于派生类型（char数组）；
区别二："x"实际上时两个字符（'x'和空字符'\0'）组成；
字符串初始化
在通过数组来存储字符时，是否需要在结尾添加结束符呢，如果每次使用字符串时，都手动添加岂不是很麻烦？看个例子
/*praisel.c--使用不同类别的字符串*/
#include<stdio.h>
#define PRAISE "What a super marvelous name!"
int main(void){
char name[40];
printf("what^s your name?\n");
scanf("%s",name);
printf("Hello,%s. %s\n",name,PRAISE);
return 0;
}程序运行结果
what^s your name?
xiaotong Niu
Hello,xiaotong. What a super marvelous name!C Pimrer Plus指出：在初始化字符串时，需要使用一对双引号；双引号表示其中的文本是一个字符串，编译器负责插入空字符。
scanf（）开始读取输入后，会在遇到第一个空白字符空格（blank）、制表符（tab）或者换行符出停止读取。一般情况下，使用%s的scanf（）只会把一个单词而不是把整个句子作为字符出读入。(这里scanf（）输入中出现空格为什么没停止，疑问？)
#include<stdio.h>
int main(){
//不指定长度，没有0结束符，有多少个元素就有多长
char buf[]={'a','b','c'};
printf("buf=%s\n", buf);
//指定长度，后面没有赋值的元素，自动补0
char buf1[100]={'a','c','d'};
printf("buf1=%s\n", buf1);
//赋值为0
char buf2[]={0};
char buf3[50] ={'1','a','b','4','7'};
printf("buf3=%s\n", buf3);
char buf4[50]={'1','a','b',0,'4','7'};
printf("buf4=%s\n", buf4);
char buf5[50]={'1','a','b','\0','4','7'};
printf("buf5=%s\n", buf5);
//字符串初始化，编译器自动补0
char buf6[] ="asdfasdf";
//'\0'后面最好不要连着数字，有可能几个数字连起来刚好是一个转义字符
//'\ddd'八进制字义字符，'\xdd'十六进制转移字符
// \012相当于\n
char str[]="\012abc";
printf("str==%s\n", str);
return 0;
} 结果
buf=abc
buf1=acd
buf3=1ab47
buf4=1ab
buf5=1ab
str==
abc字符串的输入输出
字符串采用了'\0'标志，字符串的输入输出将变得简单
#include <stdio.h>
int main()
{
char str[100];
printf("input string1 : \n");
scanf("%s", str);//scanf(“%s”,str)默认以空格分隔
printf("output:%s\n", str);
return 0;
}字符串追加
字符串采用了'\0'标志，字符串的输入输出将变得简单方便。
#include <stdio.h>
int main()
{
char str1[] = "abcdef";
char str2[] = "123456";
char dst[100];
int i = 0;
while (str1[i] != 0)
{
dst[i] = str1[i];
i++;
}
int j = 0;
while (str2[j] != 0)
{
dst[i + j] = str2[j];
j++;
}
dst[i + j] = 0; //字符串结束符
printf("dst = %s\n", dst);
return 0;
}
函数调用
产生随机数
调用函数注意点：包含头文件、函数名与头文件声明一致、函数功能、参数类型匹配、接收返回值判断
#include <time.h>
time_t time(time_t *t);- 功能：获取当前系统时间
- 参数：常设置为NULL
- 返回值：当前系统时间, time_t 相当于long类型，单位为毫秒
#include <stdlib.h>
void srand(unsigned int seed);
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
int main()
{
time_t tm = time(NULL);//得到系统时间
srand((unsigned int)tm);//随机种子只需要设置一次即可
int r = rand();
printf("r = %d\n", r);
return 0;
}- 功能：用来设置rand()产生随机数时的随机种子
- 参数：如果每次seed相等，rand()产生随机数相等
- 返回值：无
#include <stdlib.h>
int rand(void);- 功能：返回一个随机数值
- 参数：无
- 返回值：随机数
字符串处理函数
gets()
#include <stdio.h>
char *gets(char *s);功能：从标准输入读入字符，并保存到s指定的内存空间，直到出现换行符或读到文件结尾为止。
参数：
- s：字符串首地址
- 返回值：
- 成功：读入的字符串
- 失败：NULL
char str[100];
printf("please input str");
gets(str);
printf("str=%s\n", str);gets(str)与scanf("%s", str)区别
- 前者允许输入字符串含有空格、后者不允许；
- 两者都无法知道字符串s大小，必须遇到换行符或读到文件结尾为止才接收输入，易导致字符数组越界（缓存区溢出）
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()更安全，不存在缓冲区溢出
char str[100];
printf("please input str:\n");
fgets(str,sizeof(str),stdin);
printf("str=%s\n",str);puts()
#include <stdio.h>
int puts(const char *s);功能：标准设备输出s字符串，在输出完成后自动输出一个'\n'。
参数：
- s：字符串首地址
- 返回值：成功：非负数；失败：-1
#include <stdio.h>
int main()
{
printf("hello world");
puts("hello world");
return 0;
}fputs()
#include <stdio.h>
int fputs(const char * str, FILE * stream);功能：将str所指定的字符串写入到stream指定的文件中， 字符串结束符 '\0' 不写入文件。
参数：
- str：字符串
- stream：文件指针，如果把字符串输出到屏幕，固定写为stdout；
- 返回值：成功：0；失败：-1
fputs()是puts()的文件操作版本，但fputs()不会自动输出一个'\n'。
printf("hello world");
puts("hello world");
fputs("hello world", stdout);strlen()
#include <string.h>
size_t strlen(const char *s);
功能：计算指定指定字符串s的长度，不包含字符串结束符‘\0’
参数：s：字符串首地址
返回值：字符串s的长度，size_t为unsigned int类型
char str[] = "abcdefg";
int n = strlen(str);
printf("n = %d\n", n); char str[] = "abcdefg";
int n = sizeof(str)/sizeof(str[0]);
printf("n = %d\n", n);strcpy()
#include <string.h>
char *strcpy(char *dest, const char *src);
功能：把src所指向的字符串复制到dest所指向的空间中，'\0'也会拷贝过去
参数：
- dest：目的字符串首地址
- src：源字符首地址
- 返回值：
- 成功：返回dest字符串的首地址
- 失败：NULL
注意：参数dest所指的内存空间不够大，可能会造成缓冲溢出的错误情况
char dest[20] = "123456789";
char src[] = "hello world";
strcpy(dest, src);
printf("%s\n", dest);strncpy()
#include <string.h>
char *strncpy(char *dest, const char *src, size_t n);
功能：把src指向字符串的前n个字符复制到dest所指向的空间中，是否拷贝结束符看指定的长度是否包含'\0'。
参数：
- dest：目的字符串首地址
- src：源字符首地址
- n：指定需要拷贝字符串个数
- 返回值：
- 成功：返回dest字符串的首地址
- 失败：NULL
char dest[20] ;
char src[] = "hello world";
strncpy(dest, src, 5);
printf("%s\n", dest);
dest[5] = '\0';
printf("%s\n", dest);
扫一扫
871
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
