28

I have the following helper function:

template<typename T, std::size_t N>
constexpr std::size_t Length(const T(&)[N]) {
    return N;
}

Which returns the length of a static array. In the past this always has worked but when I do this:

struct Foo
{
    unsigned int temp1[3];
    void Bar()
    {
        constexpr std::size_t t = Length(temp1); // Error here
    }
};

I get an error when using MSVS 2017:

error C2131: expression did not evaluate to a constant

note: failure was caused by a read of a variable outside its lifetime

note: see usage of 'this'

I was hoping someone can shed light on what I'm doing wrong.

Improve this question
10
  • Unrelated, but you might as well make Length noexcept as well - there's no reasonable scenario where it would ever throw an exception. Commented Jun 18, 2018 at 21:01
  • 1
    Seems to work ok on gcc. Commented Jun 18, 2018 at 21:04
  • 1
    Looks like an MSVC bug to me. This should be a constant expression, I do not see any reason why it would not be. Commented Jun 18, 2018 at 21:06
  • 2
    @super: No, it doesn't work in GCC: coliru.stacked-crooked.com/a/927ce1d01daf819e. GCC without -pedantic-errors might allow it because it supports VLA in C++. With -pedantic-errors it fails in C++17 GCC as well. Commented Jun 18, 2018 at 21:08
  • 1
    @JesperJuhl Sorry, version 14.14.26428 Commented Jun 18, 2018 at 21:48

3 Answers 3

Reset to default
21

MSVC is correct. Length(temp1) is not a constant expression. From [expr.const]p2

An expression e is a core constant expression unless the evaluation of e, following the rules of the abstract machine, would evaluate one of the following expressions:

  • this, except in a constexpr function or a constexpr constructor that is being evaluated as part of e;

temp1 evaluates this implicitly (because you are referring to this->temp1), and so you don't have a constant expression. gcc and clang accept it because they support VLAs as an extension (try compiling with -Werror=vla or -pedantic-errors).

Why isn't this allowed? Well, you could access the underlying elements and potentially modify them. This is completely fine if you are dealing with a constexpr array or an array that is being evaluated as a constant expression, but if you are not, then you cannot possibly have a constant expression as you will be manipulating values that are set at run time.

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

6 Comments

If you want to test standard validity of the code with GCC, then tiptoeing around its numerous extensions with narrow-targeted -Werror=vla would make little sense. The proper combination of flags in such cases is -std=... and -pedantic-errors.
@AnT While I completely agree that disabling extensions generally is the way to go, we were specifically talking about VLAs here, so I thought I'd just mention that warning option (-Wvla) specifically. Also, sometimes, getting rid of extensions in a codebase has to happen one extension at a time to be practical.
Your answer sounds rather roundabout... I think the direct way of answering this question would be "the compiler does not account for the fact that you disregard the actual element values, which are not constant expressions".
@Jesper Juhl: Yes, I agree in general. I'm just saying that in this specific case when I compile this in GCC without -pedantic-errors I don't even get a warning. It is completely silent. I.e. there's no reason for me to even begin to suspect that something is wrong, let alone worry about something as specific as VLA.
@Mehrdad That makes it sound like a quality of implementation issue. But a compiler that accepted this code without any diagnostic message would technically be incorrect.
|
4 
Length(decltype(temp1){})

seems to work.

Unfortunately, I cannot comment, but Mehrdad 's solution is wrong. The reason: it is not technically undefined behavior but it is undefined behavior. During constexpr evaluation, the compiler must catch undefined behavior. Therefore, the code is ill-formed.

Improve this answer

1 Comment

The code is ill-formed, and as my link above shows: gcc rejects it. So, there is not extension.
1

Your question's already been answered, but in terms of how to "fix" it, a quick-and-dirty way is to replace

Length(temp1)

with

Length(*(true ? NULL : &temp1))

which I think is technically undefined behavior but practically going to work fine for MSVC.

If you need a solution that works despite the UB, you can change Length to use a pointer:

template<typename T, std::size_t N>
constexpr std::size_t Length(const T(*)[N]) {
    return N;
}

and then you can use Length(true ? NULL : &temp1).

Improve this answer

2 Comments

Is it more of an extension then UB? Because UB in a constant expression results in ill-formed, which the implementation can side-step with an extension.
@Rakete1111: That seems plausible but I really don't know. I was just trying to provide a workaround in case someone needed to get code working (which I tested for MSVC).

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.