std::array:size() as a const in gcc 11

Question

I have this example code

#include <iostream>
#include <array>
#include <bitset>

template <class T, std::size_t N>
class Booth
{
  public:
    int function(const std::array<T, N> & data) {
        std::bitset<data.size()> bit_set{};

        return 0;
    };

  private:
};

int main()
{
    std::cout << "std::array test\n";

    std::array<int, 3> data2{2};
    Booth<int, 3>booth{};
    std::cout << booth.function(data2) << std::endl;

    return 0;
}

It compiles fine in [OnlineGDB][1]. And in the older versions of gcc. However, it started failing in gcc 11:

g++ -Wall -Wconversion -lstdc++ -pthread -std=c++17 -o array_size src/array_size.cpp
src/array_size.cpp: In function ‘int function(const std::array<int, 42>&)’:
src/array_size.cpp:22:28: error: ‘data’ is not a constant expression
   22 |     std::bitset<data.size()> bit_set{};
      |                            ^
src/array_size.cpp:22:26: note: in template argument for type ‘long unsigned int’
   22 |     std::bitset<data.size()> bit_set{};
      |                 ~~~~~~~~~^~

The code is the same. The language version is the same. I know how to fix this error. I just would like to know what was changed in the compiler? What is the reason for this change and thus the failure?

Why not just `std::bitset`? – KamilCuk Jan 21 '23 at 08:31 — KamilCuk, Jan 21 '23 at 08:31
Well, I wanted to be clever, maybe too clever. – ilya1725 Jan 23 '23 at 18:52 — ilya1725, Jan 23 '23 at 18:52

user17732522 · Accepted Answer · 2023-01-25T19:36:08.457

The code has not been valid until recently. If the compiler allowed it before without diagnostic, then the compiler wasn't conforming to the standard at the time.

The issue is simply that data in function is a reference. If it was taken by-value instead, then it would be fine.

One of the rules that disqualify an expression like data.size() from being a constant expression, as required for template arguments, is that any reference named in the expression (and whose lifetime didn't start during the evaluation of the constant expression) is itself initialized with a constant expression, even if no lvalue-to-rvalue conversion is applied to the referenced object and the identity of the referenced object is irrelevant. A function parameter isn't initialized with a constant expression and so data cannot be used in a constant expression inside the function in any capacity.

There isn't really any good reason for this restriction to be that strict. You only want to call .size() which just returns a constant determined from the type. It doesn't need any information about the actual object on which it is called.

So the restriction has been softened in the latest draft for C++23 to allow for such use and the fix will also be considered a defect report against previous C++ revisions. So in the future the compilers should again allow your code regardless of the chosen C++ version.

This error only in gcc 11. Why did it work fine in the previous gcc versions? — ilya1725, Jan 23 '23 at 19:05
@ilya1725 If it worked before without a warning, then previous versions of GCC were not standard-conforming and they fixed that with version 11. — user17732522, Jan 23 '23 at 19:16
To be clear, [P2280](https://wg21.link/p2280) was accepted into C++23 as a defect report, which means that this code will be valid regardless of the targeted standard as long as the compiler is sufficiently up to date. I.e. it is *not* C++23-specific — ildjarn, Jan 25 '23 at 09:12

score -1 · Answer 2 · edited Jan 21 '23 at 08:43

-1

In C++17 and later, the std::array class template provides a size() member function that returns the size of the array. This function is constexpr, which means it can be used at compile time and the value of the size can be used as a template argument.

The issue in the code is that the std::bitset constructor expects a unsigned long long as its argument, not a size_t. Instead of using data.size(), you can explicitly convert the size_t to a unsigned long long using static_cast<unsigned long long>() as follows:

std::bitset<static_cast<unsigned long long>(data.size())> bit_set{};

This should allow the code to compile with GCC 11 and later versions.

edited Jan 21 '23 at 08:43

Andrew Truckle

17,769
16
66
164

answered Jan 21 '23 at 08:22

nkrt

15
1

3

That's just wrong. First of all `std::bitset` _does_ expect a `std::size_t` template argument (not a constructor argument by the way), see https://en.cppreference.com/w/cpp/utility/bitset. Second, `std::size_t` may or may not be `unsigned long long` already. Third, the conversion would be applied implicitly either way. And lastly it doesn't change anything about the cause of the problem, see my answer. – user17732522 Jan 21 '23 at 10:22

std::array:size() as a const in gcc 11

2 Answers2