Variable length array error with constexpr

Question

I have a class with a member function which declares an array whose size is based off a formula.

template <int SIZE>
class Example{
   constexpr int lookup(const int n) const
   {
      return n * n + n;
   }
   inline void func()
   {
       double array[lookup(SIZE)];
   }
};

This gives me the vla error. I think it should work because SIZE is resolved at compile time, and lookup is a constexpr. I know the following will work:

template <int SIZE>
class Example{

   inline void func()
   {
       constexpr int sz = SIZE * SIZE + SIZE;
       double array[sz];
   }
};

I guess I'm just trying to figure out why

EDIT Sorry for the typos, was trying to just write a smaller example and ended up with the missing n and class name.

With a few small syntax fixes, it complies and runs fine: repl.it/repls/WanLavishComputergames — Bill Lynch
– Bill Lynch, Commented May 15, 2020 at 14:47
@BillLynch - compile and run fine but isn't standard C++; if you add "-pedantic", you get the warning "warning: variable length arrays are a C99 feature". — max66
– max66, Commented May 15, 2020 at 17:05

max66 · Accepted Answer · 2020-05-15 17:59:27Z

3

It's complicated...

First of all, some compilers (see MikeCAT answer and Bill Lynch linked example) can compile the following code (if you give a name to the class and correct lookup() naming n the argument)

inline void func()
{
    double array[lookup(SIZE)];
}

because they support a C99 extension that accept the "variable length array" feature.

But this extension isn't standard C++.

You can verify this modifying func() as follows (almost equivalent, in standard C++)

inline void func()
{
    constexpr int s = lookup(SIZE);

    double array[s];
}

and this can't compile if lookup() is a non-static method

Consider that

 lookup(SIZE);

is a short form for

 this->lookup(SIZE);

I mean... the use of lookup() involve an object of your class.

The problem is that your func() method is available for both constexpr and non-constexpr objects.

Suppose you have a non-constexpr object: calling func() from it you impose that

constexpr int s = this->lookup(SIZE);

is evaluated compile-time.

That is: you impose that the this pointer (so the object itself) is available compile-time.

This is clearly impossible for run-time created objects, so your code can't compile.

Different if you declare lookup() as a static method: this way, calling lookup() doesn't involve an object of your class so your code can compile.

edited May 15, 2020 at 17:59

answered May 15, 2020 at 17:46

max66

67k11 gold badges76 silver badges121 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Tyler Kelly Over a year ago

thanks for sifting through my typos to see what I was trying to ask!

MikeCAT · Accepted Answer · 2020-05-15 14:46:23Z

0

Class template must have a name.
n is not declared in lookup.

This should work as C++11:

template <int SIZE>
class hoge { // add hoge
   constexpr int lookup(const int n) const // add n
   {
      return n * n + n;
   }
   inline void func()
   {
       double array[lookup(SIZE)];
   }
};

answered May 15, 2020 at 14:46

MikeCAT

75.1k11 gold badges50 silver badges71 bronze badges

2 Comments

max66 Over a year ago

Uhmmm... I don't think should works. If you add a hoge<2> h; h.func() (maybe declaring func() as public:) and compile with -ansi -padantic with clang++ or g++, you get a "warning: variable length arrays are a C99" (clang++) or "warning: ISO C++ forbids variable length array" (g++). If you add a row constexpr int s = lookup(SIZE); in func(), you get an error.

max66 Over a year ago

Ehmmm... sorry... in my preceding comment... -pedantic, not -padantic.

Collectives™ on Stack Overflow

Variable length array error with constexpr

2 Answers 2

1 Comment

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related