Declaring Arrays in Private Part of Class

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 po开发者_运维百科ssible 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...

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.

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()));

Hmmm...several issues here...

• Neither N nor M are declared (either in the constructor or as members of foo)
• You are trying to initialize a member data that is not declared (and you may mean data_(data) as the syntax is member(expression), not expression(member))
• The argument to your constructor is an incomplete type: it needs to be std::vector< sometype >; if you want it to be generic you'll need to use templates or get some help from boost
• You are not initializing the only member variable that you have declared (A)
• void foo(void) is a problem because it is not the correct syntax for a constructor (which has no type) but uses the class name

Let's build up to something closer to what you want

Start with a class foo:

class foo {
};

with a constructor taking a single argument of type std::vector<double>

class foo {
public:
  foo(std::vector<double> &data);
};

you want to initialize a member variable with the data

class foo {
private:
  std::vector<double> data_;
public:
  foo(std::vector<double> &data)
    :data_(data)
  {};
};

At this point I'll note that I would generally not put the definition of a non-trivial constructor in the class declaration, but in a implementation file instead, and consequently I would be able to put the declaration of member variable beneath the public section with the declaration of the constructor. But for compactness I'll leave this way here.

You want to capture and store the size of the data

class foo {
private:
  std::vector<double> data_;
  size_t N;
 public:
  foo(std::vector<double> &data)
    :data_(data)
    ,N(data.size())
  {};

};

At this point we still haven't made that multi-dimensional storage that you want, but now you have some decisions to make about how to manage the storage. If you use Kerrek SB's approach this looks something like

class foo {
private:
  std::vector<double> data_;
  size_t N;
  std::vector< std::vector<double> > A;
public:
  foo(std::vector<double> &data)
    :data_(data)
    ,N(data.size())
    ,A()
  {
    A.resize(N);
    for (size_t i=0; i<N; ++i) {
      A[i].resize(N);
    }
  };
};

You need to create it dynamically, using a smart pointer if you do not want to manage memory yourself.

double **A;

in the constructor:

A = new double *[N];
for(i=0;i<N;++i)
{
  A[i] = new double [N];
}

Not that you have to call delete in your destructor and now to obey the rule of three you have to have a copy constructor and a assignment operator... Using a smart pointer is better here: see the Boost smart pointer help page.