4.C语言数组和字符串

概述

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

1. 一个数组可以分解为多个数组元素：这些数组元素可以是基本数据类型或构造类型
2. 按数组元素类型的不同，数组可分为：数值数组、字符数组、指针数组、结构数组等类别

一维数组

定义和使用

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

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

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

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

   void test5(){
    int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};//定义了一个数组，名字叫a，有10个成员，每个成员都是int类型
    //a[0]…… a[9]，没有a[10]
    int i = 0;
    for (i = 0; i < 10; i++){
         a[i] = i; //给数组赋值
    }
    //遍历数组，并输出每个成员的值
    for (i = 0; i < 10; i++){
        printf("%d \n", a[i]);
    }
   }
   

初始化

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

数组名

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

void test7(){
    int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//定义一个数组，同时初始化所有成员变量
    //a和a[0]的地址是相同的
    //数组名是一个地址的常量，代表数组中首元素的地址
    printf("a = %p\n", a);
    printf("&a[0] = %p\n", &a[0]);

    int n = sizeof(a); //数组占用内存的大小，10个int类型，10 * 4  = 40
    int n0 = sizeof(a[0]);//数组第0个元素占用内存大小，第0个元素为int，4

    for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++){
        printf("%d \n", a[i]);
    }
}

冒泡排序法

//冒泡排序法
void test8(){
    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;

    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");
}

二维数组

定义和使用

定义的一般形式：类型说明符 数组名[常量表达式1][常量表达式2]

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

1. 二维数组在概念上是二维的：其下标在两个方向上变化，对其访问一般需要两个下标
2. 在内存中存储的二维数组，二维数组实际的硬件存储器是连续编址的，也就是说内存中只有一维数组，即放完一行之后顺次放入第二行，和一维数组存放方式是一样的

初始化

void test9(){
    //分段赋值     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 b[3][4] = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12  };

    //可以只给部分元素赋初值，未初始化则为0
    int c[3][4] = { 1, 2, 3, 4  };

    //所有的成员都设置为0
    int d[3][4] = {0};
    
    //[]中不定义元素个数，定义时必须初始化
    int e[][4] = { 1, 2, 3, 4, 5, 6, 7, 8};
}

数组名

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

void test10(){
    //定义了一个二维数组，名字叫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]));

    //求二维数组行数 3
    printf("i = %d\n", sizeof(a) / sizeof(a[0]));

    // 求二维数组列数 4
    printf("j = %d\n", sizeof(a[0]) / sizeof(a[0][0]));

    //求二维数组行*列总数 12
    printf("n = %d\n", sizeof(a) / sizeof(a[0][0]));
}

字符数组与字符串

概念

1. C语言中没有字符串这种数据类型，可以通过char的数组来替代
2. 字符串一定是一个char的数组，但char的数组未必是字符串
3. 数字0(和字符‘\0’等价)结尾的char数组就是一个字符串，但如果char数组没有以数字0结尾，那么就不是一个字符串，只是普通字符数组，所以字符串是一种特殊的char的数组

void test11(){
    char c1[] = { 'c', ' ', 'p', 'r', 'o', 'g' }; //普通字符数组
    printf("c1 = %s\n", c1); //不一定为c prog
    //以‘\0’(‘\0’就是数字0)结尾的字符数组是字符串
    char c2[] = { 'c', ' ', 'p', 'r', 'o', 'g', '\0'};
    printf("c2 = %s\n", c2);
    //字符串处理以‘\0’(数字0)作为结束符，后面的'h', 'l', 'l', 'e', 'o'不会输出
    char c3[] = { 'c', ' ', 'p', 'r', 'o', 'g', '\0', 'h', 'l', 'l', 'e', 'o', '\0'};
    printf("c3 = %s\n", c3);
}

字符串的初始化

void test12(){
    //不指定长度, 没有0结束符，有多少个元素就有多长
    char buf[] = { 'a', 'b', 'c' };
    printf("buf = %s\n", buf);    //不一定为abc
    //指定长度，后面没有赋值的元素，自动补0
    char buf2[100] = { 'a', 'b', 'c' };
    printf("buf2 = %s\n", buf2);
    //所有元素赋值为0
    char buf3[100] = { 0 };
    //char buf4[2] = { '1', '2', '3' };//数组越界
    char buf5[50] = { '1', 'a', 'b', '0', '7' };
    printf("buf5 = %s\n", buf5);
    char buf6[50] = { '1', 'a', 'b', 0, '7' };
    printf("buf6 = %s\n", buf6);
    char buf7[50] = { '1', 'a', 'b', '\0', '7' };
    printf("buf7 = %s\n", buf7);
    //使用字符串初始化，编译器自动在后面补0，常用
    char buf8[] = "agjdslgjlsdjg";
    //'\0'后面最好不要连着数字，有可能几个数字连起来刚好是一个转义字符
    //'\ddd'八进制字义字符，'\xdd'十六进制转移字符
    // \012相当于\n
    char str[] = "\012abc";
    printf("str == %s\n", str);
}

常用方法

#include 

time_t  time(time_t t);

功能：获取当前系统时间

参数：常设置为NULL

返回值：当前系统时间, *time_t* 相当于long类型，单位为毫秒



#include 

void srand(unsigned int seed);

功能：用来设置rand()产生随机数时的随机种子

参数：如果每次seed相等，rand()产生随机数相等

返回值：无



#include 

int rand(void);

功能：返回一个随机数值

参数：无

返回值：随机数
    
    
#include 
char *gets(char *s);
功能：从标准输入读入字符，并保存到s指定的内存空间，直到出现换行符或读到文件结尾为止。
参数：
    s：字符串首地址
返回值：
    成功：读入的字符串
    失败：NULL
    
    
#include 
char *fgets(char *s, int size, FILE *stream);
功能：从stream指定的文件内读入字符，保存到s所指定的内存空间，直到出现换行字符、读到文件结尾或是已读了size - 1个字符为止，最后会自动加上字符 '\0' 作为字符串结束。
参数：
    s：字符串
    size：指定最大读取字符串的长度（size - 1）
    stream：文件指针，如果读键盘输入的字符串，固定写为stdin
返回值：
    成功：成功读取的字符串
    读到文件尾或出错： NULL
    
    
#include 
int puts(const char *s);
功能：标准设备输出s字符串，在输出完成后自动输出一个'\n'。
参数：
    s：字符串首地址
返回值：
    成功：非负数
    失败：-1
    
    
#include 
int fputs(const char * str, FILE * stream);
功能：将str所指定的字符串写入到stream指定的文件中， 字符串结束符 '\0'  不写入文件。 
参数：
    str：字符串
    stream：文件指针，如果把字符串输出到屏幕，固定写为stdout
返回值：
    成功：0
    失败：-1
    
    
#include 
size_t strlen(const char *s);
功能：计算指定指定字符串s的长度，不包含字符串结束符‘\0’
参数：
s：字符串首地址
返回值：字符串s的长度，size_t为unsigned int类型
    
    
#include 
char *strcpy(char *dest, const char *src);
功能：把src所指向的字符串复制到dest所指向的空间中，'\0'也会拷贝过去
参数：
    dest：目的字符串首地址
    src：源字符首地址
返回值：
    成功：返回dest字符串的首地址
    失败：NULL
    
    
#include 
char *strncpy(char *dest, const char *src, size_t n);
功能：把src指向字符串的前n个字符复制到dest所指向的空间中，是否拷贝结束符看指定的长度是否包含'\0'。
参数：
    dest：目的字符串首地址
    src：源字符首地址
    n：指定需要拷贝字符串个数
返回值：
    成功：返回dest字符串的首地址
    失败：NULL
    
    
#include 
char *strcat(char *dest, const char *src);
功能：将src字符串连接到dest的尾部，‘\0’也会追加过去
参数：
    dest：目的字符串首地址
    src：源字符首地址
返回值：
    成功：返回dest字符串的首地址
    失败：NULL
    
    
#include 
char *strncat(char *dest, const char *src, size_t n);
功能：将src字符串前n个字符连接到dest的尾部，‘\0’也会追加过去
参数：
    dest：目的字符串首地址
    src：源字符首地址
    n：指定需要追加字符串个数
返回值：
    成功：返回dest字符串的首地址
    失败：NULL
    
    
#include 
int strcmp(const char *s1, const char *s2);
功能：比较 s1 和 s2 的大小，比较的是字符ASCII码大小。
参数：
    s1：字符串1首地址
    s2：字符串2首地址
返回值：
    相等：0
    大于：>0
    小于：<0
          
          
#include 
int strncmp(const char *s1, const char *s2, size_t n);
功能：比较 s1 和 s2 前n个字符的大小，比较的是字符ASCII码大小。
参数：
    s1：字符串1首地址
    s2：字符串2首地址
    n：指定比较字符串的数量
返回值：
    相等：0
    大于： > 0
    小于： < 0
           
           
#include 
int sprintf(char *str, const char *format, ...);
功能：根据参数format字符串来转换并格式化数据，然后将结果输出到str指定的空间中，直到出现字符串结束符 '\0'  为止。
参数：
    str：字符串首地址
    format：字符串格式，用法和printf()一样
返回值：
    成功：实际格式化的字符个数
    失败： - 1
    
    
#include 
int sscanf(const char *str, const char *format, ...);
功能：从str指定的字符串读取数据，并根据参数format字符串来转换并格式化数据。
参数：
    str：指定的字符串首地址
    format：字符串格式，用法和scanf()一样
返回值：
    成功：参数数目，成功转换的值的个数
    失败： - 1
    
    
#include 
char *strchr(const char *s, int c);
功能：在字符串s中查找字母c出现的位置
参数：
    s：字符串首地址
    c：匹配字母(字符)
返回值：
    成功：返回第一次出现的c地址
    失败：NULL
    
    
#include 
char *strstr(const char *haystack, const char *needle);
功能：在字符串haystack中查找字符串needle出现的位置
参数：
    haystack：源字符串首地址
    needle：匹配字符串首地址
返回值：
    成功：返回第一次出现的needle地址
    失败：NULL
    
    
#include 
char *strtok(char *str, const char *delim);
功能：来将字符串分割成一个个片段。当strtok()在参数s的字符串中发现参数delim中包含的分割字符时, 则会将该字符改为\0 字符，当连续出现多个时只替换第一个为\0。
参数：
    str：指向欲分割的字符串
    delim：为分割字符串中包含的所有字符
返回值：
    成功：分割后字符串首地址
    失败：NULL
    
    
#include 
int atoi(const char *nptr);
功能：atoi()会扫描nptr字符串，跳过前面的空格字符，直到遇到数字或正负号才开始做转换，而遇到非数字或字符串结束符('\0')才结束转换，并将结果返回返回值。
参数：
    nptr：待转换的字符串
返回值：成功转换后整数