C++ 在c+中使用数组进行动态内存分配+；

我试图在类对象中的数组中插入一个int，但我不知道我做错了什么。代码的当前状态从不将int插入数组

基本上，我试图做的是当我调用insert（int）时，它会检查数组中是否还有剩余空间，如果有，它会添加它，否则它会在数组中重新分配8个空间

这里是一些相关的课程信息

private:

    unsigned Cap;    // Current capacity of the set
    unsigned Num;    // Current count of items in the set
    int * Pool;      // Pointer to array holding the items

  public:

    // Return information about the set
    //
    bool is_empty() const { return Num == 0; }
    unsigned size() const { return Num; }
    unsigned capacity() const { return Cap; }

    // Initialize the set to empty
    //
    Set()
    {
      Cap = Num = 0;
      Pool = NULL;
    }

这是我正在编写的代码

bool Set::insert(int X)
{
        bool Flag = false;
        if (Num == Cap)
        {
                //reallocate
                const unsigned Inc = 8;

                int * Temp = new int[Cap+Inc];

                for (unsigned J=0;J<Num;J++)
                {
                        Temp[J] = Pool[J];
                }

                delete [] Pool;
                Pool = Temp;
                Cap = Cap+Inc;
        }

        if(Num < Cap)
        {
                Pool[Num+1] = X;

                Flag = true;
        }
        return Flag;
}

bool集：：插入（int X）
{
布尔标志=假；
如果（Num==上限）
{
//重新分配
常数无符号Inc=8；
int*Temp=新int[Cap+Inc]；
对于（unsigned J=0；J您的
insert
函数从不更新
Num
。请尝试
Pool[Num++]=X；
或类似的操作。
您的
insert
函数从不更新
Num
。尝试
Pool[Num++]=X；
或类似的东西。
您可能希望增加元素的数量，但只有在中复制新元素后才能增加元素的数量：第一个元素的索引应该为0。基本上，
insert（）
函数应该如下所示：

bool Set::insert(int X)
{
    if (Num == Cap)
    {
        const unsigned Inc(std::max(8, 2 * Cap));
        std::unique_ptr<int[]> Temp(new int[Cap+Inc]);
        std::copy(Pool.get(), Pool.get() + Num, Temp.get());
        Pool.swap(Temp);
        Cap += Inc;
    }
    Pool[Num] = X;
    ++Num;

    return true;
}

bool集：：插入（int X）
{
如果（Num==上限）
{
const unsigned Inc（标准：：max（8,2*Cap））；
标准：唯一的ptr温度（新国际[Cap+Inc]）；
复制（Pool.get（），Pool.get（）+Num，Temp.get（））；
池交换（临时）；
Cap+=公司；
}
池[Num]=X；
++Num；
返回true；
}

当然，这假设
池
被合理地声明为
std:：unique_ptr
（或者具有类似功能的东西，如果需要，可以很容易地编写）。使用
std:：unique\u ptr
而不是原始指针的原因是，它们在资源被销毁时会自动清理资源。复制
int
s序列不会引发异常，但如果
int
get被
std:：string
或模板参数替换，则有可能引发异常。
<>您可能希望增加元素的数量，但只有在中复制新元素后才能增加元素的数量：第一个元素的索引应为0。基本上，
insert（）
函数应如下所示：

bool Set::insert(int X)
{
    if (Num == Cap)
    {
        const unsigned Inc(std::max(8, 2 * Cap));
        std::unique_ptr<int[]> Temp(new int[Cap+Inc]);
        std::copy(Pool.get(), Pool.get() + Num, Temp.get());
        Pool.swap(Temp);
        Cap += Inc;
    }
    Pool[Num] = X;
    ++Num;

    return true;
}

bool集：：插入（int X）
{
如果（Num==上限）
{
const unsigned Inc（标准：：max（8,2*Cap））；
标准：唯一的ptr温度（新国际[Cap+Inc]）；
复制（Pool.get（），Pool.get（）+Num，Temp.get（））；
池交换（临时）；
Cap+=公司；
}
池[Num]=X；
++Num；
返回true；
}

当然，这假设
池
被合理地声明为
std:：unique_ptr
（或者具有类似功能的东西，如果需要，可以很容易地编写）。使用
std:：unique\u ptr
而不是原始指针的原因是，它们在资源被销毁时会自动清理资源。复制
int
s序列不会引发异常，但如果
int
get被
std:：string
或模板参数替换，则有可能引发异常。
在<>代码>标志>代码> ---看起来像“代码> INSERT <代码>永远不能返回<代码> false <代码>。我多么希望C++有一个向量“更新”操作符，它将像RealCube（）那样运行。，但随着从硬数组末尾添加/删除的额外额外构造/析构函数对象被扩展/缩减。为什么要这样做而不是简单地使用
：：std:：vector
？@WhozCraig:事实上，我想要的是
realloc
，如果它不能在p中扩展分配的大小，则返回一个错误然后你可以选择任何你想移动内存的方式。不管怎样，C++11中的
：：std:：vector
已经做到了这一点。@Omnifarious标准库做到了（通过std:：vector等）但是，语言并没有，而且仍然没有通过C++ 11。我一直想要它，并且从来没有理解它为什么没有在标准辩论中被提出。“代码>标志< /代码>的意义是什么？看起来像<代码> INSERT < /COD>永远不能返回<代码> false <代码>。我多么希望C++有一个向量“更新”操作符，它将像RealCube（）那样运行。，但随着从硬数组末尾添加/删除的额外额外构造/析构函数对象被扩展/缩减。为什么要这样做而不是简单地使用
：：std:：vector
？@WhozCraig:事实上，我想要的是
realloc
，如果它不能在p中扩展分配的大小，则返回一个错误然后你可以选择任何你想移动内存的方式。不管怎样，C++11中的
：：std:：vector
已经做到了这一点。@Omnifarious标准库做到了（通过std:：vector等）。但是，该语言没有，现在仍然没有通过C++11。我一直想要它，也不明白为什么它没有在标准辩论中提供。如果分配给
Pool
会引发异常，那么
Pool[Num++]=X；
仍然违反了基本保证？@DyP:这一点很好。我会解决这个问题。谢谢！虽然它不会违反基本保证（对象仍然可以成功销毁），但只要稍加修改，代码就会产生强保证。我认为类的不变量：Num可以解释为（成功地）的数量指定的元素。可能是我的措词错了。以下两个是：基本异常保证意味着，如果从对象的方法中抛出异常，则不会泄漏资源，并且可以清理对象。强异常保证意味着，如果抛出异常，则类不会更改（当然，没有泄露任何资源）。无论如何，原始代码需要改进…^^^我在第一篇评论之前读过那篇文章，认为最基本的是