• c15--二位数组


    //
    //  main.c
    //  day08
    
    #include <stdio.h>
    
    int main(int argc, const char * argv[]) {
        
        /*
        int score =  99;
        int score2 = 88;
        int scores[88] = {1, 3, 5, 7};
        元素类型 数组名称[元素个数];
        */
        /*
    //                    0, 1, 2, 3
        int scores[88] = {1, 3, 5, 7};
        int scores2[88] = {2, 3, 5, 7};
        int scores3[88] = {1, 9, 5, 7};
        */
        /*
         二维数组: 数组中的每一个元素又是一个数组, 那么这个数组就称之为二维数组
         元素类型 数组名称[一维数组的个数][每个一维数组的元素个数];
         元素类型 数组名称[行数][列数];
         
         元素类型: 说明二维数组中每个一维数组存储什么类型的数据
         一维数组的个数: 说明二维数组有多少个元素
         每个一维数组的元素个数 :  说明二维数组中每一个一维数组的元素个数
         */
        int scoress[3][5] =
        {
            {1, 3, 5, 7, 9}, // 0 // 每一个一维数组都是二维数组的一个元素
            {2, 4, 6, 8, 10},// 1
            {1, 2, 3, 4 , 5} // 2
        };
        
        
        char names[2][3] =
        {
    //        0    1    2
            {'l', 'n', 'j'}, // 0
            {'x', 'm', 'g'} // 1
        };
        // 如何获取二维数组中的一维数组的元素的值
        printf("%c
    ", names[0][0]);
        
        // 如何遍历二维数组
        // 思路: 1.取出二维数组的每一个元素(取出二维数组中的一维数组)
        //       2.遍历一维数组
        
        for (int i = 0; i < 2; i++) { // 0 , 1
            // 1.取出一维数组
    //        names[i];
            for (int j = 0; j < 3; j++) { // 0 , 1 , 2
                printf("name[%i][%i] = %c
    ", i, j, names[i][j]);
            }
        }
        return 0;
    }
    //
    //  main.c
    //  二维数组注意点
    //
    //  Created by xiaomage on 15/6/12.
    //  Copyright (c) 2015年 xiaomage. All rights reserved.
    //
    
    #include <stdio.h>
    
    int main(int argc, const char * argv[]) {
        // 1.二维数组的多种初始化方式
        // 1.定义的同时初始化
        int names[2][3] =
        {
            {'l', 'n', 'j'},
            {'x', 'm', 'g'}
        };
        // 2.先定义再初始化
        int names2[2][3];
        names2[0][0] = 'l';
        names2[0][1] = 'n';
        names2[0][2] = 'j';
        
        names2[1][0] = 'x';
        names2[1][1] = 'm';
        names2[1][2] = 'g';
        
        
        // 3.完全初始化
        int names3[2][3] =
        {
            {'l', 'n', 'j'},
            {'x', 'm', 'g'}
        };
        
        // 4.不完全初始化
        int names4[2][3] =
        {
            {'l', 'n'},
        };
        
        // 5.省略元素个数的两种写法
        // 明确的告诉二维数组, 我们有2个一维数组
        char names5[2][3] =
        {
            'l', 'n', 'j',
            'x', 'm', 'g'
        };
        char names15[2][3] =
        {
            'l', 'n', 'j',
            'x', 'm'
        };
        
        // 没有告诉二维数组我们有几个一维数组
        // 如果在"定义的同时"进行初始化, 那么一位数组的个数可以省略 
        系统会自动根据每一个一维数组能够存放多少个元素, 自动根据初始化的值推断出二维数组中一共有多少个元素(多少个一维数组)
        char names6[][3] =
        {
            'l', 'n', 'j',
            'x', 'm', 'g',
            'n', 'b'
        };
        
        // 6.错误写法
        // 注意点: 每个一维数组的元素个数不能省略
        /*
        int names7[2][] =
        {
            {'l', 'n', 'j'},
            {'x', 'm', 'g'}
        };
         */
        /*
        // 搞不清楚应该分配多大的存储空间, 以及搞不清楚应该把哪些数据赋值给第一个数组, 以及哪些数据赋值给第二个数组
        int names7[2][] =
        {
            'l', 'n', 'j',
            'x', 'm', 'g'
        };
         */
        
        return 0;
    }
    //
    //  main.c
    //  二维数组和函数
    //
    //  Created by xiaomage on 15/6/12.
    //  Copyright (c) 2015年 xiaomage. All rights reserved.
    //
    
    #include <stdio.h>
    void change(int nums[]);
    void change2(char names[2][3]);
    void change3(char values[]);
    void change4(char value);
    
    int main(int argc, const char * argv[]) {
        
        int nums[2] = {1, 2};
        // 数组的名称就是数组的地址,保存的是数组第0个元素的地址,
        // &nums == nums == &nums[0]
        change(nums);
        printf("nums[0] = %i
    ", nums[0]);
        
        
        char names[2][3] =
        {
            {'l', 'n', 'j'},
            {'x', 'm', 'g'}
        };
    //    &names == names == &names[0] ==  &names[0][0] , names就是数组的地址 , 都是一样的。
        printf("&names = %p
    ", &names);
        printf("names = %p
    ", names);
        printf("&names[0] = %p
    ", &names[0]);
        printf("&names[0][0] = %p
    ", &names[0][0]);
        
    //  二维数组名称作为函数参数传递, 是传递的地址
        change2(names);
        //names[0] == 一维数组
        change3(names[0]);
        
        // names[0][0] == 一维数组的一个元素 == 值
        change4(names[0][0]);
        
        printf("names[0][0] = %c
    ", names[0][0]);
        return 0;
    }
    
    // 基本数据类型
    void change4(char value)
    {
        value = 'E';
         printf("我执行了
    ");
    }
    
    // 以后只要看到函数的参数是一个数组, 那么就是地址传递
    // 在函数中修改形参的值会影响到参数
    void change3(char values[])
    {
        values[0] = 'Q';
         printf("我执行了
    ");
    }
    
    void change2(char values[2][3])
    {
        values[0][1] = 'w';
        printf("我执行了
    ");
    }
    
    // 数组作为函数的参数传递, 修改形参的值会影响到实参
    void change(int nums[])
    {
        nums[0] = 998;
        printf("我执行了
    ");
    }
  • 相关阅读:
    第三次作业
    第二次作业
    第一次作业
    第五次作业
    第四次作业
    第三次作业
    第二次作业
    随笔
    第五次作业
    第四次作业
  • 原文地址:https://www.cnblogs.com/yaowen/p/7384536.html
Copyright © 2020-2023  润新知