C++: Dynamically create array named after for loop iterator

Unfortunately, you can't do this in C++. Try something like this...

std::cout << "Enter n: ";
std::cin >> n

std::vector<std::vector<double> > arrays(n);

for (std::size_t i = 0; i < n; i++)
{
    std::cout << "Enter x: ";
    std::cin >> x;

    arrays[i].reserve(x);
}

reserve only allocates, but does not construct the objects in the std::vector; if you want to construct them too, use resize.

PS Never use using namespace std; it makes your code harder to read and debug.

Since you are programming in C++, you should use STL containers (especially std::vector) instead of C-style arrays.

If you need to access an array by using the string that has been created in runtime, then you could use std::map< std::string, std::vector<double> >, which is pretty crazy idea though:

typedef std::vector<double> MyVector;
std::map<std::string, MyVector> myVectors;

// create an array:
std::string arrayName;
arrayName = std::string("someArray");       // could be: std::cin >> arrayName;
myVectors[arrayName] = MyVector(10, 1.23);  // new vector of size 10

std::cout << myVectors["someArray"][4];     // prints 1.23

I'm not sure what exactly is what you are trying to achieve, but there are most likely more appropriate solutions. Is it really necessary to access these arrays via their names? I'm pretty sure that common std::vector< std::vector<double> > would suffice here.

Here's 3 solutions: the first is closest to your example code, the second is an improvement in order to be able to correctly retrieve the array elements within bounds, and the third is the reason why you are better served with vectors.

Solution 1:

It looks like you want your arrays to have names that are distinguishable by your loop iterator. Like Joe said, you could have an array of an array, so the inner arrays will be named array[0], array[1], ..., array[n - 1]. This will be achieved by using a pointer to pointer to double. Each of the inner pointers will be used to dynamically allocate arrays of double. Don't forget to delete the dynamically allocated memory.

#include <iostream>
int main()
{
    unsigned int n;
    std::cout << "Enter number of arrays: ";
    std::cin >> n;
    double** array = new double*[n];

    for (int i = 0; i < n; ++i)
    {
        unsigned int size;
        std::cout << "Enter size of array " << i << ": ";
        std::cin >> size;
        array[i] = new double[size];
        for (int j = 0; j < size; ++j)
        {
            int element;
            std::cout << "Enter element " << j << " of array " << i << ": ";
            std::cin >> element;
            array[i][j] = element;
        }
    }

    for (int i = 0; i < n; ++i)
    {
        delete [] array[i];
    }
    delete[] array;
    return 0;
}

Solution 2:

However, with the above code, you will have trouble accessing the elements of each inner array. Unless you memorized the size of each inner array you create with this, you might access something out of bounds. Therefore, an update to this code would be to add yet another array, let's call it sizeOfInnerArrays, where each of its element i keeps track of the size of inner array array[i]. Here's the update:

    #include <iostream>
    int main()
    {
        unsigned int n;
        std::cout << "Enter number of arrays: ";
        std::cin >> n;
        double** array = new double*[n];
        unsigned int* sizeOfInnerArrays = new unsigned int[n];

        for (int i = 0; i < n; ++i)
        {
            std::cout << "Enter size of array " << i << ": ";
            std::cin >> sizeOfInnerArrays[i];
            array[i] = new double[sizeOfInnerArrays[i]];
            for (int j = 0; j < sizeOfInnerArrays[i]; ++j)
            {
                int element;
                std::cout << "Enter element " << j << " of array " << i << ": ";
                std::cin >> element;
                array[i][j] = element;
            }
        }

        //prints out each array as curly-brace enclosed sets of doubles
        for (int i = 0; i < n; ++i)
        {
            std::cout << "{";
            for (int j = 0; j < sizeOfInnerArrays[i] - 1; ++j)
            {
                std::cout << array[i][j] << ", ";
            }
            std::cout << array[i][sizeOfInnerArrays[i] - 1] << "}" << std::endl;
        }

        // free dynamically allocated memory
        for (int i = 0; i < n; ++i)
        {
            delete [] array[i];
        }
        delete[] array;
        delete[] sizeOfInnerArrays;

        return 0;
    }

Solution 3:

However, that is too complicated, so you are better off using a container, like vector, as Joe suggested, whose data member keeps track of its size.

#include <iostream>
#include <vector>

int main()
{
    unsigned int n;
    std::cout << "Enter number of vectors: ";
    std::cin >> n;
    std::vector<std::vector<double> > myVec;
    // ^ space between closing angle brackets not needed
    //   if using C++11 conforming compiler

    for (int i = 0; i < n; ++i)
    {
        unsigned int size;
        std::cout << "Enter size of vector " << i << ": ";
        std::cin >> size;
        std::vector<double> temp;
        temp.reserve(size);
        for (int j = 0; j < size; ++j)
        {   
            double value;
            std::cout << "Enter next value of vector " << i << ": ";
            std::cin >> value;
            temp.push_back(value);
        }
        myVec.push_back(temp);
    }

    for (int i = 0; i < myVec.size(); ++i)
    {
        std::cout << "{";
        for (int j = 0; j < myVec.at(i).size() - 1; ++j)
        {
            std::cout << myVec.at(i).at(j) << ", ";
        }
        std::cout << myVec.at(i).back() << "}" << std::endl;
    }

    return 0;
}