10-数组、字符串

一、数组的基本概念

一个int类型的变量能保存一个人的年龄，如果想保存整个班的年龄呢？

1.什么是数组

数组，从字面上看，就是一组数据的意思，没错，数组就是用来存储一组数据的

2.数组的特点

• 只能存放一种类型的数据，比如int类型的数组、float类型的数组
• 里面存放的数据称为“元素”

二、数组的定义

1.定义

• 声明数组的类型
• 声明数组的元素个数（需要多少存储空间）

2.格式

元素类型 数组名[元素个数];
比如：

int ages[3];

3.简单使用

• 简单初始化：

int ages[5] = {19, 19, 20, 21, 25};

• 元素有顺序之分，每个元素都有一个唯一的下标（索引），从0开始
• 数组元素的访问：a[i]

4.初始化

• 初始化方式

 int a[3] = {10, 9, 6};
 int a[3] = {10,9};
 int a[] = {11, 7, 6};
 int a[4] = {[1]=11,[0] = 7};

• 常见错误

 int a[];
 int[4] a;
 int a[b];
 a = {10, 11};
 a[4] = {10,9,8,5}; 

5.内存分析

• 数组存储空间的大小
• 存储空间的划分（内存的分配是从高地址到低地址进行的，但一个数组内部元素又是从低到高进行的）
• 数组名的作用，查看元素地址
• 数组越界的注意

6.其他使用

• 数组与函数参数
• 数组元素作为函数参数
• 数组作为函数参数（sizeof注意）
• 遍历数组元素
• 两种方式遍历（while循环和for循环）
• 遍历元素值和元素地址
• 字符数组的使用

7.习题

1>提示输入5个学生的成绩，算出平均分、最高分、最低分，然后输出
2>设计一个函数：int arrayMax(int a[], int count)，找出数组元素的最大值
3>设计一个函数：int arraySum(int a[], int n)，求一维数组a前n个数的和
4>设计一个函数：将一维整型数组中的元素逆序存放。比如本来是1,3,4,2，逆序存放就变成了：2，4，3，1

三、二维数组

1.什么是二维数组

• 一个数组能表示一个班人的年龄，如果想表示很多班呢？
• 什么是二维数组？int ages[3][10]; 三个班，每个班10个人
• 相当于3行10列
• 相当于装着3个一维数组
• 二维数组是一个特殊的一维数组：它的元素是一维数组。例如int a[2][3]可以看作由一维数组a[0]和一维数组a[1]组成，这两个一维数组都包含了3个int类型的元素
  二维数组

2.存储

• 存储大小
• 存储结构和顺序
• 存储地址问题

3.初始化

 int a[3][4] = {1,2,3,4,5,6};
 int a[3][4] = {{},{},{}};

• 数组元素简单访问

 int a[][5] = {3,21,31,2,32,1};

• 注意错误：

int a[3][4];
a[3] = {};

4.遍历

• 遍历所有的元素
• 遍历地址

• 使用场合：五子棋、俄罗斯方块

  
  五子棋、俄罗斯方块

四、字符串

1.什么是字符串

• 简单的字符串”itcast”
• 一个’i’是一个字符
• 很多个字符组合在一起就是字符串了

2.字符串的初始化

• char a[] = “123”; 和 char a [] = {‘1’,’2’,’3’};的区别，可以比较大小
• “123”其实是由’1’、’2’、’3’、’\0’组成
• “123”的存储分布
• 字符串的输出”%s”，’\0’是不会输出的

3.\0的作用

• 输出char a[] = {‘o’,’k’};
• 在char a[]前面搞个”mj”
• 输出”hello”
• 再输出a
• char a[] = {‘i’,’t’,’\0’,’c’};

4.常用字符串处理函数

• strlen（注意中文）

5.习题

编写一个函数char_contains(char str[],char c)，如果字符串str中包含字符c则返回数值1，否则返回数值0

五、字符串数组

1.使用场合

• 一维字符数组中存放一个字符串，比如一个名字char name[20] = "zs"
• 如果要存储多个字符串，比如一个班所有学生的名字，则需要二维字符数组，char names[15][20]可以存放15个学生的姓名(假设姓名不超过20字符)
• 如果要存储两个班的学生姓名，那么可以用三维字符数组char names[2][15][20]

2.初始化

char names[2][10] = { {'J','a','y','\0'}, {'J','i','m','\0'} };  
char names2[2][10] = { {"Jay"}, {"Jim"} };  
char names3[2][10] = { "Jay", "Jim" };

---

---

---

六、程序实现

01-char

void char_practice(void) {
    
    //0000 0000 0000 0000 0000 0000 0000 1001
    int a = 9;
    // 0100 0001
    char c = 'A';
    //printf("%c\n", 67);
    //printf("%d\n", 'D');
    //char c2 = 'A' + 33; // 98
    //printf("%c - %d \n", c2 , c2);
    
    /*
     ASCII码表
     字符   ASCII码值
     A       65
     B       66
     C       67
     */
    
    // 00000000000000 110
    int num = 6;
    // 54 = 32 + 16 + 4 + 2
    // 0011 0110
    char c2 = '6';
    printf("%d - %d\n", num, c2);
}

02-char

void char_practice_practice(void) {
    
    // 单引号''只能扩住单字节的字符
    // char c = '男'; // 错误写法
    
    //char c = "A";// 错误写法
    
    // char c = A; // 错误写法
    
    // char c = 65;
    
    // printf("%c\n", c);
    
    /*
     char c = 'A';
     switch (c) {
     case 'A':
     printf("1\n");
     break;
     case 65:
     printf("2\n");
     break;
     default:
     printf("3\n");
     break;
     }
     */
    
    // -128 ~ 127
    //char c = 655894389754367857684;
    
    //printf("%d\n", '\n');
    
    printf("\"\n");
}

03-char练习 - 如果是小写字母，就转成大写

char char_practice_practice_practice(char c) {
    
    /*
     1.说出下面程序的输出结构
     int i = 67 + '4';
     char c = 'c' - 10;
     
     printf("%d - %c\n", i, i);
     printf("%d - %c\n", c, c);
     
     2.写一个函数，将小写字母转为大写
     */
    
    // 如果是小写字母，就转成大写
    /*
     if (c >= 'a' && c< = 'z') { // ['a', 'z']
     return c - ('a'-'A');
     } else {// 如果不是小写字母，返回字母本身
     return c;
     }
     */
    
    // 如果是小写字母，就转成大写
    if (c >= 'a' && c<= 'z') { // ['a', 'z']
        return c - ('a'-'A');
    }
    // 如果不是小写字母，返回字母本身
    return c;
}

04-数组

void array_practice(void) {
    
    // 使用注意
    // 都是正确写法
    //int ages[5] = {10 , 11, 12, 67, 56};
    //int ages[5] = {10, 11};
    //int ages[5] = {[3] = 10, [4] = 11};
    //int ages[] = {10, 11, 14};
    
    // 错误写法
    // int ages[];
    
    // 错误写法
    /* 只能在定义数组的同时进行初始化
     int ages[5];
     ages = {10, 11, 12, 14};
     */
    
    // 正确写法
    // int ages['A'-50] = {10, 11, 12, 14, 16};
    //int size = sizeof(ages);
    //printf("%d\n", size);
    
    // 正确写法
    /*
     int count = 5;
     int ages[count];
     ages[0] = 10;
     ages[1] = 11;
     ages[2] = 18;
     */
    
    //printf();
    // 错误写法
    // 如果想再定义数组的同事进行初始化，数组元素个数必须是常量，或者不写
    //int ages[count] = {10, 11, 12};
    
    
    int ages[] = {10, 11, 12, 78};
    
    // 计算数组元素的个数
    int count = sizeof(ages) / sizeof(int);
    
    for (int i = 0; i < count; i++) {
        printf("ages[%d] = %d\n", i, ages[i]);
    }
}

// 数组的基本使用
void arrayUse() {
    // 数组的定义格式： 类型 数组名[元素个数];
    int ages[5] = {19, 29, 28, 27, 26};
    // 19 19 28 27 26]
    ages[1] = 29;
    
    /*
     ages[0] = 19;
     ages[1] = 19;
     ages[2] = 28;
     ages[3] = 27;
     ages[4] = 26;
     */
    
    /*
     遍历：按顺序查看数组的每一个元素
     */
    for (int i = 0; i < 5; i++) {
        printf("ages[%d] = %d\n", i, ages[i]);
    }
}

05-数组的内存存储细节 - 提示用户输入5个学生的成绩，算出平均分并且输出

void memory_storage_details_for_arrays(void) {
    
    // 提示用户输入5个学生的成绩，算出平均分并且输出
    
    // 1.定义一个数组来存储成绩
    int scores[5];
    
    // 2.提示输入成绩
    // 用来存储总分
    int sum = 0;
    for (int i = 0; i < 5; i++) {
        // 2.1 提示输入某个学生的成绩
        printf("请输入第%d个学生的成绩:\n", i + 1);
        // 2.2 存储当前学生的成绩
        scanf("%d", &scores[i]);
        // 2.3 累加成绩
        sum += scores[i];
    }
    
    // 3.计算平均分，并且输出
    printf("平均分是%f\n", sum / 5.0);
}

06-数组和函数

// 数组作为函数参数，可以省略元素个数
// 数组作为函数参数，传递是整个数组的地址，修改函数形参数组元素的值，会影响到外面的实参数组

void change(int array[]) {
    
    //printf("array==%p\n", array);
    
    array[0] = 100;
}

void change2(int n) {
    
    n = 100;
}

void arrays_and_functions(void) {
    
    int ages[6] = {10, 11, 10, 11, 10, 11};
    
    //printf("ages==%p\n", ages);
    
    change(ages);
    
    //change2(ages[0]);
    
    printf("%d\n", ages[0]);
}

07-设计一个函数，找出整型数组元素的最大值

int maxOfArray(int array[], int length) {
    
    // 数组当做函数参数传递时，会当做指针变量来使用，指针变量在64bit编译器环境下，占据8个字节
    
    //int size = sizeof(array);
    //printf("array=%d\n", size);
    
    //sizeof(array);
    
    // 1.定义一个变量存储最大值(默认就是首元素)
    int max = array[0];
    
    // 2.遍历所有元素，找出最大值
    for (int i = 1; i<length; i++) {
        
        // 如果当前元素大于max，就用当前元素覆盖max
        if (array[i] > max) {
            
            max = array[i];
        }
    }
    
    return max;
}

void finds_array_element_maximum_value(void) {
    
    int ages[] = {11, 90, 67, 150, 78, 60, 70, 89, 100};
    
    int ages2[] = {11, 90, 67, 150, 78, 60, 70, 89, 100};
    
    //int size = sizeof(ages);
    
    //printf("ages=%d\n", size);
    int max = maxOfArray(ages, sizeof(ages)/sizeof(int));
    
    printf("max = %d\n", max);
}

08-二维数组

void two_dimensional_array(void) {
    
    /*
     int ages[5] = {10, 11, 90, 89, 70};
     
     int ages2[3][5]= {
     {10, 11, 90, 89, 70},
     
     {10, 11, 90, 89, 70},
     
     {10, 11, 90, 89, 70}
     };
     */
    
    char cs[2][3];
    
    /*
     1 浅蓝色
     2 深蓝色
     3 黄色
     4 红色
     -1 没有
     */
    
    int cubes[5][5] = {
        {1, -1, -1, -1, -1},
        {1, 1, -1, 2, -1},
        {4, 1, 2, 2, 2},
        {4, 3, 3, 3, 3},
        {4, 3, 3, 3, 3}
    };
    
    /*
     1 白色
     2 黑色
     -1 没有
     */
}

09-字符串

void string_practice(void) {
    
    /*
     // 'a' 'b' 'A'
     // "jack" == 'j' + 'a' + 'c' + 'k' + '\0'
     char name[10] = "roseq8030\n";
     // 把数组传入，仅仅是个警告
     printf(name);
     printf(name);
     printf(name);
     printf("358394580410");
     */
    
    /*
    // 字符串的一个初始化
    // \0的ASCII码值是0
    // 都是字符串
    char name[8] = "it";
    char name2[8] = {'i', 't', '\0'};
    char name3[8] = {'i', 't', 0};
    char name4[8] = {'i', 't'};
    printf("name:%s\nname2:%s\nname3:%s\nname4:%s\n", name,name2,name3,name4);
    
    // 不算是一个字符串（只能说是一个字符数组）
    char name5[] = {'i', 't'};
    printf("name5:%s\n", name5);
     */
    
    //char name[] = {'z', 'h', 'a', 'n', 'g', ' ', 's', 'a', 'n', '\0'};
    char name[] = "zhang san";
    name[3] = 'H';
    int size = sizeof(name);
    printf("%d\n", size);
    
    printf("我的名字叫%s\n", name);
}

10-字符串注意

void string_notice_practice(void) {
    
    /*
     \0的作用
     1.字符串结束的标记
     2.printf("%s", name2);
     会从name2这个地址开始输出字符，直到遇到\0为止
     */
    
    char name[] = "zha\0ng san";
    char name2[] = {'o', 'k'};
    printf("name:%s\n", name);
    printf("name2:%s\n", name2);
    printf("name2[1]:%s\n", &name2[1]);
}

11-strlen

void strlen_practice(void) {
    
    /*
     strlen函数：计算字符串长度
     1.计算的是字符数，并不是字数。一个汉字算作3个字符
     2.计算的字符不包括\0
     3.从某个地址开始数字符的个数，直到遇到\0为止
     */
    
    // strlen函数声明在string.h文件中
    
//    int size = strlen("张三zhas");
//    printf("%d\n", size);
    
    /*
    char name[] = "zhang san";
    char name2[] = {'0', '\0', '6'};
    int size = strlen(name2);
    printf("%d\n", size);
     */
    
    char name[] = "zhang san";
    printf("%s\n", name);
    printf("%c\n", name[3]);
}

12-字符串练习 - 编写一个函数char_contains(char str[],char c)，

// 如果字符串str中包含字符c则返回数值1，否则返回数值0

// 可读性 -> 性能 -> 精简（重构）
int char_contains(char str[], char c);
void string_practice_practice(void) {
    
    int result = char_contains("zha8ng san", '8');
    printf("%d\n", result);
}

/*
int char_contains(char str[], char c) {
    
    // 1.遍历整个字符串
    for (int i = 0; i < strlen(str); i++) {
        
        // 如果发现某个字符等于参数c，直接返回1，退出函数
        if ( str[i] == c ) {
            return 1;
        }
    }
    
    // 2.说明str里面不包含字符c
    return 0;
}

int char_contains(char str[], char c) {
    
    int i = 0;
    
    // 1.遍历整个字符串
    while ( str[i] != '\0' ) {
        // 如果发现某个字符等于参数c，直接返回1，退出函数
        if (str[i] == c) {
            return 1;
        }
        
        i++;
    }
    
    // 2.说明str里面不包含字符c
    return 0;
}

int char_contains(char str[], char c) {
    
    int i = -1;
    
    // 1.遍历整个字符串
    while ( str[++i] ) {
        // 如果发现某个字符等于参数c，直接返回1，退出函数
        if (str[i] == c) {
            return 1;
        }
    }
    
    // 2.说明str里面不包含字符c
    return 0;
}
 */

int char_contains(char str[], char c) {
    
    int i = -1;
    
    // 1.遍历整个字符串
    while ( str[++i] != c && str[i] != '\0' ) ;
    
    //return str[i] == '\0' ? 0 : 1;
    return str[i] != '\0';
}

13-字符串数组

void string_array(void) {
    
    char name[] = "jack";
    char name1[] = "rose";
    char name2[] = "jim";
    char name3[] = "jake";
    
    printf("name:%s\nname1:%s\nname2:%s\nname3:%s\n", name,name1,name2,name3);
    
    char names[2][10]= {"jack", "rose"};
    
    printf("names[0]:%s\n", names[0]);
    printf("names[0][3]%c\n", names[0][3]);
    
    char names2[2][10] =
    {
        {'j', 'a', 'c', 'k', '\0'},
        {'r', 'o', 's', 't', '\0'}
    };
    
    printf("names2[0]:%s\n", names2[0]);
    printf("names2[0][3]%c\n", names2[0][3]);
}