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

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