Início / coding / Perguntas / 78428993
Accepted
Qwe Qwe
Asked: 2024-05-04 20:35:37 +0800 CST

Pacote de parâmetros e encaminhamento perfeito

  • 772

Acabei de escrever o seguinte código simples, mas ele não compila:

#include <iostream>
#include <string>


class Obj{
public:
    std::string name = "Name";
    std::string l_name = "LastName";
    
    template<typename P>
    Obj(P&& param): name{std::forward<P>(param)} { }
    
    friend std::ostream& operator<<(std::ostream& os, const Obj& obj);
};

std::ostream& operator<<(std::ostream& os, const Obj& obj) {
    os << obj.name << ":" << obj.l_name;
    return os;
}


void print() {
    std::cout << "}";
}

template<typename T, typename ...Args>
void print(T param, Args... args) {
    std::size_t count = sizeof...(args);
    std::cout << param;
    if ( count != 0 ) {
        std::cout << ",";
    }
    print(args...);
}

template<typename... Args>
void run(Args... args) {
    std::cout << "{";
    print(args...);
}

int main() {
    Obj obj{"obj"};
    run("1", "2", 1.3, std::string{"Some Message"}, obj);
    
    return 0;
}

Acabei de usar um pacote de parâmetros simples e um exemplo de encaminhamento perfeito, mas deu o seguinte erro:

main.cpp: In instantiation of ‘Obj::Obj(P&&) [with P = Obj&]’:
main.cpp:49:8:   required from here
main.cpp:12:21: error: no matching function for call to ‘std::__cxx11::basic_string::basic_string()’
   12 |     Obj(P&& param): name{std::forward<P>(param)} {
...

Se eu não usar o parâmetro obj na função run, o exemplo funcionará conforme o esperado.

c++

2 respostas

  1. Best Answer

    Infelizmente

    template<typename P>
Obj(P&& param): name{std::forward<P>(param)} { }

    é muito ganancioso e pega Obj(Obj&)(para o que está errado).

    Você pode SFINAE esse construtor,

    template<typename P>
requires (std::is_constructible_v<std::string, P>)
Obj(P&& param): name{std::forward<P>(param)} { }

    Demonstração

    ou adicione sobrecargas extras

    Obj(Obj&&) = default;
Obj(Obj&) = default; // To fix the issue
Obj(const Obj&) = default;

    Demonstração

    ou ainda mais simples, já que você não precisa de modelo aqui:

    explicit Obj(std::string name): name{std::move(name)} { }

    Demonstração

    • 7

  2. O problema é que o modelo do construtor

    template<typename P>
Obj(P&& param)

    aceitaria um Objlvalue. Objainda possui um construtor de cópia e um construtor de movimento definidos implicitamente, mas eles possuem as assinaturas Obj(const Obj&)e, Obj(Obj&&)respectivamente, portanto, perdem na resolução de sobrecarga quando um lvalue do tipo Objé passado.

    Você pode ter um construtor de encaminhamento que use P&&, mas isso precisa ser devidamente restringido. Por exemplo, std::tupletem um construtor que aceita any UTypes&&..., mas é restrito a não aceitar a std::tuplepara que os construtores copiar/mover sempre ganhem.

    Em C++20 e superior, você poderia escrever

    template<typename P>
  requires !std::convertible_to<P&&, Obj>
Obj(P&& param)

    Em versões mais antigas, você poderia usar std::enable_if.

    Você também pode evitar totalmente o uso de modelos aqui criando um construtor:

    Obj(std::string&& param) : name(std::move(param)) { }

    Observe que você também pode usar um std::stringvalor by, mas isso geralmente é desaconselhado (consulte CppCoreGuidelines F.18: Para parâmetros “will-move-from”, passe by X&&e std::moveo parâmetro ).

    • 4

relate perguntas