当前位置：首页 > news >正文

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

news 2025/10/6 7:06:07

在这里插入图片描述

💻作者简介：曾与你一样迷茫，现以经验助你入门 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” 实现，还是使用链表的 “头插法” 实现。

#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 语言实现栈

#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：

#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，能帮助开发者从 “关注代码细节” 提升到 “设计数据模型” 的更高层次。

查看全文

http://www.dtcms.com/a/445982.html