Создание массива объектов с использованием нового и вызова конструктора с параметрами [duplicate]

Нет, нет. Новое выражение допускает только инициализацию по умолчанию или вообще не инициализацию.

Обходным решением будет выделение необработанного буфера памяти с помощью operator new[], а затем построение объектов в этом буфере с использованием размещения-new с конструктором, отличным от стандартного.

Вы можете использовать новое размещение следующим образом:

class Car {
    int _no;
public:
    Car( int no ) :_no( no ) {
    }
};

int main() {
    void* raw_memory = operator new[]( NUM_CARS * sizeof( Car ) );
    Car* ptr = static_cast<Car*>( raw_memory );
    for( int i = 0; i < NUM_CARS; ++i ) {
        new( &ptr[i] )Car( i );
    }
    // destruct in inverse order    
    for( int i = NUM_CARS - 1; i >= 0; --i ) {
        ptr[i].~Car();
    }
    operator delete[]( raw_memory );
    return 0;
}

Ссылка из более эффективного C ++ - Scott Meyers: Пункт 4 - Избегайте бесполезных конструкторов по умолчанию

Хороший вопрос. У меня был тот же вопрос, и я нашел его здесь. Реальный ответ: @ Dan-Paradox, нет стандартного синтаксического способа сделать это. Итак, все эти ответы - это множество альтернатив, чтобы обойти проблему.

Я сам прочитал ответы и особо не нашел ни одного из них идеальным для моего личного соглашения. Метод, который я, вероятно, придерживаюсь, использует конструктор по умолчанию и метод set:

class MyClass
{
  int x,y,z;
public:
  MyClass(): x(0), y(0), z(0) {}
  MyClass(int _x,int _y,int _z): x(_x), y(_y), z(_z) {} // for single declarations
  void set(int _x,int _y,int _z)
  {
    x=_x;
    y=_y;
    z=_z;
  }
};

Стандартный конструктор инициализации все еще существует, поэтому я все еще могу его инициализировать, t нужно больше одного, но в противном случае у меня есть метод set, который устанавливает все переменные, которые инициализируются в конструкторе. Таким образом, я мог бы сделать что-то вроде этого:

int len=25;
MyClass list = new MyClass[len];
for(int i = 0; i < len; i++)
  list[i].set(1,2,3);

Это прекрасно работает и протекает естественным образом, не делая код запутанным.

Теперь это мой ответ для тех, кто задается вопросом, как объявите массив объектов, которые должны быть инициализированы.

В частности, вы пытаетесь дать массив идентификаторов автомобилей, которые, я полагаю, вы хотите всегда быть уникальными. Вы можете сделать это с помощью моего метода, который я объяснил выше, а затем в цикле for использовать i+1 в качестве аргумента, переданного методу set, но из того, что я прочитал в ваших комментариях, кажется, что вы хотите Иды более внутренне инициированы, так что по умолчанию у каждого автомобиля есть уникальный идентификатор, даже если кто-то использует ваш класс Car.

Если это то, что вы хотите, вы можете использовать статический член:

class Car
{
  static int current_id;
  int id;
public:
  Car(): id(current_id++) {}

  int getId() { return id; }
};
int Car::current_id = 1;

...

int cars=10;
Car* carlist = new Car[cars];

for(int i = 0; i < cars; i++)
  cout<<carlist[i].getId()<<" "; // prints "1 2 3 4 5 6 7 8 9 10"

Таким образом, вам не нужно беспокоиться об инициализации идентификаторов, поскольку они управляются внутри.

Я не думаю, что существует безопасный тип, который может делать то, что вы хотите.

Вы можете использовать оператор на месте new.

Car* createCars(unsigned number)
{
    if (number == 0 )
        return 0;
    Car* cars = reinterpret_cast<Car*>(new char[sizeof(Car)* number]);
    for(unsigned carId = 0;
        carId != number;
        ++carId)
    {
        new(cars+carId) Car(carId);
    }
    return cars;
}

И определите соответствующий уничтожить, чтобы соответствовать новому, используемому в этом.

Вы всегда можете создать массив указателей, указывая на объекты автомобилей, а затем создать объекты в цикле for, как вы хотите, и сохранить их адрес в массиве, например:

#include <iostream>
class Car
{
private:
  Car(){};
  int _no;
public:
  Car(int no)
  {
    _no=no;
  }
  void printNo()
  {
    std::cout<<_no<<std::endl;
  }
};
void printCarNumbers(Car *cars, int length)
{
    for(int i = 0; i<length;i++)
         std::cout<<cars[i].printNo();
}

int main()
{
  int userInput = 10;
  Car **mycars = new Car*[userInput];
  int i;
  for(i=0;i<userInput;i++)
      mycars[i] = new Car(i+1);

примечание новый способ !!!

  printCarNumbers_new(mycars,userInput);


  return 0;
}    

Все, что вам нужно изменить в новом методе, - это обработка автомобилей как указателей, чем статических объектов в параметре и при вызове метода printNo (), например:

void printCarNumbers_new(Car **cars, int length)
{
    for(int i = 0; i<length;i++)
         std::cout<<cars[i]->printNo();
}

на конец main хорош, чтобы удалить всю динамически распределенную память, подобную этой

for(i=0;i<userInput;i++)
  delete mycars[i];      //deleting one obgject
delete[] mycars;         //deleting array of objects

Надеюсь, я помог, ура!

Один из способов решения - предоставить статический заводский метод для распределения массива, если по какой-либо причине вы хотите предоставить конструктору закрытый.

static Car*  Car::CreateCarArray(int dimensions)

Но почему вы сохраняете один конструктор общедоступным и другим частным?

Но каким-то еще одним способом является объявление публичного конструктора со значением по умолчанию

#define DEFAULT_CAR_INIT 0
Car::Car(int _no=DEFAULT_CAR_INIT);

Мой путь

Car * cars;

// else were

extern Car * cars;

void main()
{
    // COLORS == id
    cars = new Car[3] {
        Car(BLUE),
            Car(RED),
            Car(GREEN)
    };
}

В C ++ 11 std::vector вы можете создавать элементы на месте с помощью emplace_back :

  std::vector<Car> mycars;

  for (int i = 0; i < userInput; ++i)
  {
      mycars.emplace_back(i + 1); // pass in Car() constructor arguments
  }

Voila!

Автомобиль () никогда не вызывается.

Удаление происходит автоматически, когда mycars выходит за рамки.

Вы можете создать массив указателей.

Car** mycars = new Car*[userInput];
for (int i=0; i<userInput; i++){
    mycars[i] = new Car(...);
}

...

for (int i=0; i<userInput; i++){
    delete mycars[i];
}
delete [] mycars;

или

Конструктор Car () не обязательно должен быть общедоступным. Добавьте статический метод в ваш класс, который создает массив:

static Car* makeArray(int length){
    return new Car[length];
}