如何构建C++类型：混淆私密值并编译期统计暴露次数

我需要实现一个C++类型Secret<T, MEC, EC=0>，它用于包装私密的私有值，且仅允许通过exposeSecret()方法在作用域内暴露该值，该方法需满足以下要求：

• 接收一个闭包作为参数；
• 向闭包传递const T&引用并获取其返回值（支持void类型）；
• 必须消耗当前Secret<T, MEC, EC>实例，并返回一个EC值自增1的同模板类型实例，即Secret<T, MEC, EC+1>。

以下是我的尝试代码：

#include <iostream>
#include <tuple>
#include <type_traits>
#include <utility>

template <std::size_t A, std::size_t B>
struct IsALesserThanB : std::integral_constant<bool, A<B>> {};

template <typename T, std::size_t MEC, std::size_t EC = 0>
class Secret {
   private:
    T value;

    template <template <typename U, std::size_t, std::size_t>
              class Secret>
    static inline constexpr Secret<T, MEC, EC + 1> ECAddOne(
        const Secret<T, MEC, EC>&& this_secret) {
        return Secret<T, MEC, EC + 1>{
            .value = std::move(this_secret.value),
        };
    }

    template <template <typename U, std::size_t, std::size_t>
              class ReturnedSecret,
              template <typename U, std::size_t, std::size_t>
              class Secret>
    Secret(const Secret<T, MEC, EC>&& this_secret) {
        value = std::move(this_secret.value);
    }

    template <template <typename U, std::size_t, std::size_t>
              class ReturnedSecret,
              template <typename U, std::size_t, std::size_t>
              class Secret>
    ReturnedSecret<T, MEC, EC + 1>& operator=(
        Secret<T, MEC, EC>&& this_secret) {
        T value_ = std::move(this_secret.value);
        return Secret<T, MEC, EC + 1>{
            .value = value_,
        };
    }

    template <template <typename U, std::size_t, std::size_t>
              class ReturnedSecret,
              template <typename U, std::size_t, std::size_t>
              class Secret>
    ReturnedSecret<T, MEC, EC + 1>& operator=(Secret<T, MEC, EC>& this_secret) =
        delete;

    template <template <typename U, std::size_t, std::size_t>
              class ReturnedSecret,
              template <typename U, std::size_t, std::size_t>
              class Secret>
    Secret(Secret<T, MEC, EC>& this_secret) = delete;

   public:
    Secret(T&& initialValue) : value(std::move(initialValue)) {}

    template <
        typename Closure,
        typename = std::enable_if_t<std::conjunction_v<
            std::is_invocable<Closure, const T&>, IsALesserThanB<EC, MEC>>>>
    [[nodiscard]] constexpr inline std::tuple<
        std::invoke_result_t<Closure, const T&>, Secret<T, MEC, EC + 1>>
    exposeSecret(Closure closure) const noexcept {
        auto new_secret = ECAddOne(std::move(*this));
        return std::make_tuple(closure(new_secret.value), new_secret);
    }
};

int main() {
    Secret<double, 3, 2> secretString{std::move(69.69)};

    auto length =
        Secret<double, 3, 2>::exposeSecret(std::move(secretString), [](const double& s) { return "69"; });

    std::cout << std::get<0>(length) << std::endl;

    return 0;
}

目前遇到的核心问题：

1. C++构造函数必须返回与类自身相同的类型，例如Secret<double, 1, 0>的构造函数只能返回Secret<double, 1, 0>，无法直接返回Secret<double, 1, 1>；
2. 无法通过静态成员函数实现实例转换逻辑，因为构造任意类型的实例必须调用其构造函数，而当前的静态函数设计无法正确完成类型转换。

内容的提问来源于stack exchange，提问作者Jim