C和C++实现stack的对比

news2024/9/20 14:47:25

本篇文章，我们将对比C语言和C++实现栈的不同来体会C++的魅力！

1.栈的介绍

栈（Stack）是一种常见的数据结构，它是一种特殊的线性表，只允许在一端进行数据的插入和删除操作。这一端通常被称为栈顶（Top），而另一端则被称为栈底（Bottom）。栈的操作遵循后进先出（Last In First Out，简称LIFO）的原则，即最后进入栈的元素将会最先被移除。

1.1基本特征

后进先出：最后插入的元素最先被删除。
单端操作：所有的插入和删除操作都在栈顶进行。
动态大小：栈的大小可以根据需要动态调整，但在某些实现中，栈的大小可能是固定的。

1.2基本操作

初始化（Initialize）：创建一个空的栈。
压栈（Push）：在栈顶插入一个新的元素。
出栈（Pop）：从栈顶删除一个元素，并返回该元素。
获取栈顶元素（Peek/Top）：返回栈顶元素的值，但不删除该元素。
判断栈是否为空（IsEmpty）：检查栈是否为空。
获取栈的大小（Size）：返回栈中元素的数量。
清空栈（Clear）：移除栈中的所有元素。
销毁栈（Destroy）：释放栈所占用的内存资源

1.3实现方式

数组实现：使用数组来存储栈中的元素，栈的大小在创建时确定，可能存在上溢问题。
链表实现：使用链表来存储栈中的元素，链栈没有固定的大小限制，可以动态扩展。

1.4应用场景

函数调用：在程序中，函数调用的顺序通常使用栈来管理。
表达式求值：在计算表达式时，使用栈来存储操作数和运算符。
括号匹配：检查括号是否成对出现，常用于编译器的语法分析。
逆波兰表达式转换：将中缀表达式转换为后缀表达式（逆波兰表达式）。

栈是一种非常高效的数据结构，因为它只允许在一端进行操作，这使得插入和删除操作的时间复杂度都是O(1)。在许多编程语言中，栈已经作为内置的数据类型被实现，如C++中的stack，Java中的Stack类等。

2.C语言实现栈

stack.c

#include<stdio.h>
#include<assert.h>
typedef int DataType;
typedef struct Stack
{
	DataType* array;
	int capacity;
	int size;
}Stack;

void StackInit(Stack* ps)
{
	assert(ps);
	ps->array = (DataType*)malloc(sizeof(DataType) * 3);
	if (NULL == ps->array)
	{
		assert(0);
		return;
	}
	ps->capacity = 3;
	ps->size = 0;
}

void StackDestroy(Stack* ps)
{
	assert(ps);
	if (ps->array)
	{
		free(ps->array);
		ps->array = NULL;
		ps->capacity = 0;
		ps->size = 0;
	}
}

void CheckCapacity(Stack* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity * 2;
		DataType* temp = (DataType*)realloc(ps->array, newcapacity * sizeof(DataType));
		if (temp == NULL)
		{
			perror("realloc申请空间失败！！");
			return;
		}
		ps->array = temp;
		ps->capacity = newcapacity;
	}
}
void StackPush(Stack* ps, DataType data)
{
	assert(ps);
	CheckCapacity(ps);
	ps->array[ps->size] = data;
	ps->size++;
}

int StackEmpty(Stack* ps)
{
	assert(ps);
	return 0 == ps->size;
}

void StackPop(Stack* ps)
{
	if (StackEmpty(ps))
		return;
	ps->size--;
}

DataType StackTop(Stack* ps)
{
	assert(!StackEmpty(ps));
	return ps->array[ps->size - 1];
}

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->size;
}

test.c

int main()
{
	Stack s;
	StackInit(&s);

	StackPush(&s, 1);
	StackPush(&s, 2);
	StackPush(&s, 3);
	StackPush(&s, 4);
	printf("%d\n", StackTop(&s));
	printf("%d\n", StackSize(&s));

	StackPop(&s);
	StackPop(&s);
	printf("%d\n", StackTop(&s));
	printf("%d\n", StackSize(&s));

	StackDestroy(&s);
	return 0;
}

从以上代码，我们可以看到，用C语言实现栈时，Stack相关操作函数有以下共性

每个函数的第一个参数都是Stack*
函数中必须要对第一个参数检测，因为该参数可能是NULL
函数中都是通过Stack*参数来操作栈的
调用时必须传递Stack结构体变量的地址

结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体里，即数据和操作数据的方式是分离开的。

3.C++实现栈（手搓版ovo）

stack.cpp

typedef int DataType;
class Stack
{
public:
	void Init()
	{
		_array = (DataType*)malloc(sizeof(DataType*) * 3);
		if (NULL == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = 3;
		_size = 0;
	}

	void Push(DataType data)
	{
		CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	void Pop()
	{
		if (Empty())
			return;
		_size--;
	}

	DataType Top() { return _array[_size - 1]; }
	int Empty() { return 0 == _size; }
	int Size() { return _size; }

	void Destroy()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	void CheckCapacity()
	{
		if (_size == _capacity)
		{
			int newcapacity = _capacity * 2;
			DataType* temp = (DataType&)realloc(_array, newcapacity * sizeof(DataType));
			if (temp == NULL)
			{
				perror("realloc申请空间失败");
				return;
			}
			_array = temp;
			_capacity = newcapacity;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

test.cpp

int main()
{
	Stack s;
	s.Init();
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);

	printf("%d\n", s.Top());
	printf("%d\n", s.Size());

	s.Destroy();
	return 0;
}

C++通过类可以将数据以及操作数据的方法进行完美结合，通过访问权限可以控制那些方法在类外被调用，即封装，在使用时就像使用自己的成员一样，更符合人类对一件事情的认知。

而且每个方法不需要传递Stack*的参数了，编译器编译之后该参数会自动还原。即C++中Stack*参数是编译器维护的，C语言需要自己维护。

总之，从C语言到C++实现Stack类的转变，可以明显体会到C++在面向对象编程、封装、代码复用、异常处理等方面的优势。这些特性使得C++更适合于开发大型、复杂的应用程序。