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;

The functionality you look for already exits in the stl collection classes and and with out knowing you application it would be had to tell you weather you needed a pointer or not.

The basic layout of you underlying container could be something like this.

class Album{    

public:
    void addPhoto(Photo p){
         Photos.push_back(p); 
    }
private:
    std::vector<Photo> Photos; 

};

Even if it would be possible to use dynamic arrays, I would not recommend it, especially not on an Arduino Uno/Mega with only 2 or 8 KB memory.

Instead, create a static data element (e.g. array) that has a (reasonable) maximum number of created elements. This also has the benefit that the constructor will not be called after initialization, thus no variance in execution time (construction of objects can take time).

To manage multiple items within this data element, you can:

• Using a ring buffer, this is the normal way to store items on one side, and process them from the other (so-called FIFO, first in first out).
• Using a stack (for LIFO, last in last out).
• For arrays, keep one variable that holds the number of elements currently filled.

Given what you've described in the comments (wanting to create a 2-dimensional array), there is an alternative that avoids both explicitly using placement new to create objects into previously "raw" memory, and the terrible cache usage of an array of arrays model (implemented either as an array of pointers to separately allocate memory blocks, or a std::vector<std::vector<T>> sort of thing.

That alternative is to allocate a single block of memory for the entire rectangular array, and do a little bit of operator overloading to get 2-D addressing into that block.

A simple version of this looks something like this:

class array2D { 
    std::vector<double> data;
    size_t columns;
public:
    array2D(size_t x, size_t y) : columns(x), data(x*y) {}

    double &operator(size_t x, size_t y) {
       return data[y*columns+x];
    }
};

This is "dynamic" only to the extent that it allows you to specify the size of the array when you create it, but (as it stands right now) you can't change the size after creation.

If you want to write your own imitation of std::vector as well, that's always entirely possible--but it's a little tricky in a few respects. I wrote a blog post a few years ago that covers at least a few of the basic points, and @Loki Astari wrote a rather more extensive series about it, complete with a Code Review of his implementation.