使用向量为参数化构造函数初始化对象数组

Question

I am working with Visual Studio 2010 and am relatively new to C++. The program I am trying to work with has a class with a parameterized constructor and a destructor in its declaration. Somewhere in the listing, there was a dynamic object array creation using 'new'. However, I faced issues as object array initialization for parameterized constructors is not possible.

I have, thus, tried to implement vectors:

std::vector< class_type > my_object_array(length, arg); //current attempt

my_object_array = new class_type[length](arg); //previous code

However, once this object array is created, a ~vector destructor is called and I receive a runtime error of "Debug Assertion Failed... _BLOCK_TYPE_IS_VALID (pHead->nBlockUse)"

Based on previous such questions on SO, I think this is because of double deletion but I have not called the destructor explicitly during the debugging steps and I still receive this error.

Any help is appreciated! Thanks!

Edit: Added some snippets of the code with names changed.

class class_type {
  public:
    class_type(int var1);
    ~Class_type();
    /*

     Member functions

    */
  private:
    int var1;                        
    double var2;                   
    double length;                 
    double width;
    double* arr1;                  
};

Constructor definition:

Class_type::Class_type(int il){
  length    = 0;
  width     = 0;
  var1    = il;
  var2   = 5;
  arr1 = new double[5];
}

Destructor definition:

  Class_type::~Class_type(){
   
  delete [] arr1;}

Code where error occurs:

int class_type_2::create_my_objects(int num_elem){
   input_value = 10;
   if ( num_elem == 0 ) {
      std::cout<<"Warning!"<<endl;
   } else {
      std::vector<class_type> my_object_array(num_elem, input_value);
      //my_object_array= new class_type[num_elem](input_value);
        } //Debugger doesn't go beyond this step!
   return 0;
}

Answer 1

std::vector my_object_array(length, arg); //current attempt

Your vector might be out of scope as much as you wrote is just one line. So, it's not possible to reply exact cause what happened to yours. I think you might pass the vector to another copy constructor or move constructor where it deletes the memory and calls the destructor.

As @Matthieu Brucher just said you should manage memory by yourself if allocated using "new". Otherwise double deletion is a common issue and may other memory issues may occur.

Edit1: I just updated after seeing your code

std::vector<class_type> my_object_array(num_elem, input_value);
} ---> when this scope hits it will release all stacked memory inside it and call their object constructors

Initialize the raw pointer with nullptr.

double* arr1; // you have written
double* arr1 = nullptr;  // recommended

Edit 2:

you can delete a memory if allocated with malloc() or calloc(). otherwise use vector. it will manage your memory without leak.

Answer 2

If you use a std::unique_ptr for your object instead of the double* , you will see that your code doesn't compile anymore. This indicates that the code you have uses the default copy constructor, and the pointer will be copied to a copied class.

Unfortunately, this means that several objects will have the same pointer and try to free it, which will fail. If you follow good c++ practices and never call new and delete yourself, you won't see these issues anymore, because they will force you to think properly from the start.