我用C ++写了一个堆栈类(如下所示),但是它是静态的,并确保它使用了大量的内存。 我怎样才能使其动态化,以便何时需要它为对象添加一些内存,何时我弹出某些内容,该内存就会自动删除?

template <class T>
class stack
{
private:
    T value[512];
    uint16_t length;
public:
    stack()
    {
        length=0;
    }

    stack(T _input)
    {
        value[0]=_input;
        length=1;
    }

    bool push(T _input)
    {
        if(length+1<512)
        {
            value[++length]=_input;
            return true;    
        }
        else
            return false;
    }

    T pop()
    {
        return value[length--];     
    }

    T peak()
    {
        return value[length];   
    }

    bool has_data()
    {
        return (length>0?true:false);
    }

};

===============>>#1 票数:3

您也可以使用std :: vector:

template <class T>
class stack{
private:
std::vector<T> vec;
public:
inline void push(T arg){vec.push_back(arg);};
inline T pop(){return vec.pop_back();};
};

===============>>#2 票数:3 已采纳

您必须在需要时动态分配它。 可能是这样的:

#define STACK_INITIAL_ALLOC   32
#define STACK_CHUNK_ALLOC    32

template<typename T>
class Stack
{
public:
    Stack()
        : data(0), entries(0), allocated(0)
        { }

    Stack(const T &value)
        : data(0), entries(0), allocated(0)
        {
            push(input);
        }

    ~Stack()
        {
            if (data)
                delete [] data;
        }

    void push(const T &value)
        {
            if (entries == allocated)
                allocate();  // Allocate more memory

            data[entries++] = value;
        }

    T pop()
        {
            if (entries > 0)
            {
                shrink();
                return data[--entries];
            }
            else
                throw runtime_error("stack empty");
        }

    T &top()
        {
            if (entries > 0)
                return data[entries - 1];
            else
                throw runtime_error("stack empty");
        }

    // Return the number of entries in the stack
    size_t count() const
        {
            return entries;
        }

private:
    T      *data;      // The actual stack
    size_t  entries;   // Number of entries in stack
    size_t  allocated; // Allocated entries in stack

    void copy(T *from, T *to)
        {
            for (size_t i = 0; i < entries; i++)
                *to++ = *from++
        }

    void allocate()
        {
            if (data == 0)
            {
                allocated = STACK_INITIAL_ALLOC;
                data = new T[allocated];
            }
            else
            {
                // We need to allocate more memory

                size_t new_allocated = allocated + STACK_CHUNK_ALLOC;
                T *new_data = new T[new_allocated];

                // Copy from old stack to new stack
                copy(data, new_data);

                // Delete the old data
                delete [] data;

                allocated = new_allocated;
                data = new_data;
            }
        }

    // Shrink the stack, if lots of it is unused
    void shrink()
        {
            // The limit which the number of entries must be lower than
            size_t shrink_limit = allocated - STACK_CHUNK_ALLOC * 2;

            // Do not shrink if we will get lower than the initial allocation (shrink_limit > STACK_INITIAL_ALLOC)
            if (shrink_limit > STACK_INITIAL_ALLOC && entries < shrink_limit)
            {
                // We can shrink the allocated memory a little
                size_t new_allocated = allocated - STACK_CHUNK_ALLOC;

                T *new_data = new T[new_size];

                copy(data, new_data);

                delete [] data;

                data = new_data;
                allocated = new_allocated;
            }
        }
};

这也是一个小的免责声明,该代码直接写到浏览器中。 它未经测试,但原则上应该可以工作... :)

===============>>#3 票数:0

任何类似数组的结构的增长和收缩都是昂贵的( T必须是可复制构造的),所有现有的T都必须移动。 如果发现正在进行大量的推送/弹出操作,并且需要保持较低的内存使用量,请尝试在内部使用链接列表。 它仅需单独链接。

这是一个草图:

template <class T>
class stack
{
  struct Node
  {
    T data;
    Node* next;
  };
public:

  // methods

private:
  Node *head;
};

现在,要将某些内容压入堆栈,请使用T构造一个Node ,将其下一个指针设置为当前head ,并将head设置为Node指针。 弹出涉及从head next并将其设置到head

当然,您需要在销毁等方面正确管理内存。

编辑:啊,看来我的假设是您可能知道C ++的基础是不正确的,我认为您是在使用模板时做的。 在这种情况下,请先忽略此答案,直到您掌握了基础知识!

  ask by mefmef translate from so

未解决问题?本站智能推荐:

5回复

C ++本地var动态,在堆栈上?

假设我在动态内存(新)中有一个对象,并且在其功能之一内,它有 c(以及a和b ...)在堆栈上吗? 或与我的对象一起动态存储。 只是好奇:)谢谢
4回复

许多堆栈分配与动态分配

在多维数组中,第二维将具有已知的大小(虽然每个第一维度不同),但是对于硬编码这些数组的实际构建而言, 性能是否会更快: 等等1,000次(我知道,我知道) 或动态分配每个第二维: 试着在这里围绕一个概念。
2回复

使用数组C ++的动态堆栈

我是一名学生,我的老师给了我这个“作业”。 我必须建立一个动态堆栈,最简单的部分是我不能使用列表结构(例如,链表)。 我本来以为数组实现才是赌注,但是在开发过程中,我停了下来,不得不增加数组大小。 我不知道如何在不丢失数据的情况下增加大小。 有人能帮我吗 ?
1回复

在类构造函数(它是私有成员)中动态定义Stack

朋友,我定义了一个堆栈类,它使一个结构成为堆栈,另一个类使用堆栈(动态创建),如下所示 现在的问题是,当我编译它时出现错误,提示“。或。*左侧需要结构” 我通过创建Structure对象来测试main中的堆栈类,然后将其压入堆栈并弹出工作! 这意味着我的堆栈类工作正常。 我
2回复

如何确定堆栈上的内容?

假设我有一个名为MainComponent的C ++类,并且其中包含一些类:WindowClass,InputClass,GameClass。 主要功能是这样设置的: 由于GameClass等包含的对象,MainComponent类可能会变得很大。 是否应为MainComponent
1回复

将typedef与模板类一起使用

我已经编写了这段代码,但是没有用! 它是C ++中动态堆栈的节点实现: 我解决不了,有什么办法吗? 谢谢
3回复

动态内存控制的优点是什么?

例如,我要堆叠。 我可以使用动态内存控件以这种方式来实现,并具有new和delete操作: 而且我也可以以这种方式制作堆栈并对其进行任何处理: 那么,哪个更好? 具有动态内存分配的堆栈的优点是什么? 在什么情况下应该使用第一/第二变体?
1回复

Linux :: glibc中的C ++运行时错误检测到free():下一个大小无效(快速):带有无效ptr元素的堆栈

这是我的第一个问题,因此如果这太愚蠢,我将深表歉意。 我尝试搜索,但仍然找不到代码问题。 我正在调试别人的代码,这在Linux中给出了此错误,并且在Solaris中运行得很好。 该代码是巨大的,带有许多内部逻辑,但是我尝试创建一个示例,说明问题可能在哪里。 如果这是显而易见的
2回复

用于实现一副纸牌的链表与动态阵列? C ++ [关闭]

实施诸如《聚会魔法》或《口袋妖怪》等纸牌游戏哪个更好? 我听说链表可以更快,更有效地从卡组中添加/删除卡。 我听说动态数组可以更快地搜索特定的卡。 您知道哪一种洗牌更快吗? 那么,您认为我应该使用哪一种来创建游戏,例如口袋妖怪tcg http://hum1l1ation.hubp
1回复

使用动态数组实现堆栈

我已经使用动态数组(实现数组加倍)实现了一个Stack,但是当第二次发生加倍时,我遇到了运行时错误! 实施中出了什么问题? 请帮忙。