Is it possible to use a loop to declare multiple variables? And to create files?

Question

I have (sort of) learned c++ by myself for physics purposes, so I apologize if this is an easy question. I've tried to find the answer by myself using Google, but I didn't find anything useful (probably because I wasn't sure what kind of search words to use).

For my c++ program, I have to declare 100 (or more) variables like this:

vector< vector<double> > pol1_t1_matrix(SPACE_pol, vector<double>(2));
vector< vector<double> > pol1_t2_matrix(SPACE_pol, vector<double>(2));
vector< vector<double> > pol1_t3_matrix(SPACE_pol, vector<double>(2));
vector< vector<double> > pol1_t4_matrix(SPACE_pol, vector<double>(2));
vector< vector<double> > pol1_t5_matrix(SPACE_pol, vector<double>(2));
vector< vector<double> > pol1_t6_matrix(SPACE_pol, vector<double>(2));
vector< vector<double> > pol1_t7_matrix(SPACE_pol, vector<double>(2));
vector< vector<double> > pol1_t8_matrix(SPACE_pol, vector<double>(2));
vector< vector<double> > pol1_t9_matrix(SPACE_pol, vector<double>(2));
vector< vector<double> > pol1_t10_matrix(SPACE_pol, vector<double>(2));
etc.;

I also use these to write files as follows:

ofstream outputFile_2D_pol1_t1("gnu_2D_pol1_t1_matrix_2sol_num.dat"); 
for(i=0;i<SPACE_pol;i=i+1)
{
    outputFile_2D_pol1_t1 << x_begin + (i * h_pol) << setw(18);
    outputFile_2D_pol1_t1 << pol1_t1_matrix[i][1] << setw(18);
    outputFile_2D_pol1_t1 << endl;
}
outputFile_2D_pol1_t1.close(); 

ofstream outputFile_2D_pol1_t2("gnu_2D_pol1_t2_matrix_2sol_num.dat"); 
for(i=0;i<SPACE_pol;i=i+1)
{
    outputFile_2D_pol1_t2 << x_begin + (i * h_pol) << setw(18);
    outputFile_2D_pol1_t2 << pol1_t2_matrix[i][1] << setw(18);
    outputFile_2D_pol1_t2 << endl;
}
outputFile_2D_pol1_t2.close();

ofstream outputFile_2D_pol1_t3("gnu_2D_pol1_t3_matrix_2sol_num.dat"); 
for(i=0;i<SPACE_pol;i=i+1)
{
    outputFile_2D_pol1_t3 << x_begin + (i * h_pol) << setw(18);
    outputFile_2D_pol1_t3 << pol1_t3_matrix[i][1] << setw(18);
    outputFile_2D_pol1_t3 << endl;
}
outputFile_2D_pol1_t3.close();

etc.;

The above becomes very laborious if I have to do that more than a 100 times (at least up till t100, but sometimes I'll have to do that 1000 times or more). So my question is: is there any way to do all of the above using (separate) loops?

Naively, I would assume it looks something like this (to replace the laborious "declaration of variables" as shown above):

for(i=1;i<101;i=i+1)
{
    double (pol1_t"i"_matrix)[2] = new double[SPACE_pol][2];
}

and (to replace the laborious "writing to files" as shown above):

for(i=1;i<101;i=i+1)
{
        ofstream outputFile_2D_pol1_t"i"("gnu_2D_pol1_t"i"_matrix_2sol_num.dat"); 
        for(j=0;j<SPACE_pol;j=j+1)
        {
            outputFile_2D_pol1_t"i" << x_begin + (j * h_pol) << setw(18);
            outputFile_2D_pol1_t"i" << pol1_tj_matrix[i][1] << setw(18);
            outputFile_2D_pol1_t"i" << endl;
        }
        outputFile_2D_pol1_t"i".close(); 
}

Answer 1

You don't want to be using new, particular with raw pointers. I'm confident your program currently leaks memory because of it. Stick with nested vectors.

You can nest three vectors, but it would probably be easier to just use a class designed for this, such as Boost.MultiArray

Answer 2

Take a look at this. std::vector is dynamically allocated, see the modifiers section. So you can declare it at size zero, ten, ... whatever. The key here is that you can resize it and add stuff during the execution, then access its elements using a simple index [i]. The routine is that inside a for loop (if you got the size during execution) or a while loop (if reading from file f.e), you can push_back() elements to it on every iteration. You end up with array(s) of loop-iterations size. Very nice.

Here is a basic demonstration of a two-dimensional vector of double numbers and note that you need to #include <vector>:

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    vector<vector<double>> my2dVector; // vector of vectors<double>. initially its size is zero-by-zero and it's possible to assign an initial size.
    vector<double> temp; // this will hold data for everyrow. Notice the clear() in the beginning of the outerloop and the push_back() at the end of it

    for (int Rows = 0; Rows < WhateverDesiredRowSize; Rows++)
    {
        temp.clear();
        for (int Columns = 0; Columns < WhateverDesiredColumnSize; Columns++)
        {
            // here you push_back into temp. Imagine it as the row. So you fill the whole 2d structure row-by-row
            temp.push_back(WhateverDoubleDataYouWant);
        }
        // here you push the whole row into your 2d structure
        my2dVector.push_back(temp);
    }

    return 0;
}

Answer 3

^{(I gave several comments, they might be interesting enough to make an answer, here is it...)}

Use at least C++11 if you can. E.g. if compiling with a recent GCC, use g++ -std=c++11 -Wall (and probably also -g when debugging) ...

First, use if possible arrays (or vectors, or some other C++ standard container); if you can't do that, consider writing some script (in your favorite scripting language) or a C++ program which would emit the C++ code you want to have. You'll need to update your build procedure, e.g. add a few lines in your Makefile

Sometimes (but probably not in your case) using some tricks with C preprocessor is enough (e.g. with X-macro tricks). You could also consider using some more powerful preprocessor, e.g. GPP.

In general, metaprogramming is a useful approach, notably when you begin writing some very repetitive code. Then consider having your particular tool to generate that code. This could be a script (in some scripting language like Python or awk) or your specialized C++ program. Read about homoiconic languages (such as Common Lisp ...), multi-stage programming, partial evaluation.

A useful advice when coding some (e.g. C++) code generator: keep in memory some AST like representations of the emitted code (so build first the AST of the entire generated code, then print it).

If you generate huge C++ routines (e.g. of more than ten thousand lines each), you'll observe that your C++ compiler would take a lot of time to compile such generated C++ code, in particular when you ask it to optimize (empirically, g++ -O2 takes a time quadratic in the size of the longest routine in your source code). If you meet this issue, just modify your C++ generator to generate several smaller routines.

On Linux or POSIX systems, you might even consider having your program which generates at runtime some specialized C++ code (depending on some input data) e.g. in /tmp/generated.cc, then forks a compilation into a /tmp/generated.so plugin (e.g. using system(3) to run some command like g++ -Wall -fPIC -O2 -g -shared /tmp/generated.cc -o /tmp/generated.so ...), and use dlopen(3) (e.g. void*dlh = dlopen("/tmp/generated.so",RTLD_NOW|RTLD_GLOBAL); then test dlh against failure, using dlerror on failure) to dynamically load that plugin, and dlsym(3) to find some (extern "C") symbols there (and fill some function pointers this way). Beware of name mangling so read the C++ dlopen mini-howto. In practice this approach works surprisingly well: my manydl.c C program demonstrates that you can load several millions of such plugins on Linux (of course the practical bottleneck is the time spent in compiling the generated plugins at runtime! you'll need several days to generate a million of plugins and compile them). Notice that a dlopen-ing main program needs to be linked with -rdynamic and -ldl.

BTW, you could perhaps consider embedding some interpreter (like Guile or Lua) in your program... Or use some JIT-compiling library like GCCJIT or LLVM or libjit or asmjit. But that is a different story.

Also, I am not sure that a vector of vectors is an efficient representation of 2D matrixes. I suggest having a class Matrix keeping internally some array of double-s and having inlined member functions (to get the dimensions, get or put a particular element of given two indexes, etc...). You'll probably find some existing library doing that.