自行封装一个栈的类，包含私有成员的属性：栈的数组，记录栈顶的变量
成员函数：构造函数、析构函数、拷贝构造函数、入栈、出栈、清空栈、判空、判满、获取栈顶元素、求站的大小
头文件
#ifndef STACK_H
#define STACK_H
#include <iostream>
using namespace std;
class st
{
private:
//记录栈顶的变量
int top;
//使用指针来存储栈
int *data;
public:
//构造函数
st():top(-1),data(new int[5])
{
cout<<"无参构造函数"<<endl;
}
//析构函数
~st()
{
delete []data; //释放成员指针的空间
cout<<"析构函数:"<<endl;
}
//拷贝构造函数
st(const st &other):data(new int(*other.data))
{
cout<<"拷贝构造函数:"<<endl;
}
//入栈
int stack_in(int e,int *data);
//遍历栈
void stack_show(int *data);
//出栈
int stack_out(int *data);
//清空栈
void stack_clear(int *data);
//判空
int stack_empty(int *data);
//判满
int stack_full(int *data);
//获取栈顶元素
int *stack_top(int *data);
//求栈的大小
int stack_size(int *data);
};
#endif // STACK_H
功能函数
#include "stack.h"
//入栈
int st::stack_in(int e,int *data)
{
if(nullptr == data||stack_full(data))
{
cout<<"入栈失败!"<<endl;
return -1;
}
//先加后压
top++;
data[top] =e; //将数据存放到栈中
cout<<"入栈成功"<<endl;
return 1;
}
//遍历栈
void st::stack_show(int *data)
{
if(nullptr == data||stack_empty(data))
{
cout<<"遍历失败!"<<endl;
return ;
}
//开始遍历
cout<<"从栈顶到栈底的元素是:";
for(int i=top;i>=0;i--)
{
cout<<" "<<data[i];
}
return ;
}
//出栈
int st::stack_out(int *data)
{
if(nullptr ==data||stack_empty(data))
{
cout<<"出栈失败!"<<endl;
return -1;
}
//先弹后减
int e = data[top];
top--;
cout<<"出栈成功!"<<endl;
return 0;
}
//清空栈
void st::stack_clear(int *data)
{
//判断逻辑
if(nullptr==data)
{
cout<<"清空失败!"<<endl;
return ;
}
delete []data;
data =nullptr;
return;
}
//判空
int st::stack_empty(int *data)
{
if(nullptr != data)
{
return top == -1;
}
cout<<"栈不合法!"<<endl;
return 0;
}
//判满
int st::stack_full(int *data)
{
if(nullptr != data)
{
return top == sizeof(int[5])-1;
}
cout<<"栈不合法!"<<endl;
return 0;
}
//获取栈顶元素
int *st::stack_top(int *data)
{
if(nullptr == data||stack_empty(data))
{
cout<<"获取失败!"<<endl;
return nullptr;
}
cout<<"栈顶元素是:"<<data[top]<<endl;
return &data[top];
}
//求栈的大小
int st::stack_size(int *data)
{
if(nullptr != data)
{
cout<<"栈的大小是:"<<top+1<<endl;
return top+1;
}
cout<<"不合法!"<<endl;
return 0;
}
主函数
#include "stack.h"
int main()
{
st s1;
int stack[5];
//入栈
s1.stack_in(3,stack);
s1.stack_show(stack);
s1.stack_top(stack);
s1.stack_size(stack);
s1.stack_in(4,stack);
s1.stack_show(stack);
s1.stack_top(stack);
s1.stack_size(stack);
s1.stack_in(5,stack);
s1.stack_show(stack);
s1.stack_top(stack);
s1.stack_size(stack);
s1.stack_in(6,stack);
s1.stack_show(stack);
s1.stack_top(stack);
s1.stack_size(stack);
s1.stack_in(7,stack);
s1.stack_in(7,stack);
s1.stack_in(7,stack);
s1.stack_in(7,stack);
//遍历栈
s1.stack_show(stack);
//出栈
s1.stack_out(stack);
s1.stack_out(stack);
s1.stack_out(stack);
s1.stack_out(stack);
s1.stack_out(stack);
s1.stack_out(stack);
//遍历栈
s1.stack_show(stack);
//获取栈顶元素
s1.stack_show(stack);
s1.stack_top(stack);
s1.stack_size(stack);
//求栈的大小
//清空栈
s1.stack_clear(stack);
return 0;
}
封装一个循环顺序队列的类，包含私有成员属性：存放队列的数组、队头位置、队尾位置
成员函数：构造函数、析构函数、拷贝构造函数、入队、出队、清空队列、判空、判满、求队列大小
头文件
#ifndef QUEUE_H
#define QUEUE_H
#include <iostream>
using namespace std;
class queue
{
private:
//存放队列的数组
int *data;
//队头位置下标
int head;
//队尾位置下标
int tail;
public:
//构造函数
queue():data(new int[5]),head(tail=0),tail(head=0)
{
cout<<"无参构造函数"<<endl;
}
//析构函数
~queue()
{
delete []data;
cout<<"析构函数"<<endl;
}
//拷贝构造函数
queue(const queue &other):head(other.head),tail(other.tail),data(new int(*other.data))
{
cout<<"拷贝构造函数"<<endl;
}
//判空
int queue_empty(int *data);
//判满
int queue_full(int *data);
//入队
int queue_in(int e,int *data);
//遍历
void queue_show(int *data);
//出队
int queue_out(int *data);
//求队列大小
int queue_size(int *data);
//清空队列
void queue_clear(int *data);
};
#endif // QUEUE_H
功能函数
#include "queue.h"
//判空
int queue::queue_empty(int *data)
{
if(nullptr == data)
{
cout<<"不合法!"<<endl;
return -1;
}
return head == tail;
}
//判满
int queue::queue_full(int *data)
{
if(nullptr == data)
{
cout<<"不合法!"<<endl;
return -1;
}
return (tail+1)%20 == head;
}
//入队
int queue::queue_in(int e,int *data)
{
//判断逻辑
if(nullptr==data||queue_full(data))
{
cout<<"队列已经满了，无法入队!"<<endl;
return -1;
}
//入队逻辑,将数据放在队尾所在的地方
data[tail] = e;
//队尾后移
tail = (tail+1)%20;
cout<<"入队成功\n";
return 0;
}
//遍历
void queue::queue_show(int *data)
{
//判断逻辑
if(nullptr==data||queue_empty(data))
{
cout<<"队列不合法"<<endl;
return ;
}
for(int i=head;i!=tail;i=(i+1)%20)
{
cout<<data[i]<<" ";
}
cout<<"遍历成功!"<<endl;
}
//出队
int queue::queue_out(int *data)
{
//判断逻辑
if(nullptr==data||queue_empty(data))
{
cout<<"队列不合法"<<endl;
return -1;
}
//出队逻辑
//将队头所在的位置元素删除,先进先出
int e = data[head];
//队头后移
head =(head+1)%20;
cout<<"出队成功"<<endl;
return 0;
}
//求队列大小
int queue::queue_size(int *data)
{
//判断逻辑
if(nullptr==data||queue_empty(data))
{
cout<<"队列不合法"<<endl;
return -1;
}
return (tail-head+20)%20;
}
//清空队列
void queue::queue_clear(int *data)
{
if(nullptr!=data)
{
delete [] data;
data = nullptr;
cout<<"释放成功!"<<endl;
return ;
}
cout<<"队列不合法！"<<endl;
}
主函数
#include "queue.h"
int main()
{
//实例化对象
queue q1;
int d[5];
//入队
q1.queue_in(1,d);
q1.queue_in(2,d);
q1.queue_in(3,d);
q1.queue_show(d);
q1.queue_in(4,d);
q1.queue_in(10,d);
q1.queue_in(13,d);
q1.queue_show(d);
q1.queue_in(16,d);
//遍历
q1.queue_show(d);
//出队
q1.queue_out(d);
q1.queue_show(d);
//求队列大小
int len =q1.queue_size(d);
cout<<"len = "<<len<<endl;
return 0;
}
![[杂谈]-电动汽车有哪些不同类型](https://img-blog.csdnimg.cn/84c6a48a71d6439d85dd848281bf5fa9.png#pic_center)
