【c++】面向对象与抽象数据类型

💻作者简介：曾与你一样迷茫，现以经验助你入门 C++。

💡个人主页：@笑口常开xpr 的个人主页

📚系列专栏：C++ 炼魂场：从青铜到王者的进阶之路✨代码趣语：ADT 是 "装修效果图" - - - 先画好图（逻辑定义），施工队（数据结构）怎么砌墙（数组 / 链表）我不管，结果对就行。

💪代码千行，始于坚持，每日敲码，进阶编程之路。

📦gitee 链接：gitee

写 C/C++ 时，想实现 "栈" 却先纠结用数组还是链表？其实不用！抽象数据类型（ADT）就是解决这一问题的关键。本文拆解 ADT 的 "抽象 + 封装" 核心，结合栈的案例对比 C/C++ 实现，帮你搞懂 ADT 为何是数据结构与面向对象编程的 "桥梁"，摆脱 "先纠结实现、再迷失逻辑" 的困境。

一、抽象数据类型的定义

抽象数据类型（ADT）是计算机科学中描述数据结构的逻辑层面概念，它聚焦于 "数据是什么" 和 "数据能做什么"，而刻意隐藏 "数据如何实现" 的细节，比如 C/C++ 中头文件提供的函数，即隐藏内部实现细节，只提供相关的函数供用户使用。其核心思想是封装与抽象，将数据的 "逻辑特性" 与 "物理实现" 分离，从而降低程序复杂度、提高代码复用性和可维护性。

二、ADT 的核心定义

ADT 本质上是一个 "数据模型"，使用 3 个部分构成，即数据对象（D），数据关系（R）和基本操作（P）。通常使用 "三元组" 表示：ADT = (D, R, P)。

组成部分	核心含义	举例说明
数据对象（D）	具有相同性质的数据元素的集合	"栈"的数据对象是 "所有整数的集合"
数据关系（R）	数据对象中元素之间的逻辑关系集合	"栈"的数据关系是元素按'后进先出'的顺序排列
基本操作（P）	数据对象的合法操作	"栈"的基本操作包括：Push(入栈)、Pop(出栈)、GetTop(取栈顶)、IsEmpty(判断空)等

三、ADT 的核心思想

ADT 的核心价值在于解决 "用户无需关心内部实现，只需关注如何使用" 的问题，这依赖于两个关键思想：

（1）抽象

抽象是只暴露 "关键信息"。对使用者而言，只需知道 ADT 的函数（用来做什么，如何使用），无需知道内部如何存储数据（如栈是用数组还是链表实现）、如何执行操作（如 Pop 时如何移动指针）。
例如 ：C++ 使用 "栈" 时，你只需先引用头文件#include<stack>，然后调用 push(x) 就能让 x 入栈，不需要关心栈是用数组的 "下标 + 1" 实现，还是使用链表的 "头插法" 实现。

javascript 复制代码

#include<iostream>
#include<stack>
using namespace std;
int main()
{
	stack<int> mystack;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		mystack.push(i);
	}
	while (!mystack.empty())
	{
		cout << mystack.top() << " ";
		mystack.pop();
	}
	cout << endl;
	return 0;
}

（2）封装

封装是隐藏内部的 "实现细节" 将 ADT 的 "数据存储（如数组、链表）" 和 "操作实现（如 push 的代码）" 封装成一个独立的模块即头文件 stack，不允许用户直接修改内部数据，只能通过定义好的 "基本操作"（函数）访问。
好处：若后续需要修改实现（如把 "数组栈" 改成 "链表栈"），只要保持操作接口不变，所有使用该 ADT 的代码都无需修改，极大降低维护成本。

四、经典 ADT 示例 - - - 栈

为了更直观理解 ADT，这里采用自然语言完整描述 "栈" 的 ADT 定义。

（1）数据对象（D）

D = {a₀, a₁, ..., aₙ₋₁ | aᵢ ∈ 整数集合，i = 0, 1, ..., n-1, n ≥ 0}

（2）数据关系（R）

R = {<aᵢ₋₁, aᵢ> | aᵢ₋₁ 是 aᵢ 的前一个元素，且 aₙ₋₁ 是栈顶元素，元素只能从栈顶插入 / 删除 }（即 "后进先出" 关系）

（3）基本操作（P）

这里需要注意的是如果 C++ 中引入了头文件 stack，则无需写栈的初始化函数，因为栈属于内置类型，编译器会自动生成栈的构造函数。

操作名称	前置条件	功能	后置条件
构造函数	无	初始化一个空栈S	S为空栈
push	栈未满	将元素x插入栈顶	栈顶元素变为x，栈长度+1
pop	S 非空	删除栈顶元素	栈顶元素变为原栈顶的下一个元素，栈长度-1
top	S 非空	得到栈顶元素	栈的结构不发生改变

五、ADT 与 "数据结构" 的区别

很多人会混淆 ADT 和数据结构，核心区别在于 逻辑层面 与 物理层面 的区别。

对比维度	抽象数据类型（ADT）	数据结构
关注层面	逻辑层面（"做什么"）	物理层面（"怎么做"）
核心内容	定义数据的逻辑关系和操作接口	实现ADT的具体方式（如用数组 / 链表存储数据）
示例	"栈"的ADT（定义后进先出关系和具体操作关系）	"数组实现的栈"、"链表实现的栈"
关系	ADT是"需求"，数据结构是"实现方案"	一个ADT可以对应多种数据结构（如栈可由数组或链表实现）

六、ADT 的核心优势

降低耦合度：修改内部实现不会影响用户代码。
提高复用性：ADT 的接口是标准化的（如栈的 push/pop），可在不同程序中直接复用。
增强安全性：禁止用户直接操作内部数据，避免因非法修改导致的逻辑错误（如直接修改栈的数组下标导致越界访问）。
简化程序逻辑：用户无需关注底层细节，只需聚焦实现逻辑（如用栈解决 "括号匹配" 问题时，只需调用 push/pop，无需关心栈的存储）。

七、ADT 的应用：面向对象编程的基础

（1）类

ADT 的思想直接催生了面向对象编程的核心概念 - - - 类（Class）

类的 成员变量 对应 ADT 的 "数据对象（D）" 和 "数据关系（R）"；
类的 成员方法 对应 ADT 的 "基本操作（P）"；
类的 "访问控制（public/private）" 实现了 ADT 的 "封装"（private 隐藏实现，public 暴露接口）。

（2）C 语言实现栈

javascript 复制代码

#include<stdio.h>
#include<assert.h>
#include<stdlib.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;
}
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 结构体变量的地址

C 语言中结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出错。

（3）C++ 实现栈

在 C++ 中，用类实现 "栈" 的 ADT：

javascript 复制代码

#include<iostream>
using namespace std;
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;
};
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.Pop();
	s.Pop();
	printf("%d\n", s.Top());
	printf("%d\n", s.Size());
	s.Destroy();
	return 0;
}

C++ 是面向对象的编程语言，面向对象围绕的是 对象 和 对象 之间的交互，强调的是 做什么。C++ 中通过类可以将数据以及操作数据的方法进行完美结合，通过访问权限可以控制那些方法在类外可以被调用，即封装，在使用时就像使用自己的成员一样，更符合人类对一件事物的认知。而且每个方法不需要传递 Stack* 的参数了，编译器编译之后该参数会自动还原，即 C++ 中 Stack* 参数是 this 指针，它是由编译器维护的，C 语言中需要用户自己维护。

八、总结

抽象数据类型（ADT）是一种 "从问题出发" 的思维方式：它先定义数据的逻辑特性和操作能力，再通过具体的数据结构（数组、链表等）实现。其核心价值在于 "分离逻辑与实现"，是降低程序复杂度、提高代码质量的关键工具，也是面向对象编程的理论基础。掌握 ADT，能帮助开发者从 "关注代码细节" 提升到 "设计数据模型" 的更高层次。

【c++】面 向 对 象 与 抽 象 数 据 类 型

一、抽 象 数 据 类 型 的 定 义

二、ADT 的 核 心 定 义

三、ADT 的 核 心 思 想

（1）抽 象

（2）封 装

四、经 典 ADT 示 例 - - - 栈

（1）数 据 对 象（D）

（2）数 据 关 系（R）

（3）基 本 操 作（P）

五、ADT 与 "数 据 结 构" 的 区 别

六、ADT 的 核 心 优 势

七、ADT 的 应 用：面 向 对 象 编 程 的 基 础

（1）类

（2）C 语 言 实 现 栈

（3）C++ 实 现 栈

八、总 结

【c++】面向对象与抽象数据类型

一、抽象数据类型的定义

二、ADT 的核心定义

三、ADT 的核心思想

（1）抽象

（2）封装

四、经典 ADT 示例 - - - 栈

（1）数据对象（D）

（2）数据关系（R）

（3）基本操作（P）

五、ADT 与 "数据结构" 的区别

六、ADT 的核心优势

七、ADT 的应用：面向对象编程的基础

（2）C 语言实现栈

（3）C++ 实现栈

八、总结