C++ 向数组中添加内容

我有一个类，其中一个元素属于另一个类，但它是一个数组

class B
{
public:
    B()             //default
    {
        element = new A [1]; count = 0;
    }

    A add(A place)
    {
        A* newArr;
        newArr = new A [count+1];

        newArr = element;
        newArr[count+1] = place;
        delete element;

        return newArr[count+1];
    }



protected:
    int count;
    A* element;
};

---

我尝试使用动态数组，在添加元素时，我动态创建一个新数组，初始化为旧数组的大小加1，然后将旧数组的元素复制到新数组，然后删除旧数组。但是，我不确定如何修改已经在类中的数组，如果这是合理的（基本上是在我的添加方法中返回）。C++中的< /P> < P>没有声明一旦声明数组就调整大小。动态数组也是如此，一旦分配就无法调整大小。但是，您可以创建一个更大的数组，将所有元素从旧数组复制到新数组，然后删除旧数组。这是不鼓励的，不会被执行

使用

std:：vector

将允许您随意添加并跟踪其大小，因此您不需要将

count

作为类的一部分

class B
{
   // no need to allocate, do add when required i.e. in B::add
   B() : count(), elements() { }

   A add(A place)
   {
      // unnecessarily allocate space again
      A *new_elements = new A[count + 1];

      // do the expensive copy of all the elements
      std::copy(elements + 0, elements + count, new_elements);

      // put the new, last element in
      new_elements[count + 1] = place;

      // delete the old array and put the new one in the member pointer
      delete [] elements;
      elements = new_elements;

      // bunp the counter
      ++count;

      return place;    //redundant; since it was already passed in by the caller, there's no use in return the same back
   }

protected:
   size_t count;
   A *elements;
};

上面的代码可能会满足您的要求，但不鼓励使用。使用向量；您的代码将变得简单

class B
{
    // no need of a constructor since the default one given by the compiler will do, as vectors will get initialized properly by default

    void Add(A place)
    {
         elements.push_back(place);
         // if you need the count
         const size_t count = elements.size();
         // do stuff with count here
    }

    protected:
       std::vector<A> elements;
};

B类
{
//不需要构造函数，因为编译器提供的默认构造函数就可以了，因为默认情况下向量将正确初始化
添加（一个位置）
{
元素。推回（放置）；
//如果你需要计数
const size_t count=elements.size（）；
//在这里和伯爵一起做事
}
受保护的：
std：：向量元素；
};
一个更彻底的例子是更接近地模仿
std:：vector
：

template<typename T>
class B
{
private: // don't put data under a protected access!
    std::size_t _capacity;
    std::size_t _size;
    T* _elements;

public:
    B() : _capacity(0), _size(0), _elements(nullptr) {}

    // other methods

    void add(const T& t)
    {
        if (_size >= _capacity) // need to resize the array
        {
            _capacity++; // you can make this better by increasing by several at a time
            T* temp = new T[_capacity];
            std::copy(_elements, _elements + _size, temp);
            delete [] _elements;
            _elements = temp;
        }
        _elements[_size++] = t;
    }
};

模板
B类
{
private://不要将数据置于受保护的访问之下！
标准：尺寸和容量；
标准：：尺寸\u t\u尺寸；
T*_元素；
公众：
B（）：_容量（0），_大小（0），_元素（nullptr）{}
//其他方法
无效添加（常数T&T）
{
如果（\u size>=\u capacity）//需要调整阵列的大小
{
_容量+++；//您可以通过一次增加几个容量来改善这一点
T*temp=新的T[_容量]；
标准：复制（_元素，_元素+_大小，温度）；
删除[]_个元素；
_元素=温度；
}
_元素[_size++]=t；
}
};
在代码中添加“B”类型的变量的保护成员数组，不能使用向量。我想使用数组来实现，在有各种容器的情况下，在现代C++中没有必要使用裸数组。此外，还不清楚您想做什么。对于一个开始，严格来说，
delete element
应该是
delete[]element
，这是正确的。但是，由于C++继承了C标准库，所以可以使用ReAlLC:（不是使用<代码>新< /CODE >分配的内存）来调整内存大小。若有一个指向某个内部元素的指针，就不能保证它对realloc是有效的。此外，只有在没有其他解决方案的情况下，才需要干预低级构造。否则，使用现有的标准设施将节省大量的时间和精力。我并不反对。我只是指出这是可以做到的。。。是否应该是完全不同的事情，明白了。此外，我想让OP体验一下重新分配意味着什么，即从一个位置复制所有元素到另一个位置的费用。当然，使用
realloc
不应该这样做，因为它是一个
memcpy
引擎盖下的。。如果没有，使用向量是公认的答案：）