Creation of Dynamic Array of Dynamic Objects in C+

Question

I know how to create a array of dynamic objects.

For example, the class name is Stock.

Stock *stockArray[4];
for(int i = 0 ; i < 4;i++)
{
   stockArray[i] = new Stock();
}

How do you change this to dynamic array of dynamic objects?

What I tried:

Stock stockArrayPointer = new Stock stock[4];

It doesn't work and the error is "The value of Stock** cannot be used to initalize an entity of type Stock.

Second question is after the creation of dynamic array of dynamic objects, what is the syntax to access the pointers in the array.

Now, I use stockArray[i] = new Stock(); How will this change?

Need some guidance on this...

Answer 1

I did something which worked perfectly:

#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std; 

class student {
    string name;
    int age;
    int roll;
    public:
        student() {
            name="";
            age=0;
            roll=0;
        }
        student (string n, int a, int r) {
            name=n;
            age=a;
            roll=r;
        }
        void show_details (); 
};
void student::show_details() {
    cout << "Name: " << name << "\n";
    cout << "Age: " << age << "\n";
    cout << "Roll No: " << roll << "\n";
}
int main() {
    string a; int b, c, n;
    cin >> n;
    student **obj;
    obj=(student**)malloc(n*sizeof(student*));
    for (int i=0; i<n; i++) {
        cin >> a;
        cin >> b;
        cin >> c;
        obj[i]=new student(a,b,c);
    }
    for (int i=0; i<n; i++) {
        obj[i]->show_details();
    }
    for (int i=0; i<n; i++) free (obj[i]);
    free (obj);
}

Yes... I used pointer to pointer for the array part, and it worked perfectly for variable sized arrays.

Answer 2

The type of a variable to a dynamic array is a pointer to the first object of the array. You want an array of dynamically allocated Stock objects, so an array of pointers to Stock, so your variable is a pointer to a pointer to Stock:

int n = 4; // dynamic size of the array;
Stock** stockArray = new Stock*[n];
for (int i = 0; i != n; ++i)
{
    stockArray[i] = new Stock();
}

and freeing it:

for (int i = 0; i != n; ++i)
{
    delete stockArray[i];
}
delete[] stockArray;

Answer 3

If you are using c++ then you shouldn't reinvent the wheel, just use vectors:

#include <vector>

std::vector< std::vector< Stock > > StockVector;

// do this as many times as you wish
StockVector.push_back( std::vector< Stock >() );

// Now you are adding a stock to the i-th stockarray
StockVector[i].push_back( Stock() );

Edit:

I didn't understand your question, if you just want to have and array of arrays allocated on the heap just use:

Stock** StockArrayArray = new Stock*[n]; // where n is number of arrays to create
for( int  i = 0; i < n; ++i )
{
    StockArrayArray[i] = new Stock[25];
}

// for freeing
for( int i = 0; i < n; ++i )
{
    delete[] StockArrayArray[i];
}
delete[] StockArrayArray;

Answer 4

Stock* stockArrayPointer = new Stock [4];

works only if the Stock class has a zero argument constructor if it does not have any zero argument constructor you cannot create an array of dynamic objects dynamically

you can as said create a array of dynamic object with a static array like

Stock stockArrayPointer[4]={Stock(args),Stock (args)};

but the syntax

Stock* stockArrayPointer=new Stock[4]{Stock(args),Stock (args)}; does not hold

or as said
use vectors...
vectors are memory allocated on heap
so the vector is a dynamic allocation

vector<Stock> V;
V.push_back(Stock(args));

or

V.push_back(new Stock(args));

The reason why

Stock* stockArrayPointer=new Stock[4]{Stock(args),Stock (args)};

does not hold is because this means you are using the new operator incorrectly