Declaring Arrays in Private Part of Class

Question

I've got a class, and part of the input into the class is a vector (called Data) of variable length (lets say it has length N). I've included this after the function:

    N = data_->size();

In the private section of the class, I want to declare an array double A[N][N];. However, when I try to do this, I get something saying

error: "N is not a type name, static, or enumerator".

How do I create the array A[N][N]?

Sorry if this is already explained somewhere else, as I'm very new to c++, so wouldn't even know what to look for!

Edit -- attached code:

    class foo {     
    public:
        foo (std::vector &data)
    : data(data_)
    {
        N = data_->size();
        M =  /* four times the last member of data (which is a vector of positive integers)*/
    }

    private:
      double A[M][M];

    void foo(void)
    {
      for (std::size_t i=1; i<=M; ++i)
        {
          A[i][i] = 1;
        }
    }
    };

Hope that makes some sort of sense... How would I be able to define A[M][M]? Maybe it's not possible to do it for M as M is a function of the data. If not possible for M, is it possible for N?

One possibility I can think of is that I can make A a std::vector< std::vector<double> > A and then push a lot of 0's or something into it, and THEN modify the values...

Answer 1

if you´re using the std::vector class you must creates the vector in a function of the data_ class (like the constructor, for example), using this sentence:

A = vector<vector<double> >(N, vector<double>(N, 0));

The first parameter of the parentheses is the size of the vector and the second is the type of data on it.

Sorry for my english, i´m spanish and my english isn´t very good.

Answer 2

You cannot do that. Arrays are types, and they have to be known at compile time. This includes their sizes. So you cannot have a dynamic array as part of your class. The closest thing you get is a pointer to manually allocated array, but that is in fact essentially a std::vector. So perhaps the easiest solution is to just have a vector of vectors, or perhaps a single vector of size N * N that you access in strides j + N * i.

Example:

std::vector< std::vector<int> > v(N, std::vector<int>(N));

Or:

std::vector< std::vector<int> > v;
//...
v.resize(N, std::vector<int>(N));

Access: v[2][4] = 8;

---

Update: Since you edited your answer, you can write something like this to get you an N * 4n vector, where data.back() == n:

std::vector<unsigned int> data = get_data(); // given!

std::vector< std::vector<double> > v(data.size(), std::vector<double>(4 * data.back()));