Início / coding / Perguntas / 77180317
Accepted
yonutix
Asked: 2023-09-26 21:08:33 +0800 CST

Como você pode ativar uma função de membro de modelo de classe somente se um argumento de modelo for fornecido?

  • 772

É possível ter uma classe com um parâmetro de template opcional que possa ser chamado assim?:

#include <iostream>

template <typename T = void>
class A final
{
public:
    // This class can be called only when T exists.
    void f()
    {
        printf("%d\n", member);
    }

    // This method can be called only when T is missing.
    void g()
    {
        printf("No template parameter\n");
    }
public:
    T member;
};

int main()
{

    A<int> a1;
    A a2;
    a1.f(); // should be valid
    a1.g(); // should be invalid, cannot compile
    a2.f(); // should be invalid, cannot compile
    a2.g(); // should be valid

    return 0;
}

Se sim, quais são as funções padrão que devem ser usadas?

c++

2 respostas

  1. Best Answer

    Você pode usar o método "antigo" com especialização:

    template <typename T = void>
class A final // generic case, T != void
{
public:
    void f() { std::cout << member << std::endl; }

public:
    T member;
};

template <>
class A<void> final
{
public:
    void g() { printf("No template parameter\n"); } // actually `void` and not "No".
};

    Ao transformar sua classe em variável, para tratar o parâmetro ausente como um pacote vazio, em vez de void, você pode fazer:

    template <typename... Ts>
class A final
{
static_assert(sizeof...(Ts) < 2);
public:
    void f() requires (sizeof...(Ts) == 1) { std::cout << std::get<0>(member) << std::endl; }
    void g() requires (sizeof...(Ts) == 0) { printf("No template parameter\n"); }

public:
    std::tuple<Ts...> member;
};
    • 7

  2. Restrições da API da função membro

    Você pode aproveitar restrições e conceitos, especialmente o std::same_asconceito:

    #include <concepts>

template <typename T = void>
struct A final {
    // This method is defined only when T is non-void.
    void f() requires (!std::same_as<T, void>) {} 

    // This method is defined only when T is void.
    void g() requires std::same_as<T, void> {} 
};

int main() {
    A<int> a1;
    A a2;
    a1.f(); // OK
    // a1.g(); // error
    // a2.f(); // error
    a2.g(); // OK
}

    E o membro?

    Se você quiser que o membro exista apenas para determinadas especializações, você poderá envolvê-lo em um modelo de classe especializado de acordo. Por exemplo:

    template<typename T>
struct Value {
    T value;
};

template<>
struct Value<void> {};

    Outra abordagem seria usar uma classe base auxiliar para herdar o(s) membro(s), o que pode ser útil principalmente se os construtores de A dependerem de características do próprio tipo. Por exemplo, std::optionalnormalmente é implementado usando mixins de várias classes base.

    Você também pode querer colocar restrições no Apróprio parâmetro do modelo da classe em relação aos tipos de tipos que fazem sentido agrupar na classe.

    Usando a abordagem mínima:

    #include <concepts>

template<typename T>
struct Value {
    T value;
};

template<>
struct Value<void> {};

template <typename T = void>
struct A final {
    // This methods can be called only when T is non-void.
    T f() requires (!std::same_as<T, void>) {
        return member.value;
    } 

    // This method can be called only when T is void.
    void g() requires std::same_as<T, void> {}
private:
    Value<T> member;
};

int main() {
    A<int> a1;
    A a2;
    auto value = a1.f(); // OK
    // a1.g(); // error
    // a2.f(); // error
    a2.g(); // OK
}
    • 6

relate perguntas