C++题目练习07
7.1流插入运算符重载：编写一个stack类.part.4
描述
编写一个 stack栈类，在上一题的基础上：
（上一题指路 C++题目练习02 2.2）
取消 output()函数，重载运算符 << ：第一行输出当前栈内元素个数，如果栈空，输出 0；
如果栈不空，第二行自栈底到栈顶，输出栈内元素，每个元素后跟一个空格。
如果栈空，第二行没有输出。
输入描述
在上一题的基础上增加一类指令：
8 ：表示使用运算符<< 输出当前的栈对象
第一行是一个整数m，表示创建一个容量为m的栈对象。
第二行是命令的数量n
接下来n行，每行是一条命令
输出描述
对第3、4、8类命令，输出一行或两行：该命令对应取得的结果
#include <iostream>
using namespace std;
class myStack {
private:
int tt;
int *data;
int len;
public:
myStack()
{
len=1000;
data = new int[len];
tt=-1;
cout<<"constructing"<<endl;
}
myStack (int t) {
data = new int [t];
len = t;
tt = -1;
cout << "constructor 2" << endl;
}
~myStack() {
delete[]data;
cout << "destructing" << endl;
}
void push(int v) {
if (tt < len - 1) {
tt++;
data[tt] = v;
}
}
void pop() {
if (tt >= 0)
{
tt--;
}
}
void top(int &v) {
if (tt >= 0) {
v = data[tt];
cout << v << endl;
}
}
int size() const {
return tt+1;
}
friend ostream &operator<<(ostream &out, myStack &t) {
out<<t.size()<<endl;
if (t.tt >= 0) {
for (int i = 0; i <= t.tt; i++) {
out << t.data[i] << " ";
}
out<<endl;
}
return out;
}
};
int main() {
int m;
cin >> m;
myStack s(m);
int n;
cin >> n;
while (n--) {
int op;
cin >> op;
switch (op) {
case 1:
int a;
cin >> a;
s.push(a);
break;
case 2:
s.pop();
break;
case 3:
int t;
s.top(t);
break;
case 4:
cout<<s.size()<<endl;
break;
case 8:
cout << s ;
break;
}
}
return 0;
}
7.2 赋值运算符、比较运算符重载：编写一个stack类.part.5
描述
编写一个 stack栈类，在上一题的基础上：
重载 赋值运算符 = ：将一个栈对象赋值给另一个栈对象，实现深拷贝，最后输出一句：assignment
重载 小于比较运算符 < ： a 和 b 两个栈对象，当栈 a 的元素比栈 b 的元素个数少时，表达式 a < b 为真
重载 大于比较运算符 > ： a 和 b 两个栈对象，当栈 a 的元素比栈 b 的元素个数多时，表达式 a > b 为真
重载 不等于运算符 != ： a 和 b 两个栈对象，当栈 a 的元素 与 栈 b 的元素个数不相同时；或者元素个数相等，但任意一个对应位置的元素不等时，表达式 a != b 为真
重载 等于比较运算符 == ： a 和 b 两个栈对象，当栈 a 的元素 与 栈 b 的元素个数相同且所有对应位置的元素相等时，表达式 a == b 为真
注意：如果采用重载友元函数的方式，使用时就变成类似：operator<(s1, s2) 这样。这与习惯上的写法 s1 < s2 差别比较大。所以不提倡友元函数写法。
此外，请思考，比较运算符的返回值，应该是什么类型
输入描述
在上一题的基础上增加四类指令：
10 ：表示上一个栈对象与当前栈对象的 小于(<)比较，如果比较结果为真，输出 yes，否则输出 no
11 ：表示上一个栈对象与当前栈对象的 大于(>)比较，如果比较结果为真，输出 yes，否则输出 no
12 ：表示上一个栈对象与当前栈对象的 不等于(!=)比较，如果比较结果为真，输出 yes，否则输出 no
13 ：表示上一个栈对象与当前栈对象的 等于(==)比较，如果比较结果为真，输出 yes，否则输出 no
输入分两部分：
第一部分是作用在第一个栈对象的 n 条命令；第二部分是作用在第二个栈对象的命令，或者是第一个栈对象与第二个栈对象的比较。
第一行是一个整数 m，表示创建一个容量为 m 的栈对象
第二行是一个整数 n，表示接下来 n 行是作用在第一个栈对象的 n 条命令
接下来 n 行，每行是一条命令
接下来是一个整数 m，表示第二部分的 m 条命令
接下来 m 行，每行是一条命令
输出描述
对第 3、4、8、10、11、12、13 类命令，输出一行或两行：该命令对应取得的结果
#include <iostream>
using namespace std;
class myStack {
private:
int tt;
int *data;
int len;
public:
myStack()
{
len = 1000;
data = new int[len];
tt=-1;
cout<<"constructing"<<endl;
}
myStack (int t)
{
data = new int [t];
len = t;
tt = -1;
cout << "constructor 2" << endl;
}
~myStack()
{
delete[]data;
cout << "destructing" << endl;
}
void push(int v)
{
if (tt < len - 1)
{
tt++;
data[tt] = v;
}
}
void pop()
{
if (tt >= 0)
tt--;
}
void top(int &v)
{
if (tt >= 0)
{
v = data[tt];
cout << v << endl;
}
}
int size()const
{
return tt+1;
}
friend ostream &operator<<(ostream &out, myStack &t)
{
out<<t.size()<<endl;
if (t.tt >= 0)
{
for (int i = 0; i <= t.tt; i++)
{
out << t.data[i] << " ";
}
out<<endl;
}
return out;
}
myStack& operator=(const myStack& other)
{
if (this != &other)
{
len = other.len;
data = new int[len];
tt = other.tt;
for (int i = 0; i <= tt; i++)
{
data[i] = other.data[i];
}
}
cout << "assignment" << endl;
return *this;
}
bool operator<(const myStack& other) const
{
return this->size() < other.size();
}
bool operator>(const myStack& other) const
{
return this->size() > other.size();
}
bool operator!=(const myStack& other) const
{
if (this->size() != other.size())
return true;
for (int i = 0; i <= tt; i++)
{
if (data[i] != other.data[i]) return true;
}
return false;
}
bool operator==(const myStack& other) const
{
if (this->size() != other.size())
{
return false;
}
else
{
for (int i = 0; i <= tt; i++)
{
if (data[i] != other.data[i])
{
return false;
}
}
return true;
}
}
};
int main()
{
int m;
cin >> m;
myStack s1(m);
int n;
cin >> n;
while (n--)
{
int op;
cin >> op;
switch (op)
{
case 1:
int a;
cin >> a;
s1.push(a);
break;
case 2:
s1.pop();
break;
case 3:
int t;
s1.top(t);
break;
case 4:
cout<<s1.size()<<endl;
break;
case 8:
cout << s1 ;
break;
}
}
// cin >> m >> n;
myStack s2;
s2=s1;
cin >> n;//19
while (n--)
{
int op;
cin >> op;
switch (op)
{
case 1:
int a;
cin >> a;
s2.push(a);
break;
case 2:
s2.pop();
break;
case 3:
int t;
s2.top(t);
break;
case 4:
cout<<s2.size()<<endl;
break;
case 8:
cout << s2 ;
break;
case 10:
if (s1 < s2)
cout << "yes" << endl;
else
cout << "no" << endl;
break;
case 11:
if (s1 > s2)
cout << "yes" << endl;
else
cout << "no" << endl;
break;
case 12:
if (s1 != s2)
cout << "yes" << endl;
else
cout << "no" << endl;
break;
case 13:
if (s1 == s2)
cout << "yes" << endl;
else
cout << "no" << endl;
break;
}
}
return 0;
}
7.3 实现计数器的前自增、后自增运算
设计一个计算器类 Counter，它只有一个用于计数的数据成员 cnt，该计数器的有效计数范围是 0 - 65535，实现计数器的前自增、后自增运算。
#include <iostream>
using namespace std;
class Counter
{
private:int cnt;
public:
Counter(int a)
{
if(a>=0 && a<=65535)
cnt = a;
}
~Counter()
{
}
Counter& operator++()
{
cnt++;
return *this;
}
Counter operator++(int)
{
Counter temp= *this;
++(*this);
return temp;
}
void display()
{
cout<<"counter = "<<cnt<<endl;
}
};
int main() {
Counter a(100);
++++a;
a.display();
for( int i = 0; i < 100; i ++ )
a++;
a.display();
return 0;
}
7.4 实现计数器的前自减、后自减运算
设计一个计算器类Counter，它只有一个用于计数的数据成员cnt，该计数器的有效计数范围是0-65535，实现计数器的前自减、后自减运算。
#include <iostream>
using namespace std;
class Counter
{
private:int cnt;
public:
Counter(int a)
{
if(a>=0 && a<=65535)
cnt = a;
}
~Counter()
{
}
Counter& operator--()
{
cnt--;
return *this;
}
Counter operator--(int)
{
Counter temp = *this;
--(*this);
return temp;
}
void display()
{
cout<<"counter = "<<cnt<<endl;
}
};
int main() {
Counter a(200);
----a;
a.display();
for( int i = 0; i < 100; i++ )
a--;
a.display();
return 0;
}
1206
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
