Início / coding / Perguntas / 79232950
Accepted
Alexis ROARD
Asked: 2024-11-28 15:33:42 +0800 CST

Como obter tipos de parâmetros do construtor como uma tupla em C++?

  • 772

Não é possível recuperar argumentos do construtor em uma tupla.

Estou tentando extrair os tipos de parâmetros do construtor de uma dada classe como um std::tuple. Por exemplo, se eu tiver uma classe como esta:

struct MyClass {
    MyClass(int, double, std::string) {}
};

Quero obter um tipo como std::tuple<int, double, std::string>correspondente aos parâmetros do construtor.

Estou ciente de que no Boost.DI, isso parece ser possível, já que eles conseguem resolver dependências do construtor automaticamente. No entanto, não consegui encontrar uma explicação clara de como eles extraem os tipos de parâmetros do construtor.

Para funções regulares, sei como usar std::tuplemodelos, conforme mostrado abaixo:

template <typename Func>
struct function_traits;

// Specialization for functions
template <typename Ret, typename... Args>
struct function_traits<Ret(Args...)> {
    using args_tuple = std::tuple<Args...>;
};

No entanto, não tenho certeza de como adaptar essa abordagem para construtores.

Restrições:

  • Prefiro soluções compatíveis com C++14 ou C++17, mas estou aberto a ver abordagens usando C++20 ou mais recente.
  • Não sou contra o uso do Boost ou de outras bibliotecas, se necessário.

Alguém poderia me orientar sobre como conseguir isso? Talvez um exemplo mínimo ou uma explicação de como o Boost.DI faz isso?

Caso haja vários construtores, o boost di diz que escolhe o construtor mais longo. Como ele faz isso também?

Exemplo de como o boost di funciona (da documentação oficial). ref : boost di exemple

// $CXX -std=c++14 basic_create_objects_tree.cpp
#include <boost/di.hpp>

namespace di = boost::di;

struct renderer {
  int device;
};

class view {
 public:
  view(std::string /*title*/, const renderer&) {}
};

class model {};

class controller {
 public:
  controller(model&, view&) {}
};

class user {};

class app {
 public:
  app(controller&, user&) {}
};

int main() {
  /**
   * renderer renderer_;
   * view view_{"", renderer_};
   * model model_;
   * controller controller_{model_, view_};
   * user user_;
   * app app_{controller_, user_};
   */

  auto injector = di::make_injector();
  injector.create<app>();
}

Acho que tenho uma pista usando este arquivo, mas ainda não consigo entender completamente o sistema e como posso implementá-lo. boost/di/type_traits/ctor_traits.hpp

c++

1 respostas

  1. Best Answer

    Primeiro, conte quantos argumentos existem (usando o código de Ted Lyngmo) (com limite codificado):

    template<class T, std::size_t I>
struct Any {
    template<class U>
    operator U() const;
};

template <class T, size_t N>
struct is_valid_amount {
    static std::false_type test(...);

    template <std::size_t... Is>
    static auto test(std::index_sequence<Is...>)
        -> decltype(T(Any<T, Is>{}...), std::true_type{});

    static constexpr bool value =
        decltype(test(std::make_index_sequence<N>{}))::value;
};
template <class T, size_t N>
inline constexpr bool is_valid_amount_v = is_valid_amount<T, N>::value;

template<class T, std::size_t N>
struct ctor_def : std::integral_constant<std::size_t, N> {
};

template <class T, std::size_t N = 16> // increase max amount of args if you wish
struct ctor_arg_count
    : std::conditional_t<is_valid_amount_v<T, N>,
                        ctor_def<T, N>,
                        ctor_arg_count<T, N - 1>> {};
template<class T>
inline constexpr std::size_t ctor_arg_count_v = ctor_arg_count<T>::value;

    Então, com metaprogramação com estado , você pode fazer:

    namespace details
{
   template<std::size_t N> struct tag{};

    template<typename T, std::size_t N>
    struct loophole_t {
        friend auto loophole(details::tag<N>) { return std::type_identity<T>{}; };
    };

    auto loophole(tag<0>);
    auto loophole(tag<1>);
    auto loophole(tag<2>);
    auto loophole(tag<3>);
    auto loophole(tag<4>);
    auto loophole(tag<5>);
    auto loophole(tag<6>);
    auto loophole(tag<7>);
    auto loophole(tag<8>); // Add extra

    template <std::size_t N>
    struct detector {
        template <class T, std::size_t = sizeof(details::loophole_t<T, N>)>
        operator T();
    };

    template<typename T, typename Seq> struct ins;

    template<typename T, std::size_t... Is>
    struct ins<T, std::index_sequence<Is...>>
    {
        template <std::size_t = sizeof(T{detector<Is>{}...})>
        constexpr int operator()() const { return 0; }
    };

    template <std::size_t, std::size_t... Is, typename T = std::tuple<typename decltype(loophole(details::tag<Is>{}))::type...>>
    T get_type_impl(std::index_sequence<Is...>);

    template <typename T, std::size_t N = details::ctor_arg_count_v<T>>
    auto get_type()
    {
        return details::get_type_impl<details::ins<T, std::make_index_sequence<N>>{}()>(std::make_index_sequence<N>());
    }

}

template <typename T>
using constructor_type_as_tuple_t = decltype(details::get_type<T>());

    Demonstração

    • 2

relate perguntas