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

我试图将参数传递到构造函数中，但同时生成这样的对象数组。我使用以下代码到达那里：

PointPtr质心=新点[k]（5）

这不是语法错误，但它没有编译。我真的不想将“5”硬编码到Point的默认构造函数中。你知道我该怎么做吗？谢谢

顺便说一句，我已经在别的地方做了
typedef Point*PointPtr

如果标题不准确，很抱歉。我不知道如何总结这一点。
您可以创建一个指针数组（即
点**
）并分两步初始化它们：

创建阵列：

PointPtr*质心=新的PointPtr[k]

初始化：

对于（inti=0；i我建议使用
std:：vector
：

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

如果无法使用
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
}

constexpr auto ARRAYSIZE=5；
auto x=new PointPtr[ARRAYSIZE]；//应检查内存分配错误
for（int i=0；i

请注意，这种做法是不受欢迎的，因为除非你有很好的理由，否则你真的不应该使用
new
（在我看来，不允许你以正确的方式做事并从一开始就教授好的做法是愚蠢的）；相反，使用和智能指针，它们应该能够满足您的所有动态内存需求

注1：最好使用标准库（即本例中的
std:：vector
）来处理事情

注2：就个人而言，我不会沿着指针数组的路线走，因为你破坏了你的内存位置

您可以使用：

//创建分配器对象
分配程序alloc；
//为k点分配存储空间
点*p=分配分配（k）；
//p中k点的构造
对于（std:：size_t i{0}；i
#include
使用名称空间std；
阶级基础{
公众：
int p，q；
base（）{}
基数（inta，intb）：p（a），q（b）{
cout a>>b；
ptr[i]=基（a，b）；
}
返回0；
}
对不起，你不能用动态数组来处理这个问题。请考虑使用一个向量，让它使用<代码> EpStudioBuffe/Cuth>来构造对象。还有一个避免<代码>新< /代码>的原因。它总是“尚未”。…为什么不先教他们？这就是学校最糟糕的地方。在我的学校，他们不教
std:：vector
，甚至不教
std:：string
。这就是为什么我总是逃课的原因…
，但这里有另一个问题
-不，如果你有更多问题，请分别问他们。一篇帖子=一个问题。是的，这不是Java。是真的我不能这样做，因为我没有默认的Cor：1我想了一下java。抱歉。用C++的建议编辑。嗯。非常聪明。谢谢！注意这个解决方案给出了一个不同的类型：<代码>质心< /C> >；在原来的，它是一个代码>点*/COD>。在你的解决方案中，它变成了代码>点** /代码>。lly应该在答案中更加明显。因此，嗯，正如我在另一条评论中所说的，我不能将STL用于此作业。我可以将其用于另一个作业，但我必须仅提交此作业的指针。无论如何，谢谢！
std:：size\u t I{0}
-这是我见过的初始化循环变量最原始的方法：P
std:：size\u t I{}也足够，不是吗？我知道C不允许空括号，但我的印象是C++。@ JackThomas可以做什么。代码：STD：：分配器[/COD]手工操作，但手动内存管理通常不是很好的想法。这是不正确的：在ReleVin中，数组元素需要按相反顺序被破坏！我没有。我不知道这种方法！当
点
不是聚合时，这种非向量解决方案也有效吗？@MicroVirus是的，如果您提供的构造函数接受
int
@szczurcio，则不会编译。@MicroVirus有趣的是，同样的代码在VS15（MSVC 14.0）中编译得很好.Clang说，
候选构造函数不可行
，因为它
需要单参数“x”，但没有提供参数
，这很奇怪，但我对标准的解释可能是错误的。其中一个编译器当时的行为不标准。
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
}

// 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);

#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;
}