6.C语言 二维数组

1.什么是二维数组？

就是数组中保存的元素都是一维数组，我们就称之为二维数组

2.二维数组的定义格式

元素类型  数组名称[一维数组的组数][一维数组中存储的元素个数]

一维数组的个数：代表二维数组中可以存储元素的个数

3.如何操作二维数组？

数组名称[索引];

取出二维数组中对应索引的一维数组

数组名称[索引][索引];

需求：要求定义变量保存用户的年龄

需求：要求定义变量保存一个班级用户的年龄

需求：要求定义变量保存两个班级用户年龄

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int ages[2][4]={
        {18,19,24,21},
        {17,15,19,20}
    };
    //取出二维数组中的每一个一维数组
    for(int i=0;i<2;i++)
    {
        //2.再从每一个一维数组中取出一维数组中的元素
        for(int j=0;j<3;j++)
        {
            printf("ages[%i][%i]=%i\n",i,j,ages[i][j]);
        }
    }
    return 0;
}

 

---

二维数组初始化

1.二维数组的初始化

1.1定义的同时初始化

1.2先定义再初始化

1.定义的同时初始化

1.1定义的同时完全初始化

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

1.2定义的同时部分初始化

    int nums[2][3] = {{1,3,5}};

1.3定义的同时初始化的注意点

如果在定义的同时初始化，那么一维数组的个数可以省略

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

如果在定义的同时初始化，那么一维数组元素的个数不能省略（不然程序就会报错！！！！）

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

如果在定义的同时初始化，那么一维数组的{}可以省略

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

---

二维数组存储细节

1二维数组的存储细节

和一维数组一模一样

1.1分配存储空间从内存地址大的开始分配

1.2数组名对应的是占用存储空间最小的地址

1.3给元素分配存储空间从占用存储空间内存地址小的开始分配

 

---

二维数组和函数

1.基本数据类型和函数

在函数内修改形参，不会影响到外界实参

2.一维数组和函数

在函数内修改形参，会影响到外界实参

3.二维数组和函数

在函数内修改形参，会影响到外界实参 

总结：

以后要想知道在函数中修改形参会不会影响到外界的实参，是不是看一下传递的是不是地址就可以

如果传递的是地址，那么在函数内修改形参，会影响到外界的实参

 

 

---

迷宫游戏-地图打印

 对上面进行改进

求出其行数，列数

 int row = sizeof(map)/sizeof(map[0]);
 int column = sizeof(map[1]);

 

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    /*
    ######
    #O #
    # ## #
    #  # #
    ##   #
    ######
    */
    char map[6][6]={
    {'#','#','#','#','#','#'},
    {'#','R',' ','#',' ',' '},
    {'#',' ','#','#',' ','#'},
    {'#',' ',' ','#',' ','#'},
    {'#','#',' ',' ',' ','#'},
    {'#','#','#','#','#','#'}
    };
    int row = sizeof(map)/sizeof(map[0]);
    int column = sizeof(map[1]);
    //2.遍历二维数组，打印地图
    printMap(map,row,column);
    return 0;
}
/** \brief printfMap 用于打印地图
 *
 * \param  map       需要打印的二维数组
 * \param  row       二维数组的行数（也就是有多少个一维数组）
 * \param  col       二维数组的列数（也就是一维数组有多少个元素） 
 *  \return              
 *
 */     

void printMap(int value[6][6],int row,int col)
{
     for(int i=0;i<row;i++)
    {
        for(int j=0;j<col;j++)
        {
            printf("%c",map[i][j]);
        }
        printf("\n");
    }
}

---

下一步：请输入w、a、s、d其中一个字符，控制小人走出迷宫

迷宫游戏-获取行走方向

统一将字母转化成小写

 ch = ch + ('a'-'A');

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    char map[6][6]={
    {'#','#','#','#','#','#'},
    {'#','R',' ','#',' ',' '},
    {'#',' ','#','#',' ','#'},
    {'#',' ',' ','#',' ','#'},
    {'#','#',' ',' ',' ','#'},
    {'#','#','#','#','#','#'}
    };
    int row = sizeof(map)/sizeof(map[0]);
    int column = sizeof(map[1]);
    //2.遍历二维数组，打印地图
    printMap(map,row,column);
    //3.提示用户输入数据
    char ch = getDirection();
    lowerCase(getDirection());
    printf("ch=%c\n",ch);
    return 0;
}
//在企业开发中，封装函数一定要遵守单一原则
//一个函数只做一件事情
/** \brief  lowerCase 将大写字母转换为小写字母 
 *
 *  \param  ch        需要转换的字母
 *  \return           转换之后的字母
 *
 */     

char lowerCase(char ch)
{
    //1.判断是否是大小字母
    if(ch >= 'A' && ch <= 'Z')
    {
        return ch + ('a'-'A');
    }
    return ch;
}
/** \brief   getDirection 获取行走的方向
 *
 *  \return  获取到的方向 
 *
 */     

char getDirection()
{
     //3.提示用户输入数据
    printf("请输入w a s d其中一个字符，控制小人走出迷宫\n");
    //4.定义变量保存用户输入的数据
    char ch;
    //5.接收用户输入的数据
    scanf("%c",&ch);
    //统一将字母转换为小写
    ch=lowerCase(ch);
    return ch;
}
/** brief printfMap 用于打印地图
 *
 *  param  map       需要打印的二维数组
 *  param  row       二维数组的行数（也就是有多少个一维数组）
 *  param  col       二维数组的列数（也就是一维数组有多少个元素）
 */

void printMap(char value[6][6],int row,int col)
{
     for(int i=0;i<row;i++)
    {
        for(int j=0;j<col;j++)
        {
            printf("%c",value[i][j]);
        }
        printf("\n");
    }
}

---

迷宫游戏-人物行走

4.让小人动起来
4.1定义一个变量保存小人当前位置

#include <stdio.h>
#include <stdlib.h>
char lowerCase(char ch);
char getDirection();
void move(char ch,char map[6][6]);
void printMap(char value[6][6],int row,int col);
int startRow = 1;
int startCol = 1;
int main(void)
{
    char map[6][6]={
    {'#','#','#','#','#','#'},
    {'#','R',' ','#',' ',' '},
    {'#',' ','#','#',' ','#'},
    {'#',' ',' ','#',' ','#'},
    {'#','#',' ',' ',' ','#'},
    {'#','#','#','#','#','#'}
    };
    int row = sizeof(map)/sizeof(map[0]);
    int column = sizeof(map[1]);
    //2.遍历二维数组，打印地图
    printMap(map,row,column);
    //3.提示用户输入数据
    char ch = getDirection();
    lowerCase(ch);
    //4.让小人动起来
    //4.1定义一个变量保存小人当前位置
    //4.2判断用户输入的反向
    move(ch,map);
    printMap(map,row,column);
    return 0;
}
//在企业开发中，封装函数一定要遵守单一原则
//一个函数只做一件事情
void move(char ch,char map[6][6])
{
     switch(ch)
    {
        case 'w':printf("向上走\n");
        if(map[startRow-1][startCol] != '#')
        {
            //清空当前的位置
            map[startRow][startCol] = ' ';
            //让上一行变成小人
            map[startRow-1][startCol]='R';
            //修改小人当前的位置变成为行走之后的位置
            startRow=startRow-1;
        }
        break;

        case 's':printf("向下走\n");
        if(map[startRow+1][startCol] != '#')
        {
            //清空当前的位置
            map[startRow][startCol] = ' ';
            //让上一行变成小人
            map[startRow+1][startCol]='R';
            //修改小人当前的位置变成为行走之后的位置
            startRow=startRow+1;
        }
        break;

        case 'a':printf("向左走\n");
        if(map[startRow][startCol-1] != '#')
        {
            //清空当前的位置
            map[startRow][startCol] = ' ';
            //让前一列变成小人
            map[startRow][startCol-1]='R';
            //修改小人当前的位置变成为行走之后的位置
            startCol=startCol-1;
        }
        break;

        case 'd':printf("向右走\n");
        if(map[startRow][startCol+1] != '#')
        {
            //清空当前的位置
            map[startRow][startCol] = ' ';
            //让一行变成小人
            map[startRow][startCol+1]='R';
            //修改小人当前的位置变成为行走之后的位置
            startCol=startCol+1;
        }
        break;

        default: printf("没有这个方向\n"); break;
    }
}

char lowerCase(char ch)
{
    //1.判断是否是大小字母
    if(ch >= 'A' && ch <= 'Z')
    {
        return ch  += ('a'-'A');
    }
}

char getDirection()
{
     //3.提示用户输入数据
    printf("请输入w a s d其中一个字符，控制小人走出迷宫\n");
    //4.定义变量保存用户输入的数据
    char ch;
    //5.接收用户输入的数据
    scanf("%c",&ch);
    //统一将字母转换为小写
    ch=lowerCase(ch);
    return ch;
}

void printMap(char value[6][6],int row,int col)
{
     for(int i=0;i<row;i++)
    {
        for(int j=0;j<col;j++)
        {
            printf("%c",value[i][j]);
        }
        printf("\n");
    }
}

---

迷宫游戏-连续行走

#include <stdio.h>
#include <stdlib.h>
char lowerCase(char ch);
char getDirection();
void move(char ch,char map[6][6]);
void printMap(char value[6][6],int row,int col);
int startRow = 1;
int startCol = 1;
int endRow = 1;
int endCol = 5;
int main(void)
{
    char map[6][6]={
    {'#','#','#','#','#','#'},
    {'#','R',' ','#',' ',' '},
    {'#',' ','#','#',' ','#'},
    {'#',' ',' ','#',' ','#'},
    {'#','#',' ',' ',' ','#'},
    {'#','#','#','#','#','#'}
    };
    int row = sizeof(map)/sizeof(map[0]);
    int column = sizeof(map[1]);
    //2.遍历二维数组，打印地图
    printMap(map,row,column);
    //3.提示用户输入数据
    do{
        char ch = getDirection();
    //4.让小人动起来
    //4.1定义一个变量保存小人当前位置
    //4.2判断用户输入的反向
        move(ch,map);
        printMap(map,row,column);
        if(startCol==endCol&&startRow == endRow)
        {
            break;
        }
    }while(1);
    printf("游戏结束\n");
    return 0;
}
//在企业开发中，封装函数一定要遵守单一原则
//一个函数只做一件事情
void move(char ch,char map[6][6])
{
     switch(ch)
    {
        case 'w':printf("向上走\n");
        if(map[startRow-1][startCol] != '#')
        {
            //清空当前的位置
            map[startRow][startCol] = ' ';
            //让上一行变成小人
            map[startRow-1][startCol]='R';
            //修改小人当前的位置变成为行走之后的位置
            startRow=startRow-1;
        }
        break;

        case 's':printf("向下走\n");
        if(map[startRow+1][startCol] != '#')
        {
            //清空当前的位置
            map[startRow][startCol] = ' ';
            //让上一行变成小人
            map[startRow+1][startCol]='R';
            //修改小人当前的位置变成为行走之后的位置
            startRow=startRow+1;
        }
        break;

        case 'a':printf("向左走\n");
        if(map[startRow][startCol-1] != '#')
        {
            //清空当前的位置
            map[startRow][startCol] = ' ';
            //让前一列变成小人
            map[startRow][startCol-1]='R';
            //修改小人当前的位置变成为行走之后的位置
            startCol=startCol-1;
        }
        break;

        case 'd':printf("向右走\n");
        if(map[startRow][startCol+1] != '#')
        {
            //清空当前的位置
            map[startRow][startCol] = ' ';
            //让一行变成小人
            map[startRow][startCol+1]='R';
            //修改小人当前的位置变成为行走之后的位置
            startCol=startCol+1;
        }
        break;

        default: printf("没有这个方向\n"); break;
    }
}

char lowerCase(char ch)
{
    //1.判断是否是大小字母
    if(ch >= 'A' && ch <= 'Z')
    {
        return ch  += ('a'-'A');
    }
}

char getDirection()
{
     //3.提示用户输入数据
    printf("请输入w a s d其中一个字符，控制小人走出迷宫\n");
    //4.定义变量保存用户输入的数据
    char ch;
    //5.接收用户输入的数据
    scanf("%c",&ch);
    //清空输入缓冲区
    setbuf(stdin,NULL);
    //统一将字母转换为小写
    ch=lowerCase(ch);
    return ch;
}

void printMap(char value[6][6],int row,int col)
{
    //清空屏幕
    system("cls");
     for(int i=0;i<row;i++)
    {
        for(int j=0;j<col;j++)
        {
            printf("%c",value[i][j]);
        }
        printf("\n");
    }
}