五、数组和字符串：数组、二维数组；字符数组与字符串；字符串的输入输出：scanf、puts、fputs、gets、fgets

 

数组；数组初始化
===============================================================================================
数组就是在内存中连续的相同类型的变量空间。同一个数组所有的成员都是相同的数据类型，同时所有的成员在内存中的地址是连续的。
    一个数组可以分解为多个数组元素：这些数组元素可以是基本数据类型或构造类型。
    按数组元素类型的不同，数组可分为：数值数组、字符数组、指针数组、结构数组等类别。
        int a[10];
        char s[10];
        char *p[10];

-------------------------------------------------------------------------------------------
数组名字符合标识符的书写规定(数字、英文字母、下划线)
数组名不能与其它变量名相同，同一作用域内是唯一的
方括号[]中常量表达式表示数组元素的个数
    int a[3]表示数组a有3个元素
    其下标从0开始计算，因此3个元素分别为a[0],a[1],a[2]
定义数组时[]内最好是常量，使用数组时[]内即可是常量，也可以是变量

-------------------------------------------------------------------------------------------
//数组初始化
int main(void)
{
    //数组的存储空间是连续的！
    int arr[6] = {1,2,3,4,5,6};
    printf("%x\n", arr);        //内存地址：8c71fa08    //属组的第一个元素地址就是属组的起始地址；数组名是一个地址的常量，代表数组中首元素的地址。
    printf("%x\n", &arr[0]);    //内存地址：8c71fa08
    printf("%x\n", &arr[1]);    //内存地址：8c71fa0c
    printf("%x\n", &arr[2]);    //内存地址：8c71fa0c
    printf("%p\n", &arr[3]);    //内存地址：000000128C71FA14
    printf("%p\n", &arr[4]);    //内存地址：000000128C71FA18
    printf("%p\n", &arr[5]);    //内存地址：000000128C71FA1C
    printf("%u\n", sizeof(arr));    //数组arr[6]占用内存24字节
    printf("%u\n", sizeof(arr[0]));    //数组arr[6]元组占用内存4字节
    printf("%u\n", sizeof(arr)/sizeof(arr[0]));    //数组元素个数：6

    int arr2[10] = { 1,2,3,4,5,6,7,8,9,10 };        //数组初始化方式1【常用】
    for (size_t i = 0; i < sizeof(arr2) / sizeof(arr2[0]); i++) {
        printf("%i;", arr2[i]);                //1;2;3;4;5;6;7;8;9;10;
    }

    int arr3[10] = { 1,2,3,4,5,6,7 };        //数组初始化方式2，未赋值的元素默认为0【常用】 
    //int arr3[10] = { 0 };                    //数组初始化方式2，未赋值的元素默认为0
    arr3[7] = 8;
    for (size_t i = 0; i < sizeof(arr3) / sizeof(arr3[0]); i++) {
        printf("%i;",arr3[i]);                //1;2;3;4;5;6;7;0;0;0; //1;2;3;4;5;6;7;8;0;0; 
    }

    int arr4[10] ;                    //数组初始化方式3,元素默认为随机数
    for (size_t i = 0; i < sizeof(arr4) / sizeof(arr4[0]); i++) {
        printf("%i;", arr4[i]);                //-858993460;-858993460;-858993460;-858993460;-858993460;-858993460;-858993460;-858993460;-858993460;-858993460; 
    }

    int arr5[] = { 1,2,3,4,5,6, };        //数组初始化方式4，定义数组时，可以不指定数组长度【常用】
    for (size_t i = 0; i < sizeof(arr5) / sizeof(arr5[0]); i++) {
        printf("%i;", arr5[i]);                //1;2;3;4;5;6;
    }
}

 

一维数组代码示例：数组倒序；冒泡排序
====================================================================================
//数组倒序显示
int main(void)
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int a = sizeof(arr) / sizeof(arr[0]);
    for (size_t i = a; a-1 >= 0; a--) {
        printf("%d;",arr[a-1]);        //10;9;8;7;6;5;4;3;2;1;
    }
}

-------------------------------------------------------------------------------------
//数组倒序
int main(void)
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int a = sizeof(arr) / sizeof(arr[0]);
    int aaa;
    for (size_t i = 0; i < a/2; i++) {
        aaa = arr[i];
        arr[i] = arr[a - 1 - i];
        arr[a - 1 - i] = aaa;
    }
    for (size_t j = 0; j < a; j++) {
        printf("%d;", arr[j]);
    }
}

-------------------------------------------------------------------------------------
int main(void)
{
    //冒泡排序
    int arr[] = { 1,4332,54,3,8,5,43,754,7,456,3,2,42341,6,7, };
    int len = sizeof(arr) / sizeof(arr[0]);
    int min;
    for (size_t i = 0; i < len-1; len -- ) {
        for (size_t j = 0; j < len-1; j++) {
            if (arr[j] < arr[j + 1]) {
                min = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = min;
            }
        }
    }
    for (size_t x = 0; x < sizeof(arr) / sizeof(arr[0]); x++) {
        printf("%d ", arr[x]);        //42341 4332 754 456 54 43 8 7 7 6 5 3 3 2 1
    }
}
-------------------------------------------------------------------------------------
#include <stdio.h>
//冒泡排序2
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;
}

 

二维数组；二维数组初始化
==================================================================================================
二维数组的初始化：

    1）常规初始化：
        int arr[3][5] = {{2, 3, 54, 56, 7 }, {2, 67, 4, 35, 9}, {1, 4, 16, 3, 78}};

    2) 不完全初始化：
        int arr[3][5] = {{2, 3}, {2, 67, 4, }, {1, 4, 16, 78}};  未被初始化的数值为 0 
        int arr[3][5] = {0};    初始化一个 初值全为0的二维数组
        int arr[3][5] = {2, 3, 2, 67, 4, 1, 4, 16, 78};   【少见】 系统自动分配行列。

    3）不完全指定行列初始化：
        int arr[][] = {1, 3, 4, 6, 7};  二维数组定义必须指定列值。
          int arr[][2] = { 1, 3, 4, 6, 7 };  可以不指定行值。


    int main(void)
    {
        //二维数组的初始化方法
        int arr1[3][3] = { {1,2,3}, {2,3,4}, {3,4,3}, };    //初始化方式1
        int arr2[3][4] = { {1,2,}, {2,4}, {3,4,3}, };        //初始化方式2：数组指定的元素不要超过数组的限制就可以；未赋值的元素默认为0
        int arr3[3][4] = { 0 };                                //初始化方式3，所有元素均为0
        int arr4[][4] = { {1,2,3}, {2,3,4}, };                //初始化方式4，二维数组初始化必须指定列值
    }

----------------------------------------------------------------------------------
大小：
    数组大小: sizeof(arr);
    一行大小: sizeof(arr[0])： 二维数组的一行，就是一个一维数组。
    一个元素大小:sizeof(arr[0][0])        单位：字节
    行数：row = sizeof(arr)/ sizeof(arr[0])
    列数：col = sizeof(arr[0])/ sizeof(arr[0][0])

地址合一：
    printf("%p\n", arr); == printf("%p\n", &arr[0][0]); == printf("%p\n", arr[0]);
    数组的首地址 == 数组的首元素地址 == 数组的首行地址。

 

字符数组与字符串区别；字符串初始化；字符串的输入输出：scanf、puts、fputs、gets、fgets
==============================================================================================
字符数组与字符串区别
    C语言中没有字符串这种数据类型，可以通过char的数组来替代；
    字符串一定是一个char的数组，但char的数组未必是字符串；（也就是说C的字符串是一种特殊的char数组）
    数字0(和字符‘\0’等价)结尾的char数组就是一个字符串，但如果char数组没有以数字0结尾，那么就不是一个字符串，只是普通字符数组，所以字符串是一种特殊的char的数组。

----------------------------------------------------------------------------------------------
//字符串初始化
int main()
{
    char buf[] = { 'a', 'b', 'c' };        //不指定长度, 没有0结束符，有多少个元素就有多长
    printf("buf = %s\n", buf);    //乱码

    char buf2[100] = { 'a', 'b', 'c' };    //指定长度，后面没有赋值的元素，自动补0
    char buf[1000]={“hello”};
    printf("buf2 = %s\n", buf2);

    
    char buf3[100] = { 0 };    //所有元素赋值为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);
    
    char buf8[] = "agjdslgjlsdjg";                //使用字符串初始化，编译器自动在后面补0，常用

    //'\0'后面最好不要连着数字，有可能几个数字连起来刚好是一个转义字符
    //'\ddd'八进制字义字符，'\xdd'十六进制转移字符
    // \012相当于\n
    char str[] = "\012abc";
    printf("str == %s\n", str);

    return 0;
}

----------------------------------------------------------------------------------------------
字符串的输入输出：scanf、puts、fputs、gets、fgets
int main(void)
{    
    //scanf、gets  都是不安全的函数
    //scanf函数
    char str[100];
    printf("input string1 : \n");
    scanf("%s", str);//scanf(“%s”,str)默认以空格分隔
    printf("output:%s\n", str);

    //puts函数：标准设备输出s字符串，在输出完成后自动输出一个'\n'。
    //fputs函数：将str所指定的字符串写入到stream指定的文件中， 字符串结束符 '\0'  不写入文件。
    puts("hello wrold");            //输出到屏幕，自动换行
    printf("hello world");            //输出结果：无换行
    fputs("hello world", stdout);    //输出结果：无换行
    
    //strlen函数：计算指定指定字符串s的长度，不包含字符串结束符‘\0’
    char str0[] = "hello world";
    printf("str length is %lld\n", sizeof(str0));    //str length is 12
    printf("str length is %lld\n", strlen(str0));    //str length is 11;strlen碰到\0结束
    
    //gets函数：从标准输入读入字符，并保存到s指定的内存空间，直到出现换行符或读到文件结尾为止。
    //char str1[100];
    //printf("请输入str1: ");
    //gets(str1);
    //printf("str1 = %s\n", str1);

    //fgets函数：从stream指定的文件内读入字符，保存到s所指定的内存空间，直到出现换行字符、读到文件结尾或是已读了size - 1个字符为止，最后会自动加上字符 '\0' 作为字符串结束。
    char str2[100];
    printf("请输入str2: ");
    fgets(str2, sizeof(str2), stdin);        //fgets可以从文件读取内容；此处stdin表示从键盘获取输入
    printf("str2 = \"%s\"\n", str2);
}


//scanf接收'空格'
    char arr[1000];
    //scanf("%[^\n]", arr);
    scanf("%[^\n]s", arr);    //有没有s都可以？？？？
    printf("%s", arr);

gets(str)与scanf(“%s”,str)的区别：
    gets(str)允许输入的字符串含有空格
    scanf(“%s”,str)不允许含有空格

字符串数组初始化

char str[] = "hello"; //方式1
char str[] = {'h','e','l','l','o','\0',}; //方式2
char str[100] = {'h','e','l','l','o',}; //方式3，默认为'\0'
char *str = "hello"; //方式4

char *str = {'h','e','l','l','o','\0',}; //这种方式不允许
char str[] = {'h','e','l','l','o',}; //这是字符数组，不是字符串！！！！！

 

//字符串拼接
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;
}