C语言基础_5

一、一维字符数组
    1、说明形式
    存储类型 char 数组名[元素个数];
    
    注意：
    存储类型 、数组名及元素个数同之前的一位数组；
    
    2、一维字符数组的初始化
        1> 单个元素赋值
            eg：
            char ch[10] = {'a','p','p','l','e','o','r','a','n','g'};
            char ch1[10] = {'h','e','l','l','o'}; //未赋值的元素系统赋'\0', 即ch[5]、ch[6]、ch[7]、ch[8]、ch[9]的值是'\0'
            char ch2[] = {'h','e','l','l','o'};//sizeof(ch2)值为5
        2> 字符串赋值
            eg:
            char ch[10] = {"hello"};
            char ch1[10] = "hello";
            char ch2[] = "hello"; //sizeof(ch2)的值为6
            
            注意:
             系统自动会在字符串末尾加'\0' 
             用“%s”输出时,遇‘\0’结束
    3、字符串函数
        1> strlen() 函数
            头文件：
                #include <string.h>
            函数原型：
                size_t strlen(const char *s);
            函数参数：
                s:字符串的首地址
            函数功能：
                计算字符串的长度，不包括'\0'
            返回值:
                成功：字符串的长度
            eg:
            char buf[20] = "hello world";;
            int len = strlen(buf);
        
        2> strcat() 函数
            头文件：
                #include <string.h>
            函数原型：
                char *strcat(char *dest, const char *src);
            函数参数：
                dest：目标数组的数组名
                src： 源字符串的首地址
            函数功能：
                将源字符串连接到dest指向的目标数组之后
            返回值:
                成功：dest指针
                
            注意：
             1》dest指向的数组要足够大；
             2》连接之前，两串均以'\0'结束，连接之后，dest指针指向的字符串之后的'\0'被源字符串的第一个字符替换；
                连接之后，在新串末尾加'\0';
                
        3> strcpy() 函数
            头文件：
                #include <string.h>
            函数原型：
                char *strcpy(char *dest, const char *src);
            函数参数：
                dest：目标数组的数组名
                src： 源字符串的首地址
            函数功能：
                将源字符串拷贝到dest指向的目标数组中，拷贝时，将源字符串后的'\0'一同拷贝
            返回值:
                成功：dest指针
                
            注意：
             1》dest指向的数组要足够大；
             2》拷贝时，将源字符串后的'\0'一同拷贝
             3》不能使用赋值语句为一个字符数组赋值
                eg:
                    char buf[20];
                    buf = "hello"; //ERROR
                    strcpy(buf,"hello")//right

             
        strncpy() 函数
            头文件：
                #include <string.h>
            函数原型：
                char *strncpy(char *dest, const char *src, size_t n);
            函数参数：
                dest：目标数组的数组名
                src： 源字符串的首地址
                n:指定将src中的前n个字符拷贝到dest指向的目标数组中
            函数功能:
                将src中的前n个字符拷贝到dest指向的目标数组中
            返回值：
                成功：dest指针
        4> strcmp() 函数
            头文件：
                #include <string.h>
            函数原型：
                int strcmp(const char *s1, const char *s2);
            函数参数：
                s1：字符串1的首地址
                s2：字符串2的首地址
            函数功能：
                比较s1指向的字符串与s2指向的字符串的大小
            返回值:
                >0 ：     字符串1大于字符串2
                ==0：     字符串1等于字符串2 
                <0：      字符串1小于字符串2
                
            注意：
             比较时，两个字符串对应位从左向右逐个比较，直到遇到不同字符或‘\0’为止，实质是比较字符的ASCII值
        

        strncmp() 函数
            头文件：
                #include <string.h>
            函数原型：
                 int strncmp(const char *s1, const char *s2, size_t n);
            函数参数：
                s1：字符串1的首地址
                s2：字符串2的首地址
                n:指定字符串2的前n个字符与字符串1比较
            函数功能：
                比较s1指向的前n个字符与s2指向的前n字符的大小
            返回值:
                >0 ：     字符串1大于字符串2
                ==0：     字符串1等于字符串2 
                <0：      字符串1小于字符串2
             
二、二维数组    
    有两个下标的数组；
    1、说明形式
    存储类型 数据类型 数组名[行数][列数];
    eg:
    int a[3][4];
    说明：
    1> 存储类型同一维数组；
    2> 数据类型是数组中各个元素的数据类型；
    3> 数组名符合合法的标识符；
    4> 所占内存大小 = 行数*列数*sizeof(数据类型)或 sizeof(数组名)；
    5> 数组名是地址常量，不能做左值；
    6> 二维数组在内存中也是连续存储（即按行存储），是因为内存是线性的；
    
    降维分析多维数组：
    eg:
    int a[3][4];
    
    分析：
        将数组a看做是一个有3个元素的一位数组，同时，这个一位数组中的各个元素又是一个一维数组，每个一维数组有4个元素构成；

                                           a[0][0]
                            
                           a[0][1] 
                a[0]        
                                   a[0][2]
                            
                           a[0][3]
        
                           
                           a[1][0]
                           
        a               a[1]               a[1][1]

                                   a[1][2]
                 
                                   a[1][3]
                
                
                                   a[2][0]
                            
                a[2]               a[2][1] 
                        
                                   a[2][2]
                            
                                   a[2][3]
                
    2、二维数组的初始化
       按行初始化
        eg:
        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},{9,10,11,12}};//未初始化的元素系统自动赋0，即a[1][3]的值为0
       按元素排列顺序初始化
       eg:
       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}; //未初始化的元素系统自动赋0 ，即a[2][2]、a[2][3]的值为0
    
    省略行初始化
    int a[][3] = {{1,2,3},{4,5,6},{7,8,9},{10}};
    
    注意：
    二维数组的列数一定不能省略；
    
    3、二维字符数组
        char 数组名[行数][列数];
        
    注意：
        二维字符数组特性同二维数组
    
    1> 初始化
        eg:
        char ch[3][6] = {{'a','p','p','l','e'},{'o','r','a','n','g','e'},{'p','e','a','r'}};
        char ch1[3][7] = {{"apple"},{"orange"},{"pear"}};
        char ch2[3][7] = {"apple","orange","pear"};
        char ch3[][7] = {"apple","orange","pear"}; //ch3有3行