1、一维数组的创建和初始化

1.1、数组的创建

数组是一组相类型元素的集合。

数组的创建方式：

type_t arr_name [const_n];

//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小。

1.2、数组的初始化

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。

//不完全初始化，剩余的元素默认初始化位0
int arr1[10] = {1,2,3};

int arr2[] = {1,2,3};

int arr3[5] = {'1','2','3','4','5'};

char arr4[3] = {'a','98','c'};

char arr5[10] = {'a','b','c'};

char arr6[10] = "abcdef";

arr5和arr6存放元素的效果一样，但是有些细节还是不相同的：

arr5：是人为放进去：'a','b','c'，然后后面补充0。

arr6：是认为放进去：a','b','c','\0'，然后后面补充0。

那为什么说效果一样呢？因为'\0'的ASCII值为0，所以数组里面存放的是'\0'，其实是以它的ASCII值0存放的。

重点是：字符串有'\0'，而字符没有'\0'。

1.3、一维数组的使用

int arr[10] = {0};                 //数组的不完全使用

int sz = sizeof(arr) / sizeof(arr[0]);      //计算数组元素的个数

arr[i]       //数组的访问。

总结：

数组是使用下标来访问的，下标是从0开始的。
数组的大小是可以通过计算得到的。

1.4、一维数组在内存中的存储

看代码：

#include <stdio.h>
int main()
{
    int i = 0;
    int arr[10] = { 0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    for (i = 1; i <= 9; i++)
    {
        printf("&arr[%d]：%p\n", i, &arr[i]);
    }
    return 0;
}

输出：

可以发现：每一个元素地址值相差为4，因为一个int类型的数据占据4个字节。

随着数组下标的增长，元素的地址，也有规律的递增。

得出结论：数组在内存中是来逆序存放的。

1.5、数组的类型

我们知道一个变量是有类型的，比如：

int a = 0;

char u = 'a';

那数组有没有类型呢？答案：有！

int arr[10] = {0};

//int [10]就是arr数组的类型，[]里面的10，也是类型的一部分，不能省略。

【补充：】sizeof()和strlen的用法

#include <stdio.h>
#include <string.h>
int main()
{
    char str[] = "hello bit";
    printf("%d %d", sizeof(str), strlen(str));
    return 0;
}

输出：

分析：

sizeof()是一个操作符，是用来计算变量、类型、数组等所占空间大小的。
strlen()是一个库函数，是专门求字符串长度的，只能针对字符串，从参数给定的地址向后一直找'\0'或者说统计'\0'之前出现的字符个数。

首先：str数组中存放：h e l l o _ b i t \0

注意str数组中是存放了10个元素的，一定一定要想到'\0'也是个元素，它也是存放在str数组中的，他也算一个元素。

因此str数组中存放了10个元素，又因为全部都是char类型的，所以str数组大小一共10字节。因为sizeof()输出为10。

而strlen()是统计字符串个数的，并且只统计'\0'之前的字符个数。因为'\0'之前有9个元素，所以strlen()输出为9。

2、二维数组的创建和初始化

2.2、二维数组的创建

//数组创建
int arr[3][4];      //表示这个二维数组是3行4列的，列就是一行放几个元素，像一个表格一样。二维数组本质上就是多行的数组

char arr[3][5];

double arr[2][4];

2.3、二维数组的初始化

//3行4列，前四个元素放在第一行，中间四个元素放在第二行，最后四个元素放在第三行
int arr[3][4] = {1,2,3,4,2,3,4,5,3,4,5,6};


//前四个元素放在第一行，中间四个元素放在第二行，最后两个元素放在第三行然后剩余的两个位置用0补充
int arr[3][4] = {1,2,3,4,2,3,4,5,3,4};


//将1,2元素放在第一行剩余补0，0，将3,4元素放在第二行剩余补0，0，将4,5元素放在第三行剩余补0，0
int arr[3][4] = {
  
  {1,2},{3,4},{4,5}};


//只能省略行，不能省略列
int arr[][4] = {
  
  {1,2,3,4},{1,2}};

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

2.3、二维数组的使用

行下标是从0开始，列下标也是从0开始，先确定行，在确定列。

#include <stdio.h>
int main()
{
    int arr[3][4] = { 1,2,3,4,2,3,4,5,3,4,5,6 };
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        int j = 0;
        for (j = 0; j < 4; j++)
        {
            printf("%d ", arr[i][j]);  //打印元素
            scanf("%d", &arr[i][j]);   //输入元素
        }
        printf("\n");
    }
    return 0;
}

输出：

补充：如何把二维数组看作为一维数组

我们可以把二维数组的每一行看作是一维数组中的元素，然后把arr[0]，arr[1]，arr[2]看作是每一行的数组名。

2.4、二维数组在内存中的存储

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
    int arr[3][4] = { 1,2,3,4,2,3,4,5,3,4,5,6 };
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        int j = 0;
        for (j = 0; j < 4; j++)
        {
            printf("arr[%d][%d]：%p\n", i, j, arr[i][j]);
        }
    }
    return 0;
}

输出：

可以发现其实二维数组和一维数组在空间中存储的形式是一样的，都是连续的空间。

//以存储空间的角度来看，以下是等价的：
int arr[3][4] = { 1,2,3,4,2,3,4,5,3,4,5,6 };  =  int arr[12] = {1,2,3,4,2,3,4,5,3,4,5,6}

3、数组越界

数组的下标是有范围限制的。

数组的下标规定是从0开始，如果数组有n个元素，最后一个元素的下标就是n-1。

所以数组的下标如果是小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。

C语言本身是不做数组下标的越界检查，编译器也不一定会报错，但是编译器不报错，并不意味着程序就是正确的。

所以程序员写代码时，最好自己做好越界的检查。

4、数组作为函数参数

往往我们写代码的时候，会将数组作为一个参数传给函数，比如：我要实现一个冒泡排序（这里要讲算法思想）函数。

将一个整型数组排序。

4.1、冒泡排序函数的错误设计

5、冒泡排序的核心思想

冒泡排序的核心思想：两个相邻的元素进行比较。

6、数组名

6.1、一维数组的数组名理解

我们通常说数组名就是数组首元素地址

#include <stdio.h>
int main()
{
    int arr[3] = { 1,2,3 };
    printf("%p\n", arr);
    printf("%p\n", &arr[0]);
    return 0;
}

输出：

可以看到地址确实是一样的。

所以得出结论：数组名确实能表示数组首元素的地址。

但是又两个例外：

sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。
&数组名，这里的数组名表示整个数组，取出的是整个数组的地址。

除此以上两种情况，其它遇到的数组名都是数组首元素地址。

6.2、二维数组的数组名理解

二维数组的数组名也表示数组首元素地址。

比如：int arr[3][4]; 数组首元素地址表示的是第一行元素的地址。并不是第一行第一个的元素的地址。

7、计算二维数组的行数和列数

#include <stdio.h>
int main()
{
    int arr[3][4] = { 0 };
    //sizeof(arr)表示整个二维数组的大小，sizeof(arr[0])表示二维数组的第一行大小。
    printf("%d\n", sizeof(arr) / sizeof(arr[0]));

    //sizeof(arr[0])表示二维数组的第一行大小，sizeof(arr[0][0])表示二维数组的一个元素大小。
    printf("%d\n", sizeof(arr[0]) / sizeof(arr[0][0]));
    return 0;
}

8、三子棋

新建个项目
创建test.c 测试游戏的逻辑
创建game.c 游戏代码的实现
game.h 游戏代码的声明（函数的声明、符号定义）

test.c文件

#define _CRT_SECURE_NO_WARNINGS
#include "game.h"
void menu()
{
    printf("*****************************\n");
    printf("******1. 进入游戏 0. 退出****\n");
    printf("*****************************\n");
}

void game()
{
    char ret = 0;
    char board[ROW][COL] = { 0 };
    //初始化棋盘的函数
    InitBoard(board, ROW, COL);

    //打印棋盘
    DisplayBoard(board, ROW, COL);

    //下棋
    while (1)
    {
        //玩家下棋
        PlayerMove(board,ROW,COL);
        //判断输赢
        ret = IsWin(board,ROW,COL);
        if (ret != 'C')
        {
            break;
        }
        DisplayBoard(board, ROW, COL);
        //电脑下棋
        ComputeMove(board,ROW,COL);
        //判断输赢
        ret = IsWin(board, ROW, COL);
        if (ret != 'C')
        {
            break;
        }
        DisplayBoard(board, ROW, COL);
    }
    if (ret == '*')
    {
        printf("玩家赢\n");
        DisplayBoard(board, ROW, COL);
    }
    else if (ret == '#')
    {
        printf("电脑赢\n");
        DisplayBoard(board, ROW, COL);
    }
    else
    {
        printf("平局\n");
        DisplayBoard(board, ROW, COL);
    }
}

int main()
{
    srand((unsigned int)time(NULL));//设置随机数的生成起点
    int input = 0;
    do
    {
        menu();
        printf("请选择>");
        scanf("%d", &input);
        switch (input)
        {
        case 1:
            game();
            break;
        case 0:
            printf("退出游戏\n");
            break;
        default:
            printf("选择错误\n");
            break;
        }
    } while (input);
    return 0;
}

game.c文件

#include "game.h"

//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            board[i][j] = ' ';
        }
    }
}

////第一个版本
//void DisplayBoard(char board[ROW][COL], int row, int col)
//{
//    int i = 0;
//    for (i = 0; i < row; i++)
//    {
//        打印数据
//        printf(" %c | %c | %c \n", board[i][0], board[i][1], board[i][2]);
//        打印分割信息
//        if (i < row - 1)
//        {
//            printf("---|---|---\n");
//        }
//    }
//}

//打印棋盘
void DisplayBoard(char board[ROW][COL], int row, int col)
{
    int i = 0;
    for (i = 0; i < row; i++)
    {
        int j = 0;
        //打印数据
        for (j = 0; j < col; j++)
        {
            printf(" %c ", board[i][j]);
            if (j < col - 1)
            {
                printf("|");
            }
        }
        printf("\n");
        //打印分割信息
        if (i < row - 1)
        {
            for (j = 0; j < col; j++)
            {
                printf("---");
                if (j < col - 1)
                {
                    printf("|");
                }
            }
            printf("\n");
        }
    }
}

//玩家下棋
void PlayerMove(char board[ROW][COL], int row, int col)
{
    int x = 0;
    int y = 0;
    while (1)
    {
        printf("玩家下棋\n");
        printf("请输入坐标:>");
        scanf("%d %d", &x, &y);
        //判断坐标是否合法
        if (x >= 1 && x <= row && y >= 1 && y <= col)
        {
            //判断坐标是否被占用
            if (board[x - 1][y - 1] == ' ')
            {
                board[x - 1][y - 1] = '*';
                break;
            }
            else
            {
                printf("坐标被占用，不能下棋，请选择其它位置\n");
            }
        }
        else
        {
            printf("坐标不合法，请重新输入:>\n");
        }
    }
}

//电脑下棋
//找还未下棋的位置随机下棋
void ComputeMove(char board[ROW][COL], int row, int col)
{
    printf("电脑下棋:>\n");
    int x = 0;
    int y = 0;
    while (1)
    {
        x = rand() % row;   //0~2
        y = rand() % col;   //0~2
        if (board[x][y] == ' ')
        {
            board[x][y] = '#';
            break;
        }
    }
}

//平局的函数，返回1表示填满了，返回0表示未填满
int IsFull(char board[ROW][COL], int row, int col)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            if (board[i][j] == ' ')
            {
                return 0;
            }
        }
    }
    return 1;
}


//判断输赢
char IsWin(char board[ROW][COL], int row, int col)
{
    //判断在行中赢的
    int i = 0;
    for (i = 0; i < row; i++)
    {
        if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
        {
            return board[i][1];
        }
    }

    //判断在列中赢的
    int j = 0;
    for (j = 0; j < col; j++)
    {
        if (board[0][j] == board[1][j] && board[1][j] == board[2][j] && board[1][j] != ' ')
        {
            return board[1][j];
        }
    }

    //判断对角线赢的
    if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
    {
        return board[1][1];
    }
    if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
    {
        return board[1][1];
    }

    //平局：都没赢就需要平局，平局的判断标准就是：以上赢的标准都不符合且九个格子全部填满。
    if (IsFull(board,ROW,COL))
    {
        return 'Q';
    }
    //游戏继续
    return 'C';
}

game.h文件

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define ROW 3
#define COL 3
#include <stdlib.h>
#include <time.h>

//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col);

//打印棋盘
void DisplayBoard(char board[ROW][COL], int row, int col);

//玩家下棋
void PlayerMove(char board[ROW][COL], int row, int col);

//电脑下棋
void ComputeMove(char board[ROW][COL], int row, int col);

//判断输赢，包含四种情况：
//玩家赢-'*'
//电脑赢-'#'
//平局-'Q'
//继续-'C'
char IsWin(char board[ROW][COL], int row, int col);

9、扫雷

test.c文件

#define _CRT_SECURE_NO_WARNINGS
#include "game.h"

void menu()
{
    printf("*********************************\n");
    printf("*********   1.玩游戏    *********\n");
    printf("*********   0.退  出    *********\n");
    printf("*********************************\n");
}

void game()
{
    //存放布置好雷的信息
    char mine[ROWS][COLS] = { 0 };
    //存放排查出雷的信息
    char show[ROWS][COLS] = { 0 };
    //mine 初始化数组在没有布置雷的时候都是'0'
    InitBoard(mine, ROWS, COLS,'0');
    //show 初始化数组在没有布置雷的时候都是'*'
    InitBoard(show, ROWS, COLS, '*');

    //设置雷
    SetMine(mine, ROW, COL);
    //打印棋盘，这里只需要打印9*9的棋盘，所以参数需要变化
    //DisplayBoard(mine, ROW, COL);
    DisplayBoard(show, ROW, COL);

    //排查雷
    FindMine(mine, show, ROW, COL);

}

int main()
{
    int input = 0;
    srand((unsigned int)time(NULL));
    do
    {
        menu();
        printf("请选择:>");
        scanf("%d", &input);
        switch (input)
        {
        case 1:
            game();
            break;
        case 2:
            printf("退出游戏");
            break;
        default:
            printf("选择错误\n");
            break;
        }
    } while (input);
    return 0;
}

game.c

#include "game.h"

//初始化棋盘为'0'
void InitBoard(char board[ROWS][COLS], int rows, int cols,char set)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < rows; i++)
    {
        for (j = 0; j < cols; j++)
        {
            board[i][j] = set;
        }
    }
}

//打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
    int i = 0;
    int j = 0;
    printf("-----------------扫雷游戏--------------------\n");
    for (j = 0; j <= col; j++)
    {
        printf("%d ", j);
    }
    printf("\n");
    for (i = 1; i <= row; i++)
    {
        printf("%d ", i);    //添加行号
        for (j = 1; j <= col; j++)
        {
            printf("%c ",board[i][j]);
        }
        printf("\n");
    }
    printf("-----------------扫雷游戏--------------------\n");
}

//设置雷
void SetMine(char board[ROWS][COLS], int row, int col)
{
    int count = EASY_COUNT;
    while (count)
    {
        int x = rand() % row + 1;
        int y = rand() % col + 1;
        if (board[x][y] == '0')
        {
            board[x][y] = '1';
            count--;
        }
    }
}

int get_mine_count(char board[ROWS][COLS],int x,int y)
{
    return (board[x - 1][y] +
        board[x - 1][y] +
        board[x][y - 1] +
        board[x + 1][y - 1] +
        board[x + 1][y] +
        board[x + 1][y + 1] +
        board[x][y + 1] +
        board[x - 1][y + 1] - 8 * '0'); 


}

//排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
    int x = 0;
    int y = 0;
    int win = 0;        //记录非雷的个数
    while (win < row*col-EASY_COUNT)
    {
        printf("请输入要排查的坐标:>");
        scanf("%d %d", &x, &y);
        if (x >= 1 && x <= row && y >= 1 && y <= col)
        {
            if (show[x][y] != '*')
            {
                printf("该坐标被排查过了，不能重复排查\n");
            }
            else
            {
                if (mine[x][y] == '1')
                {
                    printf("很遗憾，你被炸死了\n");
                    DisplayBoard(mine, ROW, COL);
                    break;
                }
                else        //如果不是雷，需要统计周围有几个雷
                {
                    win++;
                    int count = get_mine_count(mine, x, y);
                    show[x][y] = count + '0';     //数字1转为字符'1'
                    DisplayBoard(show, ROW, COL);
                }
            }
        }
        else
        {
            printf("输入非法坐标，请重新输入\n");
        }
    }
    if (win == row * col - EASY_COUNT)
    {
        printf("恭喜你，排雷成功了\n");
        DisplayBoard(mine, ROW, COL);
    }
}

game.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define ROW 9
#define COL 9

#define ROWS ROW+2
#define COLS COL+2

#define EASY_COUNT 10

void InitBoard(char board[ROWS][COLS], int rows, int cols,char set);

void DisplayBoard(char board[ROWS][COLS], int row, int col);

void SetMine(char board[ROWS][COLS], int row, int col);

void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

'1'和1的运算

'1' - '0' = 1

原理：'1'的ASCII值为49

'0'的ASCII值为48

'0' - '0' = 0

原理同上。

从零开始学习C语言---数组

1、一维数组的创建和初始化

1.1、数组的创建

1.2、数组的初始化

1.3、一维数组的使用

1.4、一维数组在内存中的存储

1.5、数组的类型

【补充：】sizeof()和strlen的用法

2、二维数组的创建和初始化

2.2、二维数组的创建

2.3、二维数组的初始化

2.3、二维数组的使用

补充：如何把二维数组看作为一维数组

2.4、二维数组在内存中的存储

3、数组越界

4、数组作为函数参数

4.1、冒泡排序函数的错误设计

5、冒泡排序的核心思想

6、数组名

6.1、一维数组的数组名理解

6.2、二维数组的数组名理解

7、计算二维数组的行数和列数

8、三子棋

test.c文件

game.c文件

game.h文件

9、扫雷

test.c文件

game.c

game.h

'1'和1的运算

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

从零开始学习C语言---数组

1、一维数组的创建和初始化

1.1、数组的创建

1.2、数组的初始化

1.3、一维数组的使用

1.4、一维数组在内存中的存储

1.5、数组的类型

【补充：】sizeof()和strlen的用法

2、二维数组的创建和初始化

2.2、二维数组的创建

2.3、二维数组的初始化

2.3、二维数组的使用

补充：如何把二维数组看作为一维数组

2.4、二维数组在内存中的存储

3、数组越界

4、数组作为函数参数

4.1、冒泡排序函数的错误设计

5、冒泡排序的核心思想

6、数组名

6.1、一维数组的数组名理解

6.2、二维数组的数组名理解

7、计算二维数组的行数和列数

8、三子棋

test.c文件

game.c文件

game.h文件

9、扫雷

test.c文件

game.c

game.h

'1'和1的运算

热门文章

最新文章

相关课程

相关电子书

相关实验场景