Início / coding / Perguntas / 79234329
Accepted
Tiramisu
Asked: 2024-11-28 22:43:41 +0800 CST

Argumentos variádicos vs. argumentos de upcasting

  • 772

A versão variádica sobrecarregada de uma função deve ter a menor prioridade, quando o compilador escolhe uma especialização de modelo. No entanto, esse não é o caso quando um argumento de função precisa ser convertido para uma classe base antes de corresponder a um argumento de modelo. Veja o exemplo abaixo.

class A {};
class B : public A {};
template<class... Args>
void foo(Args&&... argsPack) {
    std::cout << "variadic function called" << std::endl;
}
void foo(A&) {
    std::cout << "non-variadic function called" << std::endl;
}


int main() {
    foo("Hello");
    B b;
    foo(b);
}

A saída deste programa resulta em

variadic function called
variadic function called

Se eu quisesse que a função não-variádica fosse chamada, eu teria que deletar a função sobrecarregada variádica inteiramente. Ou alternativamente eu teria que escrever uma terceira função sobrecarregada que aceitasse instâncias da classe B diretamente:

void foo(B&) {
    std::cout << "non-variadic function called" << std::endl;
}

No entanto, quero evitar ambas as soluções, porque elas não são elegantes e propensas a erros para meu projeto. Então, há uma terceira solução para isso?

c++

2 respostas

  1. Best Answer

    Você pode restringir seu template. Eu adiciono sobrecarga extra para simplificar o requisito:

    void foo() // Simulate empty pack
{
    std::cout << "variadic function called" << std::endl;
}

template <typename T, class... Args>
requires (!std::is_base_of_v<A, std::decay_t<T>> || sizeof...(Args) != 0)
void foo(T&& t, Args&&... argsPack) {
    std::cout << "variadic function called" << std::endl;
}
void foo(A&) {
    std::cout << "non-variadic function called" << std::endl;
}

    Demonstração

    • 3

  2. Você pode atingir seu objetivo criando modelos de ambas as versões com referências universais e habilitando somente a versão não variável se o argumento derivar de A.

    Demonstração: https://godbolt.org/z/jqjvcbKfP

    #include <iostream>
#include <type_traits>

class A {};
class B : public A {};

template<class... Args>
void foo(Args&&... argsPack) {
    std::cout << "variadic function called" << std::endl;
}

template<class T>
// Enables this version only if the condition is true
std::enable_if_t<std::is_base_of<A, std::remove_reference_t<T>>::value>
foo(T&& arg)
{
    std::cout << "non-variadic function called" << std::endl;
}


int main() {
    foo("Hello");
    B b;
    foo(b);
}
    • 3

relate perguntas