Làm thế nào để giải quyết vấn đề về đọc dữ liệu của biến không phải là constexpr 'a' không được phép trong một biểu thức không đổi, với boost.hana

Tôi đang sử dụng c ++ 17 với Boost.hana để viết một số chương trình lập trình meta. Một vấn đề khiến tôi băn khoăn là loại biểu thức nào có thể được sử dụng trong ngữ cảnh constexpr như static_assert. Đây là một ví dụ:

#include <boost/hana.hpp>

using namespace boost::hana::literals;

template <typename T>
class X {
public:
    T data;

    constexpr explicit X(T x) : data(x) {}

    constexpr T getData() {
        return data;
    }
};


int main() {
    {   // test1
        auto x1 = X(1_c);
        static_assert(x1.data == 1_c);
        static_assert(x1.getData() == 1_c);
    }
    {   //test2.1
        auto x2 = X(boost::hana::make_tuple(1_c, 2_c));
        static_assert(x2.data[0_c] == 1_c);

        // static_assert(x2.getData()[0_c] == 1_c); // read of non-constexpr variable 'x2' is not allowed in a constant expression
    }
    {   //test2.2
        auto x2 = X(boost::hana::make_tuple(1_c, 2_c));
        auto data = x2.getData();
        static_assert(data[0_c] == 1_c);
    }
}

Đầu tiên tôi viết một lớp X với dữ liệu trường và một hàm truy cập getData () . Trong chính () phần test1 của , x1.data và x1.getData () hoạt động giống như tôi mong đợi. Nhưng trong phần test2 , việc thay đổi đối số thành tuple boost :: hana, static_assert(x2.data[0_c] == 1_c)vẫn hoạt động tốt nhưng static_assert(x2.getData()[0_c] == 1_c)không biên dịch được, với lỗi ' đọc biến không phải là constexpr' x2 'không được phép trong biểu thức không đổi '. Những gì chúng tôi đã làm là nếu tôi tách x2.getData()[0_c]ra auto data = x2.getData();và static_assert(data[0_c] == 1_c);nó biên dịch lại tốt. Tôi mong họ cư xử như vậy. Vì vậy, bất cứ ai có thể giúp giải thích tại sao x2.getData()[0_c]không thể được sử dụng trong static_assert trong ví dụ này?

Để sao chép: clang ++ 8.0 -I / path / to / hana-1.5.0 / bao gồm -std = c ++ 17 Test.cpp

Vấn đề là boost::hana::tuplekhông có một constructor sao chép.

Nó có một constructor mà vẻ bề ngoài giống như một constructor sao chép:

template <typename ...dummy, typename = typename std::enable_if<
    detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Xn const&, dummy...)...>::value
>::type>
constexpr tuple(tuple const& other)
    : tuple(detail::from_index_sequence_t{},
            std::make_index_sequence<sizeof...(Xn)>{},
            other.storage_)
{ }

Nhưng vì đây là một mẫu, nó không phải là một hàm tạo sao chép .

Vì boost::hana::tuplekhông có hàm tạo sao chép, nên một hàm được khai báo ngầm định và được định nghĩa là mặc định (nó không bị loại bỏ vì boost::hana::tuplekhông có bất kỳ bản sao hoặc di chuyển hàm tạo hoặc toán tử gán nào, bởi vì, bạn đoán nó, chúng không thể là mẫu).

Ở đây chúng ta thấy phân kỳ thực hiện , được thể hiện trong hành vi của chương trình sau:

struct A {
    struct B {} b;
    constexpr A() {};
    // constexpr A(A const& a) : b{a.b} {}    // #1
};
int main() {
    auto a = A{};
    constexpr int i = (A{a}, 0);
}

gcc chấp nhận, trong khi Clang và MSVC từ chối, nhưng chấp nhận nếu dòng không #1bị lỗi. Đó là, các trình biên dịch không đồng ý về việc liệu hàm tạo sao chép được định nghĩa ngầm định của một lớp trống không (trực tiếp) có được phép sử dụng trong bối cảnh đánh giá không đổi.

Theo định nghĩa của hàm tạo sao chép được xác định ngầm định , không có cách nào mà # 1 khác với constexpr A(A const&) = default;gcc là chính xác. Cũng lưu ý rằng nếu chúng tôi cung cấp cho B một hàm tạo sao chép constexpr do người dùng định nghĩa Clang và MSVC chấp nhận lại, thì vấn đề có vẻ là các trình biên dịch này không thể theo dõi khả năng xây dựng bản sao constexpr của các lớp có thể sao chép ngầm. Đã sửa lỗi cho MSVC và Clang (đã sửa cho Clang 11).

Lưu ý rằng việc sử dụng operator[]là cá trích đỏ; vấn đề là liệu trình biên dịch có cho phép gọi getData()(cấu trúc sao chép T) trong bối cảnh đánh giá không đổi như không static_assert.

Rõ ràng, giải pháp lý tưởng sẽ là Boost.Hana sửa lỗi boost::hana::tuplesao cho nó có các hàm tạo sao chép / di chuyển thực tế và các toán tử gán / sao chép di chuyển. (Điều này sẽ khắc phục trường hợp sử dụng của bạn vì mã sẽ gọi các hàm tạo sao chép do người dùng cung cấp, được phép trong bối cảnh đánh giá không đổi.) Như một cách giải quyết , bạn có thể xem xét hack getData()để phát hiện trường hợp không có trạng thái T:

constexpr T getData() {
    if (data == T{})
        return T{};
    else
        return data;
}

Vấn đề là bởi vì bạn đang cố gắng truy xuất giá trị thời gian chạy và kiểm tra nó khi biên dịch.

Những gì bạn có thể làm là buộc biểu thức tại thời gian biên dịch qua a decltypevà nó sẽ hoạt động như một bùa mê :).

static_assert(decltype(x2.getData()[0_c]){} == 1_c);

#include <boost/hana.hpp>

using namespace boost::hana::literals;

template <typename T>
class X {
public:
    T data;

   constexpr explicit X(T x) : data(x) {}

   constexpr T getData() {
        return data;
    }
};


int main() {
    {   // test1
        auto x1 = X(1_c);
        static_assert(x1.data == 1_c);
        static_assert(x1.getData() == 1_c);
    }
    {   //test2
        auto x2 = X(boost::hana::make_tuple(1_c, 2_c));
        static_assert(x2.data[0_c] == 1_c);

         static_assert(decltype(x2.getData()[0_c]){} == 1_c);

        auto data = x2.getData();
        static_assert(data[0_c] == 1_c);
    }
}

Bây giờ biểu thức được ước tính tại thời gian biên dịch, vì vậy loại được biết đến tại thời gian biên dịch và vì nó cũng có thể xây dựng được tại thời điểm tính toán, nên có thể sử dụng nó trong static_assert

Vì vậy, trước hết, bạn đang thiếu vòng loại const trong getData()phương thức, vì vậy nó phải là:

constexpr T getData() const

Không có biến nào được quảng bá, ít nhất là từ quan điểm tiêu chuẩn, là constexpr nếu nó không được đánh dấu là constexpr.

Lưu ý rằng điều này là không cần thiết đối với x1loại Xchuyên dụng với hana :: integ_constant, vì kết quả 1_clà loại không có hàm tạo sao chép do người dùng xác định, không chứa bất kỳ dữ liệu nào trong nội bộ, do đó, hoạt động sao chép getData()trong thực tế là không hoạt động , vì vậy biểu thức: static_assert(x1.getData() == 1_c); là tốt, vì không có bản sao thực sự được thực hiện (cũng không cần truy cập vào thiscon trỏ không phải là const x1).

Điều này rất khác nhau đối với vùng chứa của bạn có hana::tuplechứa cấu trúc sao chép thực tế hana::tupletừ dữ liệu trong x2.datatrường. Điều này đòi hỏi quyền truy cập thực tế vào thiscon trỏ của bạn - điều không cần thiết trong trường hợp x1, đó cũng không phải là biến constexpr.

Điều này có nghĩa là bạn đang thể hiện ý định của mình sai với cả hai x1và x2, ít nhất là cần thiết x2, để đánh dấu các biến này là constexpr. Cũng lưu ý rằng, sử dụng bộ dữ liệu trống, là một chuyên môn chung về cơ bản trống (không có người xây dựng bản sao do người dùng xác định) hana::tuple, hoạt động trơn tru (phần test3):

#include <boost/hana.hpp>

using namespace boost::hana::literals;

template <typename T>
class X {
public:
    T data;

    constexpr explicit X(T x) : data(x) {}

    constexpr T getData() const {
        return data;
    }
};

template<typename V>
constexpr auto make_X(V value)
{
    return value;
}

int main() {
    {   // test1
        auto x1 = X(1_c);
        static_assert(x1.data == 1_c);
        static_assert(x1.getData() == 1_c);
    }
    {   //test2
        constexpr auto x2 = X(boost::hana::make_tuple(1_c, 2_c));
        static_assert(x2.data[0_c] == 1_c);

        static_assert(x2.getData()[0_c] == 1_c); // read of non-constexpr variable 'x2' is not allowed in a constant expression

        auto data = x2.getData();
        static_assert(data[0_c] == 1_c);
    }
    {   //test3
        auto x3 = X(boost::hana::make_tuple());
        static_assert(x3.data == boost::hana::make_tuple());

        static_assert(x3.getData() == boost::hana::make_tuple());
    }
}