4.2 基于链表list封装栈StackL 题目+答案 2分钟看完

C++数据结构与算法 目录

下面使用标准库中的std::list来封装栈。

由于链表的接口功能超过了栈的功能范围，所以，我们只需要把链表的一部分功能包装成栈即可。

这样就不用再把指针指来指去那种容易出错的代码再写一遍了。

最重要的是我们也不需要把复制控制再实现一遍了，这样工作量大大降低。

因为标准库的容器已经实现了复制控制（深拷贝），所以我们的std::list成员变量可以当作值类型来使用。

此时栈的实现将边的非常简单：

#include <iostream>
#include <iomanip>
#include <list>
using namespace std;

//内存泄漏检测 begin
#include <assert.h>
#include <iostream>
#include <atomic>
#include <string>
/*author: toy_lee5566(weixin)*/
class should_static_data {
public:
    should_static_data(const char* name) :m_name(name), counter_(0) {};
    ~should_static_data() { std::cout << "class " << m_name << " memory leak num = " << counter_ << std::endl; };
    void inc() { ++counter_; }
    void dec() { --counter_;	assert(counter_ >= 0); }
private:
    std::atomic<long long> counter_;
    std::string m_name;
};
template<typename T>
class should_value_data_counter {
public:
    should_value_data_counter() { m_data.inc(); }
    ~should_value_data_counter() { m_data.dec(); }
    should_value_data_counter(const should_value_data_counter&) { m_data.inc(); }
private:
    //一个类只有这一个对象，这个对象维护计数器
    static should_static_data m_data;
};
//TIPS:模板类的静态成员可以定义在头文件中，被链接程序特殊处理
template<typename T>
should_static_data should_value_data_counter<T>::m_data(typeid(T).name());
//示例用法
/*
class A
{
public:
    //这个对象的复制析构引发该类should_value_data_counter静态成员m_data的计数
    should_value_data_counter<A> m_checker;
};
*/
//内存泄漏检测 end
//检查是否通过测试 begin
void check_do(bool b, int line = __LINE__)
{
    if (b) { cout << "line:" << line << " Pass" << endl; }
    else { cout << "line:" << line << " Ohh! not passed!!!!!!!!!!!!!!!!!!!!!!!!!!!" << " " << endl; exit(0); }
}
#define check(msg)  check_do(msg, __LINE__);
//检查是否通过测试 end


class CStack
{
public:
    inline const int& top(void) const;
    inline bool empty(void) const;
    inline size_t size(void) const;
    void push(const int& _item);
    void pop(void);
    void clear(void);
private:
    std::list<int> m_stack;
    //下面的这个成员不要删除，请忽略即可。
    should_value_data_counter<CStack> m_checker;
};

bool CStack::empty(void) const
{
    return m_stack.empty();
}

void CStack::pop(void)
{
    m_stack.pop_back();
}

void CStack::clear(void)
{
    m_stack.clear();
}

size_t CStack::size(void) const
{
    return m_stack.size();
}

void CStack::push(const int& item)
{
    m_stack.push_back(item);
}

const int& CStack::top(void) const
{
    return m_stack.back();
}

int main(int argc, char** argv)
{
    //test clear
    {
        CStack s;
        check(s.size() == 0);
        check(s.empty());
        s.push(1);
        check(s.size() == 1);
        check(s.empty() == false);
        s.clear();
        check(s.size() == 0);
        check(s.empty());
    }
    CStack stack1;
    check(stack1.size() == 0);
    stack1.push(1);
    check(stack1.size() == 1);
    auto stack2 = stack1;
    check(stack2.size() == 1);
    stack1 = stack2;
    stack1.push(2);
    auto top = stack2.top();
    check(top == 1);
    check(stack1.size() == 2);
    check(stack1.top() == 2);
    stack1.clear();
    check(stack1.size() == 0 && stack1.empty());
    for (size_t i = 0; i < 10; i++)
    {
        stack1.push(i);
    }
    while (!stack1.empty())
    {
        std::cout << stack1.top() << std::endl;
        stack1.pop();
    }
    check(stack1.size() == 0 && stack1.empty());
}

输出如下：

line:105 Pass
line:106 Pass
line:108 Pass
line:109 Pass
line:111 Pass
line:112 Pass
line:115 Pass
line:117 Pass
line:119 Pass
line:123 Pass
line:124 Pass
line:125 Pass
line:127 Pass
9
8
7
6
5
4
3
2
1
0
line:137 Pass
class class CStack memory leak num = 0

由于vector也有同样的接口，所以我们也可以用vector来实现栈