C语言—港式五张第二天：分文件全局变量声明，循环注意，free高阶指针

最新推荐文章于 2024-07-17 20:43:45 发布
最新推荐文章于 2024-07-17 20:43:45 发布
阅读量384 收藏 9
点赞数 4
文章标签： c++ 开发语言 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50198957/article/details/136992230
版权

1.分文件全局变量声明

/*
    在B.c文件中调用A.c的全局变量的步骤如下：
    1.任何头文件都禁止定义全局变量；
    2.如果B.c想用来自A.c的全局变量的话，需要做以下步骤：
        ①.确保A.h中没有全局变量的定义；
        ②.去掉A.c中全局变量static的关键字（如果有的话）；
        ③.在B.h中使用《extern》关键字来“声明”来自于A.c的全局变量（注意是声明不是定义，复制粘贴的时候别把值粘过来）；
        ④.在B.c中包含B.h；
        ⑤.现在，B.c可以正常调用来自A.c的全局变量了。
    ！！《《再次声明：禁止在任何头文件中定义全局变量》》！！
    ！！《《再次声明：禁止在任何头文件中定义全局变量》》！！
    ！！《《再次声明：禁止在任何头文件中定义全局变量》》！！
    ！！《《再次声明：禁止在任何头文件中定义全局变量》》！！
    ！！《《再次声明：禁止在任何头文件中定义全局变量》》！！
    ！！《《再次声明：禁止在任何头文件中定义全局变量》》！！
    现在以此项目为例，进行展示：
    《注意：不要在任何头文件中定义全局变量；只在实现文件（.c）文件中定义全局变量》
    《注意：不要在任何头文件中定义全局变量；只在实现文件（.c）文件中定义全局变量》
    《注意：不要在任何头文件中定义全局变量；只在实现文件（.c）文件中定义全局变量》
    在这里，cardFunctions.c中定义了两个全局变量g_initialCardNum和g_initialCardColor.
    我们想要在playerFunctions.c中调用来自cardFunctions.c中的这两个全局变量。
    以下是步骤：
    1）确保cardFunctions.h中没有全局变量的定义；
    2）去除cardFunctions.c中全局变量static的关键字定义；
    3）在playerFunctions.h中《使用extern关键字》来“声明”来自cardFunctions.c的全局变量，注意不要赋值；
    4）在playerFunctions.c中包含playerFunctions.h头文件；
    5）在playerFunctions.c中就可以正常调用来自cardFunctions.c中全局变量了。
*/

2.循环

GAME_STATUS showPlayerCardStackValid(_IN_ PPlayer player)
{
	for (int j = 0; j < MAX_PERSONNAL_CARDS && *(((player->playerCardStack)[j])->num) != '0'; j++)
	{
		printf("Target Player's %ldth Card is %s%s\n", j + 1, ((player->playerCardStack)[j])->color, ((player->playerCardStack)[j])->num);
	}
	return STATUS_SUCCESS;
}

之前一个版本没有加

j < MAX_PERSONNAL_CARDS

导致当牌栈满了的时候由于无法识别

*(((player->playerCardStack)[j])->num)

导致内存错误。

3.free高阶指针（II）

GAME_STATUS getCombinedInfo(_OUT_ char**** combinedInfo)
{
	*combinedInfo = (char***)malloc(2 * sizeof(char**));
	if (*combinedInfo)
	{
		(*combinedInfo)[0] = (char**)malloc(COUNT_OF_NUM * sizeof(char*));
		(*combinedInfo)[1] = (char**)malloc(COUNT_OF_COLOR * sizeof(char*));
	}
	if (*combinedInfo && (*combinedInfo)[0])
	{
		for (int j = 0; j < COUNT_OF_NUM; j++)
		{
			(*combinedInfo)[0][j] = (char*)malloc(BYTES_FOR_SINGLE_NUM * sizeof(char));
		}
	}
	if (*combinedInfo && (*combinedInfo)[1])
	{
		for (int j = 0; j < COUNT_OF_COLOR; j++)
		{
			(*combinedInfo)[1][j] = (char*)malloc(BYTES_FOR_SINGLE_COLOR * sizeof(char));
		}
	}
	char* Card_NUM_8 = (char*)"8\0";
	char* Card_NUM_9 = (char*)"9\0";
	char* Card_NUM_10 = (char*)"10";
	char* Card_NUM_J = (char*)"J\0";
	char* Card_NUM_Q = (char*)"Q\0";
	char* Card_NUM_K = (char*)"K\0";
	char* Card_NUM_A = (char*)"A\0";
	char* Card_COLOR_梅花 = (char*)"梅花";
	char* Card_COLOR_黑桃 = (char*)"黑桃";
	char* Card_COLOR_红桃 = (char*)"红桃";
	char* Card_COLOR_方片 = (char*)"方片";
	if (*combinedInfo && (*combinedInfo)[0] && (*combinedInfo)[0][0] && (*combinedInfo)[0][1] && (*combinedInfo)[0][2] && (*combinedInfo)[0][3] && (*combinedInfo)[0][4] && (*combinedInfo)[0][5] && (*combinedInfo)[0][6])
	{
		memcpy((*combinedInfo)[0][0], Card_NUM_8, BYTES_FOR_SINGLE_NUM);
		memcpy((*combinedInfo)[0][1], Card_NUM_9, BYTES_FOR_SINGLE_NUM);
		memcpy((*combinedInfo)[0][2], Card_NUM_10, BYTES_FOR_SINGLE_NUM);
		memcpy((*combinedInfo)[0][3], Card_NUM_J, BYTES_FOR_SINGLE_NUM);
		memcpy((*combinedInfo)[0][4], Card_NUM_Q, BYTES_FOR_SINGLE_NUM);
		memcpy((*combinedInfo)[0][5], Card_NUM_K, BYTES_FOR_SINGLE_NUM);
		memcpy((*combinedInfo)[0][6], Card_NUM_A, BYTES_FOR_SINGLE_NUM);
	}
	if (*combinedInfo && (*combinedInfo)[1] && (*combinedInfo)[1][0] && (*combinedInfo)[1][1] && (*combinedInfo)[1][2] && (*combinedInfo)[1][3])
	{
		memcpy((*combinedInfo)[1][0], Card_COLOR_梅花, BYTES_FOR_SINGLE_COLOR);
		memcpy((*combinedInfo)[1][1], Card_COLOR_黑桃, BYTES_FOR_SINGLE_COLOR);
		memcpy((*combinedInfo)[1][2], Card_COLOR_红桃, BYTES_FOR_SINGLE_COLOR);
		memcpy((*combinedInfo)[1][3], Card_COLOR_方片, BYTES_FOR_SINGLE_COLOR);
	}
	return STATUS_SUCCESS;
}
GAME_STATUS killCombinedInfoMemory(_OUT_ char**** combinedInfo)
{
	for (int j = 0; j < COUNT_OF_NUM; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&((*combinedInfo)[0][j])));
	}
	for (int j = 0; j < COUNT_OF_COLOR; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&((*combinedInfo)[1][j])));
	}
	for (int j = 0; j < 2; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&((*combinedInfo)[j])));
	}
	ExFreeMemoryToNULL((PVOID)(&(*combinedInfo)));
	return STATUS_SUCCESS;
}

和

GAME_STATUS initialPlayerInfo(_OUT_ PPlayer* player)
{
	(*player) = (PPlayer)malloc(sizeof(Player));
	if (*player)
	{
		(*player)->playerCardStack = (PCard*)malloc(MAX_PERSONNAL_CARDS * sizeof(PCard));
		if ((*player)->playerCardStack)
		{
			for (int j = 0; j < MAX_PERSONNAL_CARDS; j++)
			{
				((*player)->playerCardStack)[j] = (PCard)malloc(CARD_ATTRIBUTION_TYPES * sizeof(Card));
			}
		}
		if ((*player)->playerCardStack && ((*player)->playerCardStack)[0] && ((*player)->playerCardStack)[1] && ((*player)->playerCardStack)[2] && ((*player)->playerCardStack)[3] && ((*player)->playerCardStack)[4])
		{
			for (int j = 0; j < MAX_PERSONNAL_CARDS; j++)
			{
				(((*player)->playerCardStack)[j])->num = (char*)malloc(BYTES_FOR_SINGLE_NUM * sizeof(char));
				(((*player)->playerCardStack)[j])->color = (char*)malloc(BYTES_FOR_SINGLE_COLOR * sizeof(char));
			}
		}
		if ((*player)->playerCardStack && ((*player)->playerCardStack)[0] && ((*player)->playerCardStack)[1] && ((*player)->playerCardStack)[2] && ((*player)->playerCardStack)[3] && ((*player)->playerCardStack)[4])
		{
			if ((((*player)->playerCardStack)[0])->num && (((*player)->playerCardStack)[1])->num && (((*player)->playerCardStack)[2])->num && (((*player)->playerCardStack)[3])->num && (((*player)->playerCardStack)[4])->num && (((*player)->playerCardStack)[0])->color && (((*player)->playerCardStack)[1])->color && (((*player)->playerCardStack)[2])->color && (((*player)->playerCardStack)[3])->color && (((*player)->playerCardStack)[4])->color)
			{
				for (int j = 0; j < MAX_PERSONNAL_CARDS; j++)
				{
					memcpy((((*player)->playerCardStack)[j])->num, g_initialCardNum, BYTES_FOR_SINGLE_NUM);
					memcpy((((*player)->playerCardStack)[j])->color, g_initialCardColor, BYTES_FOR_SINGLE_COLOR);
				}
			}
		}
		(*player)->chips = 50000;
		(*player)->round = 0;
	}
	return STATUS_SUCCESS;
}
GAME_STATUS killPlayerMemory(_OUT_ PPlayer* player)
{
	
	for (int j = 0; j < MAX_PERSONNAL_CARDS; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&((((*player)->playerCardStack)[j])->num)));
	}
	for (int j = 0; j < MAX_PERSONNAL_CARDS; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&((((*player)->playerCardStack)[j])->color)));
	}
	for (int j = 0; j < MAX_PERSONNAL_CARDS; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&(((*player)->playerCardStack)[j])));
	}
	ExFreeMemoryToNULL((PVOID)(&((*player)->playerCardStack)));
	ExFreeMemoryToNULL((PVOID)(&(*player)));
	return STATUS_SUCCESS;
}

这次是正确的。第一天有点问题，没free直接NULL了，虽然没报错但是不对。

目前没有任何问题。

目前新加的文件

//showHandPlayerDefs.h
#ifndef __showHandPlayerDefs__
#define __showHandPlayerDefs__
extern char* g_initialCardNum; // From cardFunctions.c extern g_initialCardNum
extern char* g_initialCardColor; // From cardFunctions.c extern g_initialCardColor
#include "showHandDefs.h"
GAME_STATUS initialPlayerInfo(_OUT_ PPlayer* player);
GAME_STATUS sentSingleCardToPlayer(_IN_ PCard card, _IN_ PPlayer player);
GAME_STATUS showPlayerCardStackValid(_IN_ PPlayer player);
GAME_STATUS resetPersonalChips(_IN_ PPlayer player, _IN_ ULONG newChip);
GAME_STATUS incGameRounds(_IN_ PPlayer player);
GAME_STATUS displaySinglePlayerAllInfo(_IN_ PPlayer player);
GAME_STATUS killPlayerMemory(_OUT_ PPlayer* player);
#endif
//playerFunctions.c
#include "showHandPlayerDefs.h"
#include "showHandPublicDefs.h"
GAME_STATUS initialPlayerInfo(_OUT_ PPlayer* player)
{
	(*player) = (PPlayer)malloc(sizeof(Player));
	if (*player)
	{
		(*player)->playerCardStack = (PCard*)malloc(MAX_PERSONNAL_CARDS * sizeof(PCard));
		if ((*player)->playerCardStack)
		{
			for (int j = 0; j < MAX_PERSONNAL_CARDS; j++)
			{
				((*player)->playerCardStack)[j] = (PCard)malloc(CARD_ATTRIBUTION_TYPES * sizeof(Card));
			}
		}
		if ((*player)->playerCardStack && ((*player)->playerCardStack)[0] && ((*player)->playerCardStack)[1] && ((*player)->playerCardStack)[2] && ((*player)->playerCardStack)[3] && ((*player)->playerCardStack)[4])
		{
			for (int j = 0; j < MAX_PERSONNAL_CARDS; j++)
			{
				(((*player)->playerCardStack)[j])->num = (char*)malloc(BYTES_FOR_SINGLE_NUM * sizeof(char));
				(((*player)->playerCardStack)[j])->color = (char*)malloc(BYTES_FOR_SINGLE_COLOR * sizeof(char));
			}
		}
		if ((*player)->playerCardStack && ((*player)->playerCardStack)[0] && ((*player)->playerCardStack)[1] && ((*player)->playerCardStack)[2] && ((*player)->playerCardStack)[3] && ((*player)->playerCardStack)[4])
		{
			if ((((*player)->playerCardStack)[0])->num && (((*player)->playerCardStack)[1])->num && (((*player)->playerCardStack)[2])->num && (((*player)->playerCardStack)[3])->num && (((*player)->playerCardStack)[4])->num && (((*player)->playerCardStack)[0])->color && (((*player)->playerCardStack)[1])->color && (((*player)->playerCardStack)[2])->color && (((*player)->playerCardStack)[3])->color && (((*player)->playerCardStack)[4])->color)
			{
				for (int j = 0; j < MAX_PERSONNAL_CARDS; j++)
				{
					memcpy((((*player)->playerCardStack)[j])->num, g_initialCardNum, BYTES_FOR_SINGLE_NUM);
					memcpy((((*player)->playerCardStack)[j])->color, g_initialCardColor, BYTES_FOR_SINGLE_COLOR);
				}
			}
		}
		(*player)->chips = 50000;
		(*player)->round = 0;
	}
	return STATUS_SUCCESS;
}
GAME_STATUS sentSingleCardToPlayer(_IN_ PCard card, _IN_ PPlayer player)
{
	int top = 0;
	for (int j = 0; j<MAX_PERSONNAL_CARDS; j++)
	{
		if (*(((player->playerCardStack)[j])->num) == '0')
		{
			top = j;
			break;
		}
	}
	memcpy(((player->playerCardStack)[top])->num, card->num, BYTES_FOR_SINGLE_NUM);
	memcpy(((player->playerCardStack)[top])->color, card->color, BYTES_FOR_SINGLE_COLOR);
	return STATUS_SUCCESS;
}
GAME_STATUS showPlayerCardStackValid(_IN_ PPlayer player)
{
	for (int j = 0; j < MAX_PERSONNAL_CARDS && *(((player->playerCardStack)[j])->num) != '0'; j++)
	{
		printf("Target Player's %ldth Card is %s%s\n", j + 1, ((player->playerCardStack)[j])->color, ((player->playerCardStack)[j])->num);
	}
	return STATUS_SUCCESS;
}
GAME_STATUS resetPersonalChips(_IN_ PPlayer player, _IN_ ULONG newChip)
{
	player->chips = newChip;
	return STATUS_SUCCESS;
}
GAME_STATUS incGameRounds(_IN_ PPlayer player)
{
	player->round++;
	return STATUS_SUCCESS;
}
GAME_STATUS displaySinglePlayerAllInfo(_IN_ PPlayer player)
{
	showPlayerCardStackValid(player);
	printf("Chips now: %ld\n", player->chips);
	printf("Round now: %ld\n", player->round);
	return STATUS_SUCCESS;
}
GAME_STATUS killPlayerMemory(_OUT_ PPlayer* player)
{
	
	for (int j = 0; j < MAX_PERSONNAL_CARDS; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&((((*player)->playerCardStack)[j])->num)));
	}
	for (int j = 0; j < MAX_PERSONNAL_CARDS; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&((((*player)->playerCardStack)[j])->color)));
	}
	for (int j = 0; j < MAX_PERSONNAL_CARDS; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&(((*player)->playerCardStack)[j])));
	}
	ExFreeMemoryToNULL((PVOID)(&((*player)->playerCardStack)));
	ExFreeMemoryToNULL((PVOID)(&(*player)));
	return STATUS_SUCCESS;
}

修改过的cardFunctions.c

#include "showHandCardDefs.h"
#include "showHandPublicDefs.h"
char* g_initialCardNum = (char*)"0\0";
char* g_initialCardColor = (char*)"无花";
GAME_STATUS initialCard(_OUT_ PCard* card, _IN_ char* num, _IN_ char* color)
{
	*card = (PCard)malloc(sizeof(Card));
	if (*card)
	{
		(*card)->num = (char*)malloc(BYTES_FOR_SINGLE_NUM * sizeof(char));
		if ((*card)->num)
		{
			memcpy((*card)->num, num, BYTES_FOR_SINGLE_NUM);
		}
		(*card)->color = (char*)malloc(BYTES_FOR_SINGLE_COLOR * sizeof(char));
		if ((*card)->color)
		{
			memcpy((*card)->color, color, BYTES_FOR_SINGLE_COLOR);
		}
	}
	return STATUS_SUCCESS;
}
GAME_STATUS initialSentCardsStack(_OUT_ PCard** stack)
{

	*stack = (PCard*)malloc(MAX_POSSIBLE_CARDS * sizeof(PCard));
	if (*stack)
	{
		for (int j = 0; j < MAX_POSSIBLE_CARDS; j++)
		{
			(*stack)[j] = (PCard)malloc(sizeof(Card));
		}
		for (int j = 0; j < MAX_POSSIBLE_CARDS; j++)
		{
			if(((*stack)[j]) != NULL)
			{
				((*stack)[j])->num = (char*)malloc(BYTES_FOR_SINGLE_NUM * sizeof(char));
				((*stack)[j])->color = (char*)malloc(BYTES_FOR_SINGLE_COLOR * sizeof(char));
			}
		}
		for (int j = 0; j < MAX_POSSIBLE_CARDS; j++)
		{
			if (((*stack)[j]) != NULL)
			{
				if ((*stack)[j]->num && (*stack)[j]->color && g_initialCardNum && g_initialCardColor)
				{
					memcpy(((*stack)[j])->num, g_initialCardNum, BYTES_FOR_SINGLE_NUM);
					memcpy(((*stack)[j])->color, g_initialCardColor, BYTES_FOR_SINGLE_COLOR);
				}
			}
		}
	}
	return STATUS_SUCCESS;
}
GAME_STATUS getCombinedInfo(_OUT_ char**** combinedInfo)
{
	*combinedInfo = (char***)malloc(2 * sizeof(char**));
	if (*combinedInfo)
	{
		(*combinedInfo)[0] = (char**)malloc(COUNT_OF_NUM * sizeof(char*));
		(*combinedInfo)[1] = (char**)malloc(COUNT_OF_COLOR * sizeof(char*));
	}
	if (*combinedInfo && (*combinedInfo)[0])
	{
		for (int j = 0; j < COUNT_OF_NUM; j++)
		{
			(*combinedInfo)[0][j] = (char*)malloc(BYTES_FOR_SINGLE_NUM * sizeof(char));
		}
	}
	if (*combinedInfo && (*combinedInfo)[1])
	{
		for (int j = 0; j < COUNT_OF_COLOR; j++)
		{
			(*combinedInfo)[1][j] = (char*)malloc(BYTES_FOR_SINGLE_COLOR * sizeof(char));
		}
	}
	char* Card_NUM_8 = (char*)"8\0";
	char* Card_NUM_9 = (char*)"9\0";
	char* Card_NUM_10 = (char*)"10";
	char* Card_NUM_J = (char*)"J\0";
	char* Card_NUM_Q = (char*)"Q\0";
	char* Card_NUM_K = (char*)"K\0";
	char* Card_NUM_A = (char*)"A\0";
	char* Card_COLOR_梅花 = (char*)"梅花";
	char* Card_COLOR_黑桃 = (char*)"黑桃";
	char* Card_COLOR_红桃 = (char*)"红桃";
	char* Card_COLOR_方片 = (char*)"方片";
	if (*combinedInfo && (*combinedInfo)[0] && (*combinedInfo)[0][0] && (*combinedInfo)[0][1] && (*combinedInfo)[0][2] && (*combinedInfo)[0][3] && (*combinedInfo)[0][4] && (*combinedInfo)[0][5] && (*combinedInfo)[0][6])
	{
		memcpy((*combinedInfo)[0][0], Card_NUM_8, BYTES_FOR_SINGLE_NUM);
		memcpy((*combinedInfo)[0][1], Card_NUM_9, BYTES_FOR_SINGLE_NUM);
		memcpy((*combinedInfo)[0][2], Card_NUM_10, BYTES_FOR_SINGLE_NUM);
		memcpy((*combinedInfo)[0][3], Card_NUM_J, BYTES_FOR_SINGLE_NUM);
		memcpy((*combinedInfo)[0][4], Card_NUM_Q, BYTES_FOR_SINGLE_NUM);
		memcpy((*combinedInfo)[0][5], Card_NUM_K, BYTES_FOR_SINGLE_NUM);
		memcpy((*combinedInfo)[0][6], Card_NUM_A, BYTES_FOR_SINGLE_NUM);
	}
	if (*combinedInfo && (*combinedInfo)[1] && (*combinedInfo)[1][0] && (*combinedInfo)[1][1] && (*combinedInfo)[1][2] && (*combinedInfo)[1][3])
	{
		memcpy((*combinedInfo)[1][0], Card_COLOR_梅花, BYTES_FOR_SINGLE_COLOR);
		memcpy((*combinedInfo)[1][1], Card_COLOR_黑桃, BYTES_FOR_SINGLE_COLOR);
		memcpy((*combinedInfo)[1][2], Card_COLOR_红桃, BYTES_FOR_SINGLE_COLOR);
		memcpy((*combinedInfo)[1][3], Card_COLOR_方片, BYTES_FOR_SINGLE_COLOR);
	}
	return STATUS_SUCCESS;
}
GAME_STATUS verifyCardAlreadySent(_IN_ PCard card, _IN_ PCard* stack, _OUT_ INT* flag, _OUT_ INT* loc)
{
	*flag = 1;
	*loc = 0;
	for (int j = 0; j < MAX_POSSIBLE_CARDS; j++)
	{
		if (strncmp(stack[j]->num, card->num, BYTES_FOR_SINGLE_NUM) == 0)
		{
			if (strncmp(stack[j]->color, card->color, BYTES_FOR_SINGLE_COLOR) == 0)
			{
				*flag = 0;
				*loc = j;
			}
		}
	}
	return STATUS_SUCCESS;
}
GAME_STATUS pushCardIntoStack(_IN_ PCard card, _IN_OUT_ PCard* stack)
{
	int top = 0;
	for (int j = 0; j < MAX_POSSIBLE_CARDS; j++)
	{
		if(*(stack[j]->num) == '0')
		{
			top = j;
			break;
		}
	}
	memcpy(stack[top]->num, card->num, BYTES_FOR_SINGLE_NUM);
	memcpy(stack[top]->color, card->color, BYTES_FOR_SINGLE_COLOR);
	return STATUS_SUCCESS;
}
GAME_STATUS displaySentStackValid(_IN_ PCard* stack)
{
	for (int j = 0; j < MAX_POSSIBLE_CARDS && *(stack[j]->num) != '0'; j++)
	{
		printf("%ld -> %s%s\n", j + 1, stack[j]->color, stack[j]->num);
	}
	return STATUS_SUCCESS;
}
GAME_STATUS displayAllStack(_IN_ PCard* stack)
{
	for (int j = 0; j<MAX_POSSIBLE_CARDS; j++)
	{
		printf("%ld -> %s%s\n", j + 1, stack[j]->color, stack[j]->num);
	}
	return STATUS_SUCCESS;
}
GAME_STATUS clearSentCardsStack(_IN_OUT_ PCard* stack)
{
	for (int j = 0; j < MAX_POSSIBLE_CARDS; j++)
	{
		memcpy(stack[j]->num, g_initialCardNum, BYTES_FOR_SINGLE_NUM);
		memcpy(stack[j]->color, g_initialCardColor, BYTES_FOR_SINGLE_COLOR);
	}
	return STATUS_SUCCESS;
}
GAME_STATUS killCardMemory(_OUT_ PCard* card)
{
	ExFreeMemoryToNULL((PVOID)(&((*card)->num)));
	ExFreeMemoryToNULL((PVOID)(&((*card)->color)));
	*card = NULL;
	return STATUS_SUCCESS;
}
GAME_STATUS killStackMemory(_OUT_ PCard** stack)
{
	for (int j = 0; j < MAX_POSSIBLE_CARDS; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&(((*stack)[j])->num)));
	}
	for (int j = 0; j < MAX_POSSIBLE_CARDS; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&(((*stack)[j])->color)));
	}
	for (int j = 0; j < MAX_POSSIBLE_CARDS; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&((*stack)[j])));
	}
	ExFreeMemoryToNULL((PVOID)(&(*stack)));
	return STATUS_SUCCESS;
}
GAME_STATUS killCombinedInfoMemory(_OUT_ char**** combinedInfo)
{
	for (int j = 0; j < COUNT_OF_NUM; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&((*combinedInfo)[0][j])));
	}
	for (int j = 0; j < COUNT_OF_COLOR; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&((*combinedInfo)[1][j])));
	}
	for (int j = 0; j < 2; j++)
	{
		ExFreeMemoryToNULL((PVOID)(&((*combinedInfo)[j])));
	}
	ExFreeMemoryToNULL((PVOID)(&(*combinedInfo)));
	return STATUS_SUCCESS;
}

今天到此为止！

m0_50198957
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【C 高阶】彻底理解数组与指针
Kong
12-03 753
C 高阶系列导航 0. 前言 本文将深入浅出地讲述数组与指针之间的共性与关联，适合有一定 C/C++ 功底的同学进阶学习。文中的程序均在 64 位环境下运行，且程序运行的结果会以注释的方式呈现在代码中以便阅读。 全文学习约需 15 分钟。 1. 数组和指针的本质 数组类型和指针类型都是 C 的特殊数据类型，这里的“特殊”是相对于整型、浮点型等基本数据类型来说的。 一般地，数组类型变量统称为...
C语言学习路线图：(阶段三) C语言函数参考手册
06-28
- 函数指针可以存储函数的地址，允许我们以指针的方式调用函数，这对于回调函数、高阶函数等场景非常有用。 - 例如，声明一个指向返回整型、接受两个整数参数的函数的指针： ```c int (*func_ptr)(int, int); `...
c语言算法高级,C语言简明教程（十九）：高级数据结构和算法详解
weixin_39617473的博客
05-21 953
数据结构和算法是C语言的主要内容，更特别在于C语言的数据结构和算法一般需要自己实现，与OOP语言不同，C标准库中没有提供相关的数据结构。Linux C标准库原为Linux Libc，现在常用的是GLibc，即GNU C Library，另外可用的库还有GTK的库Glib，POSIX标准库Gnulib，其中Glib中提供有完整的数据结构和相关算法操作。本文详细讨论C数据结构的标准定义及其算法实现，自...
【C++ 函数式编程 】C++中的高阶函数：以std::function优雅地实现回调
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
05-29 2664
高阶函数的一个重要应用就是回调函数（Callback Function）。回调函数是一个在某个事件发生时被调用的函数，它经常被用在异步操作、事件驱动的编程模式和遍历操作等场景。在C++中，`std::function`也经常被用作回调函数，因为它能够提供一种灵活的机制，允许我们自定义或改变函数的行为。
c 语言函数指针和高级语言闭包区别
tzshlyt的专栏
03-11 921
高阶函数 所谓高阶函数，就是用函数作为参数的函数。 函数指针 typedef void (*func_t)(int); void foreach(struct node *list, func_t func) { while (list) { func(list->val); list = list->next; } } void f(int n) { printf("node(?) = %d\n", n); } int main() { st
8.c语言高级编程
qq_26511221的博客
03-07 495
c高级编程
嵌入式C语言高级知识点总结
weixin_56940389的博客
04-18 2141
预处理， 展开头文件/宏替换/去掉注释/条件编译 （test.i main .i）编译（gcc -s）， 检查语法，生成汇编 （ test.s main .s）汇编（gcc -c）， 汇编代码转换机器码 (test.o main.o)
C语言学习笔记—P31（＜C语言高阶＞+动态内存管理+题例+图解）
m0_57859086的博客
02-04 357
“海压竹枝低复举，风吹山角晦还明。” ——宋·陈与义《观雨》 目录 本章重点 1. 为什么存在动态内存分配 2. 动态内存函数的介绍 2.1 malloc和free 2.2 calloc 2.3 realloc 3. 常见的动态内存错误 3.1 对NULL指针的解引用操作 3.2 对动态开辟空间的越界访问 3.3 对非动态开辟内存使用free释放 3.4 使用free释放一块动态开辟内存的一部分 3.5 对同一块动态内......
零基础学c语言 第2版,零基础学C语言(第2版)(1张) 康莉 等 机械工业出版社 9787111372929...
weixin_30490029的博客
05-21 194
商品描述：基本信息书名:零基础学C语言(第2版)(1张)定价：59.00元作者:康莉等著出版社：机械工业出版社出版日期：2012-04-01ISBN：9787111372929字数：页码：424版次：2装帧：平装开本：16开商品重量：编辑推荐《零基础学C语言(第2版)》由浅入深，循序渐进，从零开始学C语言，一点都不难。　　编程基础、编程进阶、编程应用、项目实战、上机练习、面试指南。　...
C语言知识总结笔记，谭浩强C语言第五版 + 工作补充【10000字】【难点辨析、得意之作】【进阶版】【原创】
本不平凡
03-06 2501
C语言知识总结笔记，谭浩强C语言第五版 + 工作补充【10000字】【难点辨析、得意之作】【进阶版】【原创】
C语言高级编程及实例部析.rar
05-18
8. **并发编程**：虽然C语言本身不支持高阶的并发模型，但通过系统调用如fork()、pthread_create()等，可以在多处理器环境下编写并发程序。 9. **高级数据结构**：C语言常用于实现各种高级数据结构，如栈、队列、...
基于C语言的计算机编程技术分析 (1).pdf
09-19
- 函数指针：C语言允许使用函数指针，这使得函数可以作为参数传递，也可以作为其他函数的返回值，为实现回调机制和高阶函数提供了可能。 3. 内存管理 - 静态与动态内存：C语言提供了静态（auto、static）和动态...
C语言程序设计课件.rar
12-07
- 函数指针：学习如何使用函数指针，实现回调和高阶函数功能。 4. **数组**： - 一维数组：掌握数组的声明、初始化和访问方式。 - 多维数组：理解二维数组和其他多维数组的概念及其应用。 - 动态数组：通过...
C语言面试大全（100题）C语言面试大全（100题）
03-22
- **函数指针**：使用函数指针作为参数或返回值，实现回调和高阶函数。 5. **数组与指针**： - **一维数组**：声明、初始化和访问数组元素。 - **多维数组**：二维数组的概念及操作方法。 - **指针**：指针的...
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
最新发布
qq_44962949的博客
07-17 33
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 1054
c++ primer plus 第16章string 类和标准模板库,string 类输入。
学懂C语言系列（三）：C语言基本语法
martian665的专栏
07-17 374
学懂C语言系列,C语言基本语法
c++ 生成随机字符串
m0_56306892的博客
07-15 199
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C语言学习第八章(共30张PPT).pptx
11-14
"C语言学习资料，讲解了C语言中的变量作用域和存储类别，包括局部变量和全局变量的概念和使用规则。" 在C语言中，变量的定义和使用是编程的基础，而变量的作用域和存储类别是理解程序执行流程的关键。本资料详细...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值