C++, массив объектов без <vector>

Question

Я хочу создать на C++ массив объектов без использования STL.

Как это сделать?

Как я могу создать массив Object2, у которого нет конструктора без аргументов (конструктор по умолчанию)?

Answer 1

Если тип в вопросе имеет никаких аргументов конструктора, используйте new[]:

Object2* newArray = new Object2[numberOfObjects]; 

Не забудьте позвонить delete[], когда вам больше не нужен массив:

delete[] newArray; 

Если это Безразлично 't использовать такой конструктор operator new для выделения памяти, затем называть конструкторы на месте:

//do for each object 
::new(addressOfObject) Object2(parameters); 

Опять же, не забудьте освободить массив, когда он вам больше не нужен.

Answer 2

Если конструктор по умолчанию недоступен, вам понадобится массив указателей, а затем цикл над этим массивом для инициализации каждого указателя.

Answer 3

Object2 *myArray[42]; 
for (int i = 0; i < 42; i++) 
{ 
    myArray[i] = new Object2(param1, param2, ...); 
} 

Позже вы должны будете пройти через массив и освободить каждого члена в отдельности:

for (int j = 0; j < 42; j++) 
{ 
    delete myArray[j]; 
} 

Answer 4

Очевидный вопрос, почему вы не хотите использовать STL.

Предполагая, что у вас есть причина, вы должны создать массив объектов с чем-то вроде Obj * op = new Obj[4];. Просто не забудьте избавиться от него delete [] op;.

Вы не можете сделать это с объектом без конструктора, который не принимает аргументы. В этом случае я думаю, что лучше всего вы можете выделить некоторую память и использовать новое место размещения. Это не так просто, как другие методы.

Answer 5

Используйте массив указателей на Object2:

std::tr1::shared_ptr<Object2>* newArray = new shared_ptr<Object2>[numberOfObjects]; 
for(int i = 0; i < numberOfObjects; i++) 
{ 
    newArray[i] = shared_ptr<Object2>(new Object2(params)); 
} 

Или, в качестве альтернативы, без использования shared_ptr:

Object2** newArray = new Object2*[numberOfObjects]; 
for(int i = 0; i < numberOfObjects; i++) 
{ 
    newArray[i] = new Object2(params); 
} 

Answer 6

Вы можете делать то, что std::vector делает и создать блок необработанной памяти. Затем вы создаете свои объекты, которые не имеют конструктора по умолчанию в этой памяти, используя новое место размещения, поскольку они необходимы. Но, конечно, если вы это сделаете, вы могли бы использовать, в первую очередь, std::vector.

Answer 7

Предполагая, что ваш класс Base и у вас есть один аргумент конструктор

Base arr[3] = {Base(0), Base(1), Base(2)} ; 

Answer 8

// allocate memory 
Object2* objArray = static_cast<Object2*>(::operator new (sizeof Object2 * NUM_OF_OBJS)); 
// invoke constuctors 
for (size_t i = 0; i < NUM_OF_OBJS; i++) 
    new (&objArray[i]) Object2(/* initializers */); 

// ... do some work 

// invoke destructors 
for (size_t i = 0; i < NUM_OF_OBJS; i++) 
    objArray[i].~Object2(); 

// deallocate memory 
::operator delete (objArray); 

Answer 9

Если вы действительно нужен массив (непрерывная последовательность объектов) конструктивизируемой типа не по умолчанию, и по некоторым причинам вы cannoy user std::vector (!?), то вам нужно использовать функцию выделения и размещения new.

Это очень трудно сделать надежно; это должно помочь показать, почему. Этот фрагмент включает в себя некоторую защиту от исключений, но более чем вероятно не устойчив ко всем отказам.

const size_t required_count = 100; //e.g. 

// cast to pointer of required type needed for pointer arithmetic 
Object2* objarray = static_cast<Object2*>(operator new(required_count * sizeof(Object2))); 

size_t construction_count = 0; 

try 
{ 
    while (construction_count < required_count) 
    { 
     // params could change with index. 
     new (static_cast<void*>(objarray + construction_count)) Object2(param1, param2); 
     ++construction_count; 
    } 
} 
catch (...) 
{ 
    while (construction_count-- != 0) 
    { 
     try 
     { 
      (&objarray[construction_count])->~Object2(); 
     } 
     catch (...) 
     { 
      // not a lot we can do here, log but don't re-throw. 
     } 
    } 

    operator delete(objarray); 
    throw; 
} 

// Now objarray has been allocated and pointer to an array of required_count Object2 
// It cannot be de-allocated via delete[] or delete; you must loop through 
// calling destructors and then call operator delete on the buffer.