Создайте массив объектов класса

Вам не нужен malloc (). Вы также можете использовать new для массива указателей:

    test **objs = new test* [50];

Зачем нужен массив?

std::vector<test*> v(50);

Или как @j_random_hacker предложил в комментариях:

std::vector<test> v(50, test(1));

Пример:

/** g++ -Wall -o vector_test *.cpp && vector_test */
#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>

struct Test {
  int value;
  Test(int x) : value(x) 
  {
    std::cout << "Test(" << value << ")" << " ";
  }
  operator int() const
  {
    std::cout << "int(" << value << ")" << " ";
    return value;
  }
};

int main()
{
  using namespace std;

  vector<Test> v(5, Test(1));

  cout << endl;
  copy(v.begin(), v.end(), ostream_iterator<int>(cout, " "));
  cout << endl;

  v[1] = 2;
  v[2].value = 3;

  cout << endl;
  copy(v.begin(), v.end(), ostream_iterator<int>(cout, " "));
  cout << endl;

  return 0;
}

Выход:

Test(1) 
int(1) 1 int(1) 1 int(1) 1 int(1) 1 int(1) 1 
Test(2) 
int(1) 1 int(2) 2 int(3) 3 int(1) 1 int(1) 1 

Вы не можете создать массив объектов, как в Foo foo  [N], без конструктора по умолчанию. Это часть языковой спецификации.

Либо делать:

test * objs [50];
for() objs[i] = new test(1).

Вам не нужен malloc (). Вы можете просто объявить массив указателей.

c++decl> explain int * objs [50]
declare objs as array 50 of pointer to int

Но вы, вероятно, должны иметь какое-то автоматическое уничтожение типа RAII.

ИЛИ ЖЕ подкласс контрольная работа публично:

class TempTest : public test
{
public:
  TempTest() : test(1) {}
  TempTest(int x) : test(x) {}
  TempTest(const     test & theTest ) : test(theTest) {}
  TempTest(const TempTest & theTest ) : test(theTest) {}
  test & operator=( const     test & theTest ) { return test::operator=(theTest); }
  test & operator=( const TempTest & theTest ) { return test::operator=(theTest); }
  virtual ~TempTest() {}
};

а потом:

TempTest  array[50];

Вы можете рассматривать каждый объект TempTest как объект контрольная работа.

Примечание. Operator = () и конструктор копирования не наследуются, поэтому при необходимости укажите заново.

Я думаю, что другие респонденты слишком буквально трактуют этот вопрос.

Если все, что вам действительно нужно, это создать «группу» из 50 объектов, которые можно рассматривать как массив, то, безусловно, самый простой и наиболее удобный способ выполнить то, что вы пытаетесь сделать, это:

std::vector<test> objs(50, test(1));

Это объявляет vector из 50 объектов, каждый из которых является копией test(1). vector - это, по сути, растущий массив C++; хотя вам может не понадобиться возможность роста, тот факт, что он может быть вызван с помощью конструктора с 2 аргументами, который копирует каждый элемент, здесь полезен.

Вы можете использовать это более или менее точно так же, как массив - например, 5-й элемент - objs[4]. Производительность тоже такая же - стандарт C++ гарантирует, что внутри элементы хранятся в непрерывном массиве.

Здесь на помощь может прийти библиотека Boost Контейнер указателя. С boost::ptr_vector<T> вы можете хранить список объектов, размещенных в куче, которые могут быть даже полиморфными (виртуальные функции), что невозможно с просто std::vector<T>.

В отличие от std::vector<T>, объекты не будут храниться в подпоследовательных адресах памяти. Однако такие вещи, как изменение размера контейнера, будут выполняться быстрее, потому что элементы сохранят свои исходные адреса в памяти. Лучшим бонусом является то, что вам не нужно вызывать delete самостоятельно: содержащиеся в нем объекты будут уничтожены, когда ptr_vector выйдет за пределы области видимости. Пример:

#include <boost/ptr_vector.hpp>
#include <iostream>
class test() {
protected:
    int const i;
public:
    explicit test(int i) : i(i) {}
    virtual void who_am_i() const { std::cout << "I am test " << i << std::endl; }
};
class special_test : public test {
public:
    explicit special_test(int i) : test(i) {}
    virtual void who_am_i() const { std::cout << "I am special_test " << i << std::endl; }
};
int main() {
    boost::ptr_vector<test> objs;
    for (int i=0; i<50; ++i)
        objs.push_back(new test(i)); // NB: constructing to heap here!
    objs.push_back(new special_test(123)); // objs can also hold inherited classes
    objs[13].who_am_i(); // outputs: I am test 13
    objs[50].who_am_i(); // outputs: I am special_test 123
} // all created objects are automatically destroyed here

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

#define PRINTT(z, n, initializer) initializer
test objs[50] = {
    BOOST_PP_ENUM(50, PRINTT, 1) // yields 1, 1, 1, .... 1
};
#undef PRINTT

Это инициализирует все 50 элементов с 1. boost::pp используется для автоматической печати 1 50 раз подряд.