Estoy usando gcc versión 4.9.2 Si compilo usando el indicador del compilador -std = c ++ 0x, el siguiente código compila OK.

#include <iostream>
#include <vector>

using namespace std;
typedef struct
{
    vector<int> a;
    int b;
} MYTYPE;

int main(void)
{
    MYTYPE test[]=
    {
        { {1,2,3},4},
        { {5,6},7},
        { {},8}
    };
}

Si elimino el indicador -std = c ++ 0x, el compilador informa:

error: no se pudo convertir ‘{1, 2, 3} 'de‘' a ‘std :: vector '

¿Cuál es una forma elegante de inicializar la prueba []?

4
monzie 22 ene. 2018 a las 18:37

3 respuestas

La mejor respuesta

Con C ++ 98, lo mejor que se puede lograr es probablemente la definición y el uso de una función auxiliar:

struct Data
{
    std::vector<int> vector;
    int scalar;
};

template<std::size_t N>
Data make_data(const int (&vector)[N], int scalar)
{
    Data result;
    result.vector.assign(vector, vector+N);
    result.scalar = scalar;
    return result;
}

int main()
{
    const int vector[] = {1,2,3}; // just to annoy people using namespace std :)
    Data d = make_data(vector, 4);
    std::cout << d.vector[2] << "\n" << d.scalar << "\n";
}

demo en vivo

2
YSC 22 ene. 2018 a las 15:59

Puede copiar la solución de Boost.Assign.

Algo así como el código a continuación, sin embargo, podríamos considerarlo elegante "solo si se hace una vez, se usa muchas veces.

Gol:

MYTYPE mm[] = {
    { VectorBuilder<int>(1)(2)(3), 4},
    { VectorBuilder<int>(3)(4)(5), 4}
};

Solución (ejemplo de trabajo):

template <typename T>
class VectorBuilder
{
public:
    VectorBuilder(T val) : val(val), prev(0), next(0), first(this)
    {}

    VectorBuilder operator ()(T val) const
    {
        return VectorBuilder(val, this);
    }

    operator std::vector<T>() const
    {
        std::vector<T> vv;
        vv.reserve(this->getSize());
        this->build(vv);
        return vv;
    }

private:

    T val;
    const VectorBuilder* prev;
    mutable const VectorBuilder* next;
    const VectorBuilder* first;

    VectorBuilder(T val, const VectorBuilder* prev) 
      : val(val), prev(prev), next(0), first(prev->first)
    {
        prev->next = this;
    }

    std::size_t getSize() const
    {
        // TODO - see working example link
    }

    void build(std::vector<T>& vv) const
    {
        // TODO - see working example link
    }

};
0
PiotrNycz 22 ene. 2018 a las 16:41

Además de lograr una apariencia de elegancia en el sitio de llamadas escribiendo un conjunto de constructores horribles en su struct, no hay una forma particularmente elegante de inicializar una matriz de estos struct s pre-C ++ 11 .

Fue precisamente para estas construcciones que se desarrolló la sintaxis de C ++ 11.

4
Bathsheba 22 ene. 2018 a las 15:39
48385185