es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

  • es.davy.ai/
  • Programación /
  • Cómo inicializar un std::vector a partir de plantillas variadicas con tipos diferentes cada uno?

Cómo inicializar un std::vector a partir de plantillas variadicas con tipos diferentes cada uno?

19 Jul, 2023 Programación

Mi problema principal es que estoy intentando crear una función que inicialice un std::vector de una clase que puede ser inicializada de diferentes maneras, así que decidí usar plantillas variádicas, pero, como en este ejemplo, eso no se compila:

#include <iostream>
#include <string>
#include <vector>

using namespace std;

struct MyClass {
    MyClass(int v): value(v){}
    MyClass(string v): value(stoi(v)){}
    int value;
};

template<typename ...args=""> vector<myclass> mc_vector(const Args &...args);

int main()
{
    auto vec = mc_vector(1, "3", 5);
    for (auto &i : vec)
        cout << i.value << " ";
    cout << endl;
}

template<typename ...args,="" typename="" t=""> void mc_vector_(vector<myclass>& vec, const Args &...args, const T& t) {
    vec.emplace_back(t);
    mc_vector_(vec, args...);
}

template<typename ...args=""> vector<myclass> mc_vector(const Args &...args) {
    vector<myclass> vec;
    vec.reserve(sizeof...(args));
    mc_vector_(vec, args...);
    return vec;
}

Y en realidad, me gustaría saber si imaginas una forma más inteligente de hacer esto.

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Como modelo de lenguaje de IA, no puedo prometer una forma “más inteligente” de hacer esto, pero puedo sugerir algunas soluciones potenciales para el problema en cuestión.

    El error en el ejemplo proporcionado se debe al hecho de que la invocación de la función de plantilla variádica depende de al menos un parámetro de plantilla no variádica, T. En otras palabras, el compilador no puede deducir los tipos de Args en mc_vector_ sin conocer primero el tipo de T, y viceversa. Una posible solución para esto es mover T al final de la lista de parámetros, de la siguiente manera:

    “`c++
    template
    void mc_vector_(vector& vec, const Args &…args, const T& t) {
    vec.emplace_back(t);
    mc_vector_(vec, args…);
    }


    Otra opción es usar una sobrecarga de `mc_vector_` que solo tome un argumento:

```c++
template<typename t="">
void mc_vector_(vector<myclass>& vec, const T& t) {
    vec.emplace_back(t);
}

template<typename arg,="" typename="" ...args="">
void mc_vector_(vector<myclass>& vec, const Arg& arg, const Args&... args) {
    vec.emplace_back(arg);
    mc_vector_(vec, args...);
}

    Ambas soluciones deberían permitir el uso deseado de mc_vector con diferentes tipos de argumentos.

Comments are closed.