1. 用C++或Java写一个关于堆栈的类描述，并为堆栈的压栈（push）和出栈（pop）操作编写方法

Posted 2023-05-10

#include<iostream.h>
using namespace std;
const int MAX=5; //假定栈中最多保存5个数据
//定义名为stack的类，其具有栈功能
class stack
//数据成员
float num[MAX]; //存放栈数据的数组
int top; //指示栈顶位置的变量
public:
//成员函数
void init(void) top=0; //初始化函数
void push(float x) //入栈函数

if (top==MAX)
cout<<"Stack is full !"<<endl;
return;
;
num[top]=x;
top++;

float pop(void) //出栈函数

top--;
if (top<0)
cout<<"Stack is underflow !"<<endl;
return 0;
;
return num[top];


//以下是main()函数，其用stack类创建栈对象，并使用了这些对象
main(void)

//声明变量和对象
int i;
float x;
stack a,b; //声明(创建)栈对象
//以下对栈对象初始化
a.init();
b.init();
//以下利用循环和push()成员函数将2,4,6,8,10依次入a栈对象
for (i=1; i<=MAX; i++)
a.push(2*i);
//以下利用循环和pop()成员函数依次弹出a栈中的数据并显示
for (i=1; i<=MAX; i++)
cout<<a.pop()<<" ";
cout<<endl;
//以下利用循环和push()成员函数将键盘输入的数据依次入b栈
cout<<"Please input five numbers."<<endl;
for (i=1; i<=MAX; i++)
cin>>x;
b.push(x);

//以下利用循环和pop()成员函数依次弹出b栈中的数据并显示
for (i=1; i<=MAX; i++)
cout<<b.pop()<<" ";
参考技术A #include<iostream>
using namespace std;
class sStack;
class sStack

public:
sStack();
sStack(int a,sStack *p=NULL)

num = a;
next = p;

void push();
void pop();
void display()

cout<<num<<"\t";

void play()

sStack *p=sStack::top;
while(p!=NULL)
p->display();
p=p->next;


protected:
static sStack *top;
int num;
sStack *next;
;
sStack* sStack::top = NULL;
void sStack::push()//压栈

if(sStack::top == NULL)

next = NULL;

next = sStack::top;
sStack::top = this;

void sStack::pop()

if(sStack::top!=this)
cout<<"不可出栈"<<endl;
else
sStack::top = this->next;
this->next = NULL;



int main()

sStack s1(1); sStack s2(2); sStack s3(3);
//入栈
s1.push(); s1.play();cout<<endl;
s2.push(); s2.play();cout<<endl;
s3.push(); s3.play();cout<<endl;
//出栈
s3.pop(); s3.play();cout<<endl;
s2.pop(); s2.play();cout<<endl;
s1.pop(); s1.play();cout<<endl;
return 0;


我写了一个很简单的 很短 你扩充下就可以了 参考技术B 上楼的回答得很好了，顶一个！

ZeroC ICE源代码中的那些事 - 嵌套类和局部类

使用嵌套类（类中定义的类，c++没有静态类）或局部类（在函数或成员方法中定义的类），进行行为模式的委托（委托请求）或异步
。
java中嵌套类和局部类隐式完成了你对外部对象（实例）访问的私有堆栈的初始化，而c++你必须通过类成员变量来保存你要访问到的
外部对象（变量，实例），即自行实现私有堆栈，并使用嵌套类和局部类的构造函数，以参数传递的方式初始化这些用作私有堆栈的成
员变量。当你的局部类（在函数中定义的类）要访问到函数的局部变量时，你并不能确保局部类在局部变量被释放前访问，所以你只能
将局部变量进行拷贝复制到你的局部类的私有堆栈（c++中由你自行用成员变量实现），并且复制成const变量，表明你不会去对这些变
量进行修改，因为即使你进行修改也不是真的对局部类外部的堆栈局部变量进行修改，你只是对一分私有副本进行访问修改。在java中
由语法检查器为我们检查是否在访问一个Final变量。在java中你可以很自然地使用嵌套类或局部类进行行为模式的委托，因为嵌套类
或局部类可以直接访问到将它们（new）实例化的（某对象的成员）方法的上下文this引用。而在c++中你必须还要使用成员变量保存这
个外部上下文中的this，还要在构造函数中对其进行初始化。当然还要将你的声明为私有的嵌套类声明为外部类的友元，从而获得对外
部类的全部访问权限。
java相比于c++，还有一种特殊的局部类，就是匿名局部类，可以在new的同时override对象的方法。
不难想象，其实ObjectC的执行块（Block，以^开头定义的执行块），其实质也是一个匿名的局部类，编译器自动为你完成这个匿名的
局部类访问到外部变量的私有堆栈。事实上Block就是一个类。请参看《objc反汇编分析，block函数块为何物？》。
同样c++11中也有等价物，就是lambda。你必须在lambda声明中的[]内设计你的私有堆栈，官方名称是capture list，不同于其它语言
的是你可以指定私有堆栈上变量的副本类型，是copy还是引用。
c++使用嵌套类或局部类进行委托是十分不方便的，因为c++中的实例的生命期并不被管理，必须由程序员自己管理。即使有了
shared_ptr等指针管理器的帮助，还是不能随意地就可以使用嵌套类或局部类进行委托。因为有时候委托中还必须依赖其它对象的协作
，而这些对象可能来自其它库或子系统，并没有一套统一的对象生命期管理，你还是不得不在你的委托中加入这些生命期管理和代码，
这些委托同时可能需要进行异步。在Ice编程环境中，统一使用了生命期管理，所以Ice内核代码中就有不少地方使用了嵌套类或局部类
进行委托以及异步，这样的编程在Java项目中十分常见的，但在c++项目中就比较罕见，一般只使用嵌套类或局部类定义一些结构体。
常见的使用局部类进行异步的有，Java的Runnable，ObjectC的dispatch_async，通常都会将函数一部分逻辑异步到其它地方；或者将
一部分逻辑嵌入到其它回调框架中，Java的匿名局部类Override回调类，ObjectC使用Block块，而这些回调都意味着函数的一部分逻辑
异步到别的地方去。这样的方便就是，我们不用通过对我们的知名类进行接口继承，写另外一些成员函数的实现。
我们现在开始，提及的嵌套类（c++中我们包含了对外部类实例的引用，并声明为外部类的友元）。我们使用嵌套类进行委托，也同时
可以减少对框架接口的继承，我们可以通过嵌套类完成模式上的事情，将扩展的功能委托给嵌套类。例如我们的类要在别的框架内运行
，我们必须实现其中的一些回调接口。我们的类每参与到一个框架中，都必须去继承一个或多个接口，这时我们可以通过嵌套类来为我
们完成这些继承，我们将一切委托给嵌套类。嵌套类成了外部类的一个代理（proxy），或组合成其它模式，因为外部类已经组合到嵌
套类。通常使用嵌套类都不会局限于完成一些同步进行的操作，往往都去参与异步的回调。
过多的异步和回调，往往意味着逻辑（代码）的支离破碎，让人难以理解。