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
原理同上。
