У меня есть этот код. Это массив (немного похожий на std :: array), с которым я мог бы работать во время компиляции. Также цикл for во время компиляции.
#include <utility>
#include <memory>
#include <type_traits>
template<class F,
std::size_t ... Is>
constexpr void __loop(F&& func, std::index_sequence<Is ...>) noexcept
{
(func(std::integral_constant<std::size_t, Is>{}), ...);
}
template<std::size_t N,
typename F>
constexpr void CONSTEXPR_LOOP(F&& func) noexcept
{
__loop(std::forward<F>(func), std::make_index_sequence<N>());
}
template<typename T, std::size_t Size>
class StaticArray
{
static_assert(std::disjunction_v<
std::is_default_constructible<T>,
std::is_nothrow_default_constructible<T>
>,
"Type must have a trivial constructor.");
public:
constexpr StaticArray() noexcept;
template<typename ... Args,
std::enable_if_t<
std::conjunction_v<
std::is_same<T, Args>...
>
> * = nullptr
>
constexpr StaticArray(Args && ... list) noexcept;
constexpr StaticArray(const StaticArray& a) = delete;
constexpr StaticArray(StaticArray&& a) = delete;
~StaticArray() noexcept = default;
constexpr StaticArray& operator=(const StaticArray& a) = delete;
constexpr StaticArray& operator=(StaticArray&& a) = delete;
constexpr const T& operator[](std::size_t i) const noexcept;
private:
T _data[Size];
std::size_t _capacity;
std::size_t _count;
template<typename Arg>
constexpr void set_data(std::size_t i, Arg&& arg) noexcept;
template<typename ... Args, std::size_t ... Indices>
constexpr void unpack(std::index_sequence<Indices ...>, Args&& ... args) noexcept;
template<typename ... Args>
constexpr void create_indexes(Args&& ... args) noexcept;
};
template<typename T, std::size_t Size>
constexpr StaticArray<T, Size>::StaticArray() noexcept :
_data{T{}},
_capacity{Size},
_count{0}
{
}
template<typename T, std::size_t Size>
template<typename ... Args,
std::enable_if_t<
std::conjunction_v<
std::is_same<T, Args>...
>
> *
>
constexpr StaticArray<T, Size>::StaticArray(Args&& ... list) noexcept :
_data{T{}},
_capacity{Size},
_count{Size}
{
static_assert(Size == sizeof ... (list), "Size of array not equal number of elements in the list");
static_assert(std::conjunction_v<std::is_same<T, Args>... >, "Parameter must be the same type as StaticArray<T>.");
create_indexes(std::forward<Args>(list) ...);
}
template<typename T, std::size_t Size>
template<typename Arg>
constexpr void StaticArray<T, Size>::set_data(std::size_t i, Arg&& arg) noexcept
{
_data[i] = arg;
}
template<typename T, std::size_t Size>
template<typename ... Args, std::size_t ... Indices>
constexpr void StaticArray<T, Size>::unpack(std::index_sequence<Indices ...>, Args&& ... args) noexcept
{
(set_data(Indices, args), ...);
}
template<typename T, std::size_t Size>
template<typename ... Args>
constexpr void StaticArray<T, Size>::create_indexes(Args&& ... args) noexcept
{
unpack(std::make_index_sequence<Size>{}, std::forward<Args>(args)...);
}
template<typename T, std::size_t Size>
constexpr const T& StaticArray<T, Size>::operator[](std::size_t i) const noexcept
{
return _data[i];
}
int main()
{
constexpr StaticArray<unsigned, 10> array = {9u, 8u, 7u, 6u, 5u, 4u, 3u, 2u, 1u, 0u};
static_assert(array[0] == 9);
static_assert(array[1] == 8);
static_assert(array[2] == 7);
static_assert(array[3] == 6);
static_assert(array[4] == 5);
static_assert(array[5] == 4);
static_assert(array[6] == 3);
static_assert(array[7] == 2);
static_assert(array[8] == 1);
static_assert(array[9] == 0);
constexpr std::array<unsigned, 10> checker = {9u, 8u, 7u, 6u, 5u, 4u, 3u, 2u, 1u, 0u};
CONSTEXPR_LOOP<10>([&](auto i) constexpr {
static_assert(array[i] == checker[i]);
});
return 0;
}
И когда я компилирую это, используя g++-8.3, я получаю эту ошибку:
.../main.cpp: In instantiation of ‘main()::<lambda(auto:1)> [with auto:1 = std::integral_constant<long unsigned int, 0>]’:
.../main.cpp:9:10: required from ‘constexpr void __loop(F&&, std::index_sequence<Is ...>) [with F = main()::<lambda(auto:1)>; long unsigned int ...Is = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; std::index_sequence<Is ...> = std::integer_sequence<long unsigned int, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9>]’
.../main.cpp:16:11: required from ‘constexpr void CONSTEXPR_LOOP(F&&) [with long unsigned int N = 10; F = main()::<lambda(auto:1)>]’
.../main.cpp:149:6: required from here
.../main.cpp:148:32: error: non-constant condition for static assertion
static_assert(array[i] == checker[i]);
~~~~~~~~~^~~~~~~~~~~
.../main.cpp:148:32: error: ‘__closure’ is not a constant expression
После того, как я потратил некоторое время, чтобы понять, в чем проблема, я решил скомпилировать этот код, используя g++-7.4. Он успешно компилируется без ошибок. Clang-6 и g++-9 дают мне тот же результат, но как только я использую g ++ - 8, я получаю ошибки, описанные выше. Есть идеи, почему это происходит?
Спасибо!
[Примечание] Онлайн пример: https://godbolt.org/z/Ig4CCW
[ОБНОВЛЕНИЕ] Я скомпилировал этот код в g++-8, когда добавил статический спецификатор в переменную constexpr. Это работает, потому что:
введите описание ссылки здесь
Лямбда-выражение может использовать переменную без ее захвата, если переменная
- является нелокальной переменной или имеет статическую или потоковую локальную продолжительность хранения> (в этом случае переменная не может быть захвачена)
Но если вы посмотрите на код ниже, вы заметите, что лямбда, которая вызывается из другой функции, по какой-то причине не захватывает переменную constexpr по ссылке и значению в g++-8. Другие компиляторы не сообщают об ошибках.
template<typename F>
constexpr void call(F&& f)
{
f();
}
int main()
{
constexpr std::array<unsigned, 1> checker = {1u};
call([&]() constexpr { static_assert(checker[0] == checker[0]); });
static constexpr std::array<unsigned, 1> checker2 = {1u};
call([]() constexpr { static_assert(checker2[0] == checker2[0]); });
constexpr std::array<unsigned, 1> checker3 = {1u};
call([=]() constexpr { static_assert(checker3[0] == checker3[0]); });
return 0;
}
Попробуйте