C语言实现爆炸展开的扫雷详解

2024-08-09 12:13:23

游戏介绍

首先，我们来说基础版的扫雷游戏有什么功能：

1.打印菜单，由玩家选择玩游戏或者是退出游戏。

2.打印雷盘，让玩家知道我们的雷盘是什么样子的，从而让玩家知道排雷的时候哪个位置对应着哪个坐标。

3.玩家开始排雷，并在排雷的函数中加入判断输赢的模块。

以上就是我们基础版扫雷的功能啦！！！当然，这样玩扫雷这个游戏会很累的，因为我们在游戏中设置的展现给玩家的雷盘是9X9的雷盘，也就是说，我们如果想赢，我们就需要在这个雷盘中排查71个非雷部分（当然，如果排查到雷那游戏就会直接结束了！！）这样的游戏是毫无游戏体验感的。

所以，我们今天来学习一下，如何让我们的扫雷游戏变得厉害起来！！！

那么，我们进阶版的扫雷游戏有什么新加的功能呐？？？

1.在玩家排雷的模块，我们增添了爆炸展开的情况。如果玩家排雷的位置没有雷，并且，周围的位置也没有雷，我们就让这些位置爆炸式的展开。

2.在玩家开始排雷之前，我们增加了一个小菜单，用来让玩家选择排雷，添加标记或者是取消标记。

3.为了增加游戏的快乐，我们增加了添加标记和取消标记这两个功能。如果玩家认为某个位置有雷的存在，就可以在那个位置增加一个" ! "的标记。

游戏功能实现

1.主菜单：

在游戏开始之前，我们先给玩家来上这么一个菜单来供玩家选择玩游戏还是退出游戏

void Menu()
{
	printf("\t***************************************\n\n");
	printf("\t**************  1.play  ***************\n\n");
	printf("\t**************  0.exit  ***************\n\n");
	printf("\t***************************************\n");
}

2.初始化雷盘

//mine数组在没有布置雷的时候，全是'0'
//show数组在没有排查雷的时候，全是'*'
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;
		}
	}
}

3.打印雷盘

//打印雷盘
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	printf("\t***   扫雷游戏  ***\n\n");
	printf("\t");
	for (j = 0; j <= col; j++)
	{

		printf("%d ",j );
	}
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		printf("\t");
		printf("%d ", i);
		for (j = 1; j <= col; j++)
		{

			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
	printf("\n\t***   扫雷选择  ***\n\n");
}

此时，我们的调试结果应该如下图所示：

4.布置雷

void SetMine(char board[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;//雷的个数
	while (count)
	{
		int x = rand() % row + 1;//1~9
		int y = rand() % col + 1;//1~9
		if (board[x][y] == '0')//查看该坐标处是否已经布置雷
		{
			board[x][y] = '1';
			count--;
		}
	}
}

这个时候，我们来看看是否能够完美的布置好我们的雷：

5.玩家开始排查雷

void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int input1 = 0;
	int win = 0;//找到非雷的数量
	int flag_count = 0;//标记雷的个数
	while (1)
	{
		Menu1();
		printf("请输入你的选择：>");

		scanf("%d", &input1);
		printf("\n");
		if (input1 == 1)
		{
			int x = 0;
	        int y = 0;
			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++;
						broad(mine, show, x, y);
						//要注意字符1和数字1的区别
						if (get_mine_count(mine, x, y) == 0)
						{
							show[x][y] = ' ';
							system("cls");
							DisplayBoard(show, ROW, COL);//如果该位置周围没有雷就显示为空格
						}
						else
						{
							int count = get_mine_count(mine, x, y);//统计mine数组中x,y坐标周围有几个0
							show[x][y] = count + '0';
							DisplayBoard(show, ROW, COL);
						}
						//int count = get_mine_count(mine, x, y);//统计mine数组中x,y坐标周围有几个0
						//show[x][y] = count + '0';//数字转换为字符
					}
				}
			}
			else
			{
				printf("输入坐标非法！！！请重新输入。\n");
			}
		}
		else if (input1 == 2)
		{
			printf("请开始标记雷：");
			flag_count = Flagmine(show, ROW, COL, flag_count);
			DisplayBoard(show, ROW, COL);
		}
		else if (input1 == 3)
		{
			printf("请取消已经标记雷：");
			flag_count = Cancelflag(show, ROW, COL, flag_count);
			DisplayBoard(show, ROW, COL);
		}
		if (win == COL * ROW)
		{
			printf("恭喜你排雷成功！！！\n");
			DisplayBoard(mine, ROW, COL);
			break;
		}
	}
}

6.小菜单

void Menu1()
{
	printf("\t*** 1.开始排雷  ***\n\n");
	printf("\t*** 2.添加标记  ***\n\n");
	printf("\t*** 3.取消标记  ***\n\n");
}

7.排查位置周围的八个坐标有几个雷

int get_mine_count(char board[ROWS][COLS], int x, int y)
{
	return (board[x - 1][y] + board[x - 1][y - 1] + 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');
}

8.使用递归爆炸式展开

void broad(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{
	//判断是否在范围内，坐标是否越界
	if (x == 0 || y == 0 || x == ROWS - 1 || y == COLS - 1)
	{
		return;
	}
	//判断该坐标是否已经被排查过了
	if (show[x][y] != '*')
	{
		return;
	}
	//开始准备递归
	int count = get_mine_count(mine, x, y);
	if (count == 0)
	{
		show[x][y] = ' ';
		broad(mine, show, x - 1, y);
		broad(mine, show, x - 1, y - 1);
		broad(mine, show, x, y - 1);
		broad(mine, show, x + 1, y - 1);
		broad(mine, show, x + 1, y);
		broad(mine, show, x + 1, y + 1);
		broad(mine, show, x, y + 1);
		broad(mine, show, x - 1, y + 1);
	}
	else if (count > 0)
	{
		show[x][y] = count + '0';
	}
}

9.标记功能

//标记功能——>玩家可以自行标记自己觉得是雷的位置
int Flagmine(char show[ROWS][COLS], int row, int col,int flag_count)
{
	int x = 0;
	int y = 0;
	//如果目前雷盘上已经标记过的点的数量已经和我们要排的雷的数量相等的话，显示无法标记
	if (flag_count == EASY_COUNT)
	{
		printf("目前雷盘上已经存在和所要排雷数量相等的标记，无法进行标记！！！\n");
		return;
	}
	printf("请输入你要标记的位置坐标:> ");
	scanf("%d %d", &x, &y);
	//判断坐标是否在指定的区域
	if (x > 0 && x <= row && y > 0 && y <= col)
	{
		//判断该坐标是否仍未被排除
		if (show[x][y] == '*')
		{
			show[x][y] = '!';
			flag_count++;
		}
		else
		{
			printf("该位置不可能是雷，请重新输入\n");
		}
	}
	else
	{
		printf("该坐标不合法，请重新输入:>\n");
	}
	return flag_count;
}

10.取消标记功能

//取消标记的功能
int Cancelflag(char show[ROWS][COLS], int row, int col, int flag_count)
{
	int x = 0;
	int y = 0;
	printf("请输入你要取消标记的位置坐标:> ");
	scanf("%d %d", &x, &y);
	//判断坐标是否在指定的区域
	if (x > 0 && x <= row && y > 0 && y <= col)
	{
		if (show[x][y] == '！')
		{
			show[x][y] = '*';
			flag_count--;
		}
		else
		{
			printf("该坐标没有被标记，无需取消标记\n");
		}
	}
	else
	{
		printf("该坐标不合法，请重新输入：>");
	}
	return flag_count;
}

完整代码

1.game.c

扫雷游戏代码

#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"
//mine数组在没有布置雷的时候，全是'0'
//show数组在没有排查雷的时候，全是'*'
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("\t***   扫雷游戏  ***\n\n");
	printf("\t");
	for (j = 0; j <= col; j++)
	{
		printf("%d ",j );
	}
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		printf("\t");
		printf("%d ", i);
		for (j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
	printf("\n\t***   扫雷选择  ***\n\n");
}
//设置雷
void SetMine(char board[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;//雷的个数
	while (count)
	{
		int x = rand() % row + 1;//1~9
		int y = rand() % col + 1;//1~9
		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 - 1] + 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 broad(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{
	//判断是否在范围内，坐标是否越界
	if (x == 0 || y == 0 || x == ROWS - 1 || y == COLS - 1)
	{
		return;
	}
	//判断该坐标是否已经被排查过了
	if (show[x][y] != '*')
	{
		return;
	}
	//开始准备递归
	int count = get_mine_count(mine, x, y);
	if (count == 0)
	{
		show[x][y] = ' ';
		broad(mine, show, x - 1, y);
		broad(mine, show, x - 1, y - 1);
		broad(mine, show, x, y - 1);
		broad(mine, show, x + 1, y - 1);
		broad(mine, show, x + 1, y);
		broad(mine, show, x + 1, y + 1);
		broad(mine, show, x, y + 1);
		broad(mine, show, x - 1, y + 1);
	}
	else if (count > 0)
	{
		show[x][y] = count + '0';
	}
}
//标记功能——>玩家可以自行标记自己觉得是雷的位置
int Flagmine(char show[ROWS][COLS], int row, int col,int flag_count)
{
	int x = 0;
	int y = 0;
	//如果目前雷盘上已经标记过的点的数量已经和我们要排的雷的数量相等的话，显示无法标记
	if (flag_count == EASY_COUNT)
	{
		printf("目前雷盘上已经存在和所要排雷数量相等的标记，无法进行标记！！！\n");
		return;
	}
	printf("请输入你要标记的位置坐标:> ");
	scanf("%d %d", &x, &y);
	//判断坐标是否在指定的区域
	if (x > 0 && x <= row && y > 0 && y <= col)
	{
		//判断该坐标是否仍未被排除
		if (show[x][y] == '*')
		{
			show[x][y] = '!';
			flag_count++;
		}
		else
		{
			printf("该位置不可能是雷，请重新输入\n");
		}
	}
	else
	{
		printf("该坐标不合法，请重新输入:>\n");
	}
	return flag_count;
}
//取消标记的功能
int Cancelflag(char show[ROWS][COLS], int row, int col, int flag_count)
{
	int x = 0;
	int y = 0;
	printf("请输入你要取消标记的位置坐标:> ");
	scanf("%d %d", &x, &y);
	//判断坐标是否在指定的区域
	if (x > 0 && x <= row && y > 0 && y <= col)
	{
		if (show[x][y] == '！')
		{
			show[x][y] = '*';
			flag_count--;
		}
		else
		{
			printf("该坐标没有被标记，无需取消标记\n");
		}
	}
	else
	{
		printf("该坐标不合法，请重新输入：>");
	}
	return flag_count;
}
void Menu1()
{
	printf("\t*** 1.开始排雷  ***\n\n");
	printf("\t*** 2.添加标记  ***\n\n");
	printf("\t*** 3.取消标记  ***\n\n");
}
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int input1 = 0;
	int win = 0;//找到非雷的数量
	int flag_count = 0;//标记雷的个数
	while (1)
	{
		Menu1();
		printf("请输入你的选择：>");
		scanf("%d", &input1);
		printf("\n");
		if (input1 == 1)
		{
			int x = 0;
	        int y = 0;
			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++;
						broad(mine, show, x, y);
						//要注意字符1和数字1的区别
						if (get_mine_count(mine, x, y) == 0)
						{
							show[x][y] = ' ';
							system("cls");
							DisplayBoard(show, ROW, COL);//如果该位置周围没有雷就显示为空格
						}
						else
						{
							int count = get_mine_count(mine, x, y);//统计mine数组中x,y坐标周围有几个0
							show[x][y] = count + '0';
							DisplayBoard(show, ROW, COL);
						}
						//int count = get_mine_count(mine, x, y);//统计mine数组中x,y坐标周围有几个0
						//show[x][y] = count + '0';//数字转换为字符
					}
				}
			}
			else
			{
				printf("输入坐标非法！！！请重新输入。\n");
			}
		}
		else if (input1 == 2)
		{
			printf("请开始标记雷：");
			flag_count = Flagmine(show, ROW, COL, flag_count);
			DisplayBoard(show, ROW, COL);
		}
		else if (input1 == 3)
		{
			printf("请取消已经标记雷：");
			flag_count = Cancelflag(show, ROW, COL, flag_count);
			DisplayBoard(show, ROW, COL);
		}
		if (win == COL * ROW)
		{
			printf("恭喜你排雷成功！！！\n");
			DisplayBoard(mine, ROW, COL);
			break;
		}
	}
}

2.test.c

游戏主逻辑

#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"
void Menu()
{
	printf("\t***************************************\n\n");
	printf("\t**************  1.play  ***************\n\n");
	printf("\t**************  0.exit  ***************\n\n");
	printf("\t***************************************\n");
}
void game()
{
	char mine[ROWS][COLS] = { 0 };//用来存放布置好的雷
	char show[ROWS][COLS] = { 0 };//用来存放排查出的雷的信息
	//初始化数组的内容为我们指定的内容
	Initboard(mine, ROWS, COLS, '0');
	Initboard(show, ROWS, COLS, '*');
	//设置雷
	SetMine(mine, ROW, COL);
	//打印棋盘
	DisplayBoard(show, ROW, COL);
	//DisplayBoard(mine, ROW, COL);
	//排查雷
	FindMine(mine, show, ROW, COL);//在mine中找雷。把雷放在show中
}
int main()
{
	//设置随机数的生成起点
	srand((unsigned int)time(NULL));
	int input = 0;
	do
	{
		Menu();
		printf("请输入你的选择：>");
		scanf("%d", &input);
		printf("\n");
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n已退出游戏，欢迎您再次游玩\n");
			break;
		default:
			printf("输入错误，请重新选择。\n");
			break;
		}
		Sleep(3000);
		system("cls");
	} while (input);
	return 0;
}

3.game.h

头文件部分

#pragma once
#include<stdio.h>
#include<time.h>
#include<stdlib.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);
int  get_mine_count(char mine[ROWS][COLS], int x, int y);
void broad(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y);
int Flagmine(char show[ROWS][COLS], int row, int col, int flag_count);

详细代码：扫雷进阶版

到此这篇关于C语言实现爆炸展开的扫雷详解的文章就介绍到这了,更多相关C语言扫雷内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

基于C语言实现简易的扫雷游戏

对于C语言学习者来说,在完成C语言初级学习之后,扫雷游戏是一个很好的知识的总结和练习. 扫雷即在一个棋盘中,随机放入一定数量的雷,玩家通过输入坐标,得到坐标上的信息(以此点为中心四周8个格子内地雷数量的总和),来判断此格子是否有地雷,从而依照此法排查出整个棋盘上所有的地雷. 本项目采用9*9的棋盘,放入地雷的数量可以依照个人设置. 首先声明总的头文件 #ifndef _UTILI_H_ #define _UTILI_H_ #include<stdio.h> #include<time
C语言实现扫雷小游戏完整算法详解(附完整代码)

目录前言 1.算法基本思路 2.算法详解 1.初始化数组与打印数组 2.设置雷 3.排查与标记 4.CountMine函数计算周围雷的个数 5.ExpandMine函数递归展开周围所有安全区域 3.完整代码!!! 总结前言扫雷是一个常见小游戏,那么如何用C语言实现扫雷呢?学习了二维数组之后,我们可将扫雷的网格区域存储为二维数组,从而使用C语言实现扫雷. 1.算法基本思路首先,用一个二维数组存储雷的分布,雷的分布在游戏期间从始至终不变,下文称为mine数组.用另一个二维数组存储排查出的雷的
C语言制作扫雷游戏(图形库)

本文实例为大家分享了C语言制作扫雷游戏的具体代码,供大家参考,具体内容如下游戏预览: 学习内容: 1.图形库文件的使用2.C++的使用,如类函数3.了解扫雷的规则,严谨的思维逻辑扫雷的规则: 玩家点击一个地方,如果该地方是雷,则游戏结束:如果是空格,则会显示周围空格和周围8个格子的雷的数量,玩家依照提示逐步挖掘全部的雷,从而结束游戏. 制作步骤: 基本的库函数和常量 #include<stdio.h> #include<stdlib.h> #include<time.h&
C语言实现扫雷游戏的方法

相信大家对扫雷一定都不陌生吧!但是你敢信仅仅使用一些C语言的初阶基础知识就能够制作一个扫雷简单小游戏?今天,我将带领大家一起走进扫雷,探究其基础算法奥秘. 一.基本思路首先,既然是玩游戏,我们应该设计相应的菜单. 输入1后继续让玩家选择游戏难度: 我们在这里设计简单模式为6x6大小的面板,雷埋10个:中等模式为10x10大小的面板,雷埋30个:困难模式为14x14大小的面板,雷埋50个. 为了方便雷的布置与显示,我们设计了两张面板:show_board[ROW][COL]和mine_board
C语言实现扫雷代码

本文实例为大家分享了C语言实现扫雷的具体代码,供大家参考,具体内容如下前言扫雷实现的基本规划: 1.玩家可以自由选择进入和退出游戏2.玩家通过输入坐标来排雷3.排查雷给出提示4.玩家可以任意标记雷区5.排雷同时展开非雷区下面为效果图: 一.主函数(test.c): 通过do while嵌套switch对游戏菜单进行控制: 玩游戏输入1:进入case1开始游戏. 输入2:进入case2退出游戏 . 输入错误:进入default,进入下一次循环重新输入. 菜单给出标记操作提示. #includ
C语言详细讲解通过递归实现扫雷的展开

目录用户选择菜单棋盘初始化布置雷(随机布置) 打印棋盘玩家下棋棋盘展开展开部分思维导图展开函数最后一个else return 作用周围雷个数判断用户选择菜单 void menu() { printf("****************************\n"); printf("******** 1.play **********\n"); printf("******** 0.exit **********\n"); p
C语言递归应用实现扫雷游戏

本文实例为大家分享了C语言递归应用实现扫雷游戏的具体代码,供大家参考,具体内容如下游戏设计规则: 菜单两个棋盘,Mine一个布置雷,Show一个给玩家看,玩家选择show里的坐标翻开雷阵,在mine里的相同坐标如果是雷则玩家失败游戏结束,若不是雷则判断此坐标周围8个坐标是否有雷,有雷则显示周围总雷数,没有就显示为空格.为了避免判断雷阵最外边一圈坐标时出现溢出,因此设置雷阵数组时行(列)比打印出的要多两行(列),布置雷时也不在最外面一圈布雷. 第一步如果踩雷则将mine中所选坐标位置换为安全,
C语言二维数组应用实现扫雷游戏

本文实例为大家分享了C语言二维数组应用实现扫雷游戏的具体代码,供大家参考,具体内容如下游戏简介: 电脑随机设置10个雷,用户输入坐标,若坐标下是雷则结束游戏,不是则该位置显示周围的雷数. game.h #ifndef __GAME_H__ #define __GAME_H__ #include<stdio.h> //设置屏幕显示的雷盘的大小 #define ROW 9 #define COL 9 //设置实际雷盘的大小(判断雷数是看用户所选的坐标周围八个坐标内是否设雷,但若是用户选
C语言实现经典扫雷小游戏完整代码（递归展开 + 选择标记）

目录游戏介绍游戏整体框架游戏具体功能及实现 1.雷盘的定义 2.雷盘的初始化 3.布置雷 4.排查雷 5.递归式展开一片 6.获取周围雷的个数 7.标记特定位置 8.打印雷盘游戏完整代码 1.test.c 2.game.h 3.game.c 游戏效果展示大家好,今天我们将一起用C语言实现一个经典小游戏 – 扫雷,Let is go ! 游戏介绍扫雷游戏相信大家都玩过,上图就是一个网页版的扫雷,它的规则是玩家选择一个方格,若此方格没有地雷,那么该方格会显示与它相邻的八个方格中雷的个数,
C语言实现爆炸展开的扫雷详解

目录游戏介绍游戏功能实现 1.主菜单: 2.初始化雷盘 3.打印雷盘 4.布置雷 5.玩家开始排查雷 6.小菜单 7.排查位置周围的八个坐标有几个雷 8.使用递归爆炸式展开 9.标记功能 10.取消标记功能完整代码 1.game.c 2.test.c 3.game.h 游戏介绍首先,我们来说基础版的扫雷游戏有什么功能: 1.打印菜单,由玩家选择玩游戏或者是退出游戏. 2.打印雷盘,让玩家知道我们的雷盘是什么样子的,从而让玩家知道排雷的时候哪个位置对应着哪个坐标. 3.玩家开始排雷,并在排
R语言时间序列TAR阈值自回归模型示例详解

为了方便起见,这些模型通常简称为TAR模型.这些模型捕获了线性时间序列模型无法捕获的行为,例如周期,幅度相关的频率和跳跃现象.Tong和Lim(1980)使用阈值模型表明,该模型能够发现黑子数据出现的不对称周期性行为. 一阶TAR模型的示例: σ是噪声标准偏差,Yt-1是阈值变量,r是阈值参数, {et}是具有零均值和单位方差的iid随机变量序列. 每个线性子模型都称为一个机制.上面是两个机制的模型. 考虑以下简单的一阶TAR模型: #低机制参数 i1 = 0.3 p1 = 0.5 s1 = 1
C语言从编译到运行过程详解

目录 C语言从编译到运行一.前言二.C程序编译过程三.阶段过程 1.预处理阶段 2.编译阶段 3.汇编阶段 4.链接阶段 C语言从编译到运行一.前言最近在看CSAPP(深入理解计算机系统)然后以前也学过C语言,但是从来没有深究写好的C代码是怎么编译再到执行的. 所以现在自己学习,然后记录下来. 以最常用的hello world!程序为例程序名: main.c #include <stdio.h> int main() { printf("Hello world!\n&qu
Go语言使用对称加密的示例详解

目录介绍 AES 算法实践总结介绍在项目开发中,我们经常会遇到需要使用对称密钥加密的场景,比如客户端调用接口时,参数包含手机号.身份证号或银行卡号等. 对称密钥加密是一种加密方式,其中只有一个密钥用于加密和解密数据.通过对称加密进行通信的实体必须共享该密钥,以便可以在解密过程中使用它.这种加密方法与非对称加密不同,非对称加密使用一对密钥(一个公钥和一个私钥)来加密和解密数据. AES 算法常见的对称密钥加密算法有 AES (Advanced Encryption Standard),
C语言树状数组的实例详解

C语言树状数组的实例详解最近学了树状数组,给我的感觉就是这个数据结构好神奇啊^_^ 首先她的常数比线段树小,其次她的实现复杂度也远低于线段树 (并没有黑线段树的意思=-=) 所以熟练掌握她是非常有必要的.. 关于树状数组的基础知识与原理网上一搜一大堆,我就不赘述了,就谈一些树状数组的应用好了 1,单点修改,求区间和 #define lowbit(x) (x&-x) // 设 x 的末尾零的个数为 y , 则 lowbit(x) == 2^y void Update(int i,int v)
Kotlin 语言中调用 JavaScript 方法实例详解

Kotlin 语言中调用 JavaScript 方法实例详解 Kotlin 已被设计为能够与 Java 平台轻松互操作.它将 Java 类视为 Kotlin 类,并且 Java 也将 Kotlin 类视为 Java 类.但是,JavaScript 是一种动态类型语言,这意味着它不会在编译期检查类型.你可以通过动态类型在 Kotlin 中自由地与 JavaScript 交流,但是如果你想要 Kotlin 类型系统的全部威力 ,你可以为 JavaScript 库创建 Kotlin 头文件. 内联 J
C语言中联合体union的实例详解

C语言中联合体union的实例详解 1.定义: union(int i, short s, char c) un; un.i = 3; printf("i=%d",un.i); printf("length = %d\n",sizeof(un);//==4,有最大的变量来决定 2.相当与java里的List T类型 3.数据交换 void swap(int *p , int *q){ int temp = *p; *p = *q; *q = temp; } 4.打
C语言中二级指针的实例详解

C语言中二级指针的实例详解用图说明示例代码: #include <stdio.h> int main(int argc, const char * argv[]) { // int a = 5; int *p1 = &a; //-打印地址-----地址相同--------------- printf("&a = %p\n", &a);// printf("p1 = %p\n", p1);// int **p2 = &p
C语言中调用Swift函数实例详解

C语言中调用Swift函数实例详解在Apple官方的<Using Swift with Cocoa and Objectgive-C>一书中详细地介绍了如何在Objective-C中使用Swift的类以及如何在Swift中使用Objective-C中的类.在后半部分也介绍了如何在Swift中使用C函数,不过对于如何在C语言中使用Swift函数却只字未提.这里我就为大家分享一下如何在C语言中调用Swift函数. 我们首先要知道的是,所有Swift函数都属于闭包.其次,Swift函数的调用约定与
C语言实现“幸运数”的实例详解

C语言实现"幸运数"的实例详解 1.题目: 标题:幸运数幸运数是波兰数学家乌拉姆命名的.它采用与生成素数类似的"筛法"生成. 首先从1开始写出自然数1,2,3,4,5,6,-. 1 就是第一个幸运数. 我们从2这个数开始.把所有序号能被2整除的项删除,变为: 1 _ 3 _ 5 _ 7 _ 9 -. 把它们缩紧,重新记序,为: 1 3 5 7 9 -. .这时,3为第2个幸运数,然后把所有能被3整除的序号位置的数删去.注意,是序号位置,不是那个数本身能否被3整除!