I have defined a struct in side a class. One of the members is an array with a given size.
class foo {
private:
int N;
struct entry {
uint64_t pc;
uint64_t offset;
bool pattern [N];
};
public:
void bar()
{
entry en;
en.pc = 1;
en.offset = 2;
en.pattern[en.pc] = 1;
}
};
But the error is
error: invalid use of non-static data member ‘N’
C++ doesn't support variable-length arrays. N must be known at compile-time. An alternative is using a std::vector instead.
class foo {
private:
int N;
struct entry {
uint64_t pc;
uint64_t offset;
std::vector<int> pattern;
};
public:
void bar()
{
N = 100; //don't forget to initialize N
entry en;
en.pc = 1;
en.offset = 2;
en.pattern.resize(N);
en.pattern[en.pc] = 1;
}
};
pattern is a bit vector. let say 00000. Then I want to set one of them using en.pc to . So 01000. Using vector, I have to push_back
std::bitset<N> instead.std::bitset I have to define a static const int N=5;N entries and then use operator[] just as if it was an array. No push_back, no re-allocation.N size have to be known at compile time. If you make in like static const int N=5 it will compile.
To initialize an array, you must use a compile-time known integral constant. If you'd said static const int N=10;, say it would have worked.
Variable-length arrays, i.e. where the size is not known until runtime, are not allowed in C++.
One other way of doing this could be to use a template, e.g.:
template<int N>
struct my_struct {
bool vals[N];
};
Or, similarly, use std::array, as in std::array<bool,10> vals;.
Better to use a std::vector than a fixed length array in most cases. In this case you don't know the size at compile time which isn't allowed anyway. Given that it's a collection of bool, you might want to consider a std::bitset which is a lot more size efficient than an array of bool
template < int S >
class foo {
private:
int N;
struct entry {
uint64_t pc;
uint64_t offset;
std::bitset<S> pattern;
};
public:
entry en;
foo()
{
en.pc = 1;
en.offset = 2;
en.pattern[en.pc] = 1;
}
};
Note that I've added the foo constructor, which may or may not now make sense given the switch to a bitset, and the object can now be used as follows:
foo<24> myBits;
Here the N is not known at the compile time. if you create a ob1,ob2,ob3 then there is a possiblity that all the three object might have different value of N and which is against law of c++( variable-length arrays).
either use const int N=5; or make a N as class variable static int foo::N=6;
