Question

我正在尝试将参数传递给构造函数，但同时创建一个像这样的对象数组。我使用以下代码来实现目标：

PointPtr centroids = new Point[k](5);

嗯，这不是语法错误，但它没有编译。我真的不想将“5”硬编码为Point的默认构造函数。对我应该怎么做有什么想法？谢谢！

BTW，我已经在其他地方做过typedef Point *PointPtr。

如果标题不准确，请注意。我不知道怎么总结这个。

Answer 1

我建议使用std::vector：

std::vector<Point> v(k, Point{5});

但你也可以这样做：

Point* centroids = new Point[5]{{1}, {2}, {3}, {4}, {5}};

Live Demo

Answer 2

如果你不能使用std::vector，那么一个选项是动态分配一个指针数组，然后动态分配n个对象并将结果内存分配给数组中的指针。例如：

constexpr auto ARRAYSIZE = 5;

auto x = new PointPtr[ARRAYSIZE];  // should check for memory alloc errors
for (int i = 0; i < ARRAYSIZE; ++i)
{
    x[i] = new Point(5); // pass any arguments you want, remember to check if allocation was successful
}

请注意，这种做法令人不悦，因为你真的不应该使用new，除非你有充分的理由这样做（而且IMO愚蠢的是你不允许做事情正确的方法，并从一开始就教好的做法）;相反，使用std::vector和智能指针，它们应该能够满足您所有的动态内存需求。

Answer 3

注1：使用标准库（在本例中为std::vector）来处理事情是可取的！

注意2：就个人而言，我不会指向路由数组，因为你破坏了你的记忆位置。

您可以使用std::allocator：

// Create allocator object
std::allocator<Point> alloc;
// allocate storage for k Points
Point * p = alloc.allocate(k);
// Construct k Points in p
for (std::size_t i{0}; i<k; ++i)
{
  alloc.construct(p+i, 5);
}
// Do stuff using p
// ...
// Destroy k objects in p
for (std::size_t i{0}; i<k; ++i)
{
  alloc.destroy(p+i);
}
// Dealloacte memory
alloc.deallocate(p, k);

或者您可以手动处理

// allocate
Point * p = static_cast<Point*>(::operator new[](k*sizeof(Point)));
// placement new construction
for (std::size_t i{0}; i<k; ++i)
{
  new((void *)(p+i)) Point{5};
}
// stuff
// destruction
for (std::size_t i{0}; i<k; ++i)
{
  (p+i)->~Point();
}
// deallocation
::operator delete[](static_cast<void*>(p));

我将内存处理至少包含在函数（如果不是类）中：

#include <new>
#include <utility>
#include <cstddef>

template<class T, class ... Args>
T * new_n(std::size_t const n, Args&&  ... args)
{
  T * p{ (T*)::operator new[](n*sizeof(T)) };
  for (std::size_t i{ 0 }; i < n; ++i) 
  {
    new((void*)(p + i)) T(std::forward<Args>(args)...);
  }
  return p;
}

template<class T>
void remove_n(T * const p, std::size_t const n)
{
  for (std::size_t i{ 0 }; i < n; ++i) (p + i)->~T();
  ::operator delete[]((void*)p);
}

并使用它们

auto p = new_n<Point>(k, 5);
// stuff using k Points in p constructed by passing 5 to constructors
remove_n(p, k);

Answer 4

#include <iostream>
using namespace std;

class base {
   public:
    int p, q;
    base() {}
    base(int a, int b) : p(a), q(b) {
        cout << p << q;
    }
};

int main() {
    int a, b;
    base *ptr = new base[3];
    for (int i = 0; i < 3; i++) {

        cin >> a >> b;
        ptr[i] = base(a, b);
    }

    return 0;
}

Answer 5

你可以创建一个指针数组（即Point**）并分两步进行初始化：

创建数组：

PointPtr* centroids = new PointPtr[k];
初始化：

for (int i=0 ; i<k ; ++i) centroids[i]=new Point(5);

如何使用new传递构造函数参数

5 个答案: