Me gustaría usar el boost::matriz como un miembro de la clase, pero no sé el tamaño en tiempo de compilación.
Pensé en algo como esto, pero no funciona:

int main() {
    boost::array<int, 4> array = {{1,2,3,4}};
    MyClass obj(array);
}

class MyClass {
    private:
        boost::array<int, std::size_t> array;
    public:
        template<std::size_t N> MyClass(boost::array<int, N> array)
        : array(array) {};
};

El compilador gcc, dice:

error: type/value mismatch at argument 2 in template parameter list for
  template<class _Tp, long unsigned int _Nm> struct boost::array
error:   expected a constant of type long unsigned int’, got size_t

Que obviamente significa que uno no puede utilizar la variable de tamaño de las matrices como miembros de la clase. Si es así, esto sería negar todas las ventajas de boost::conjunto de vectores o arrays estándar.

¿Me puedes mostrar lo que hice mal?

7 Comentarios

  1. 19

    Impulso de la matriz es de tamaño fijo basado en el segundo parámetro de plantilla, y boost::array<int,4> es un diferentes tipo de de boost::array<int,2>. Usted no puede tener instancias de la misma clase (Miclase en tu ejemplo) que tienen diferentes tipos para sus miembros.

    Sin embargo, std::vectores pueden tener diferentes tamaños sin ser de diferentes tipos:

    struct MyClass {
      template<std::size_t N>
      explicit
      MyClass(boost::array<int, N> const& array)
      : data(array.begin(), array.end())
      {}
    
    private:
      std::vector<int> data;
    };
    
    int main() {
      boost::array<int, 4> a = {{1,2,3,4}};
      MyClass obj(a);
    
      boost::array<int, 2> a2 = {{42,3}};
      MyClass obj2(a2);
    
      //notice obj.data.size() != obj2.data.size()
    
      return 0;
    }

    Que dijo, boost::array es todavía útil (es útil en este código de ejemplo), pero no de la manera exacta que usted desea utilizar.

  2. 12

    Que faltan algunos puntos básicos. Usted puede tener:

    1. Un estáticamente asignados en la matriz se char arr[10];
    2. Un dinámicamente asignados en la matriz se char* arr = new arr[10];

    La primera de ellas del tamaño es conocido en tiempo de compilación (porque el tamaño es un constante), por lo tanto, usted puede asignar previamente un espacio de memoria para ella, el otro no lo es, por lo tanto es necesario asignar memoria para que durante el tiempo de ejecución.

    STL/TR1/Boost proporciona contenedores para ambos tipos de matrices. Esas no son sólo contenedores para convieniece, pero también para la seguridad (intervalo de comprobación en algunas situaciones) y el poder (iteradores). Para ambos casos tenemos un contenedor independientes:

    1. Asignado estáticamente matriz de contenedor boost::array<char,10> arr;
    2. Asignada dinámicamente matriz de contenedor std::vector<char> arr;

    El último tiene la ventaja de ser auto cambio de tamaño, y permite cambiar el tamaño, además de ser dinámicamente allocatable. boost::array por otra parte, imita a un type arr[const] construir.

    Por lo tanto, usted necesita decidir si desea que la clase tenga memoria asignada estáticamente o dinámicamente. El primero, sólo tiene sentido si las clases de almacenamiento es de tamaño fijo, o uno de los pocos tamaños fijos. Esto último tiene sentido en todos los demás casos.

    Asignado estáticamente, sería el uso de plantillas

    template < size_t N >
    class MyClass {
    private:
        boost::array< int, N > array;
    public:
       MyClass(boost::array< int, N > array) : array(array) {};
    };
    
    //...
    
    boost::array<int, 4> array = {{1,2,3,4}};
    MyClass<4> obj(array);

    Pero sería crear código separado para cada tamaño de la clase, y que no iba a ser inter-operable (esto puede evitarse, sin embargo).

    Asignada dinámicamente haría uso de vectores

    class MyClass {
    private:
        std::vector< int > array;
    public:
       MyClass(const std::vector< int >& array) : array(array) {};
    };

    No tenga miedo de vectores, de tratarlos como a la asignación dinámica de las matrices — el resizingness de vectores es un beneficio adicional que no afecta el rendimiento de casi todos.

  3. 3

    No, boost::array (es en TR1 como std::tr1::array) es un estáticamente tamaño de búfer. El punto de la clase es para evitar una asignación dinámica de memoria – se puede poner un boost::matriz completamente de la pila.

    Usted puede hacer su clase de ejemplo tomar una plantilla de tipo int y que pase a la boost::miembro de la matriz,

    template<int Size>
    class MyClass
    {
    private:
        boost::array<int, Size> m_array;
    public:
        //....
    };

    Pero eso es sólo vestirse, es todavía una asignación estática.

    • Tenga en cuenta que esta solución se traslada el problema a la clase Miclase (donde cada plantilla de la creación de instancias de se convierta en un tipo diferente). Dependiendo de la tarea actual de la interrogador esto puede funcionar, pero lo dudo.
    • También «es» no asignación, la frase es engañosa.
    • Eso es lo que entiende por ser simplemente «vestir» y la estática del tamaño de las asignaciones (y de la pila de asignaciones) son todavía las asignaciones.
  4. 1

    Te equivocas sobre el error :

        template<unsigned long N> MyClass(boost::array<int, N> array) : array(array) {};

    Debería funcionar. Por la forma en que esto todavía va a generar la matriz en tiempo de compilación, así que no es una buena solución. Y otros se produzcan errores.

    Aquí lo que queremos es un vector, con un reservado tamaño y algunas afirmaciones que mantener la capacidad en un tamaño fijo.

    • El error mencionado es acerca de boost::array<int, std::size_t>, y parece que se va a interpretar correctamente.
  5. 1

    Si ya la ha aceptado una respuesta, por favor, tenga en cuenta que std::vector puede no ser la opción correcta para su tarea. Si desea crear la matriz de una vez – un tamaño fijo de la matriz de – y no desea cambiar el tamaño de ella más adelante, luego de un buen viejo llano matriz puede ser la opción correcta para usted! Ignorar boost::array, ignorar std::vector, sus intenciones son muy diferentes, keep it simple. BESO, YAGNI y así sucesivamente…

    int main() {
        int* array = new int[4];
        for( int i=0; i<4; ++i ) array[i] = i+1;
        MyClass obj(array);
    }
    
    class MyClass {
        private:
            int* array;
        public:
            MyClass( int* array )
            : array(array) {}
            ~MyClass() { delete[] array; }
    };

    EDICIÓN: Como Nikolai N Fetissov ya se ha dicho, boost::scoped_array podría ser una buena opción. Proporciona una fina RAII envoltura alrededor de la matriz. Aquí está un ejemplo de uso (espero que sea la correcta, siéntase libre de modificar lo contrario):

    class MyClass {
        private:
            boost::scoped_array<int> array;
        public:
            MyClass( int* array )
            : array(array) {}
    };
    • Hmm, la falta de constructor de copia y copia operador de asignación aquí.
    • boost::matriz/tr1::array es una muy envoltura alrededor de un tamaño fijo de la matriz – de hecho, no tiene ninguna sobrecarga. Literalmente no hay razón para usar un estilo C de la matriz cuando tr1::array está disponible.
    • Terry: ¿usted ha leído la pregunta? No hay razón para votar por mí, si no a entender la intención de la pregunta.
    • Terry: El «estilo C matrices», como usted los llama, son un ajuste perfecto cuando el tamaño de la matriz es desconocido en tiempo de compilación. tr1/boost::matriz requiere que el tamaño es conocido en tiempo de compilación, por lo que está fuera de toda duda. ESE es el punto.
  6. 0

    Si usted no necesita la dinámica de cambio de tamaño, no necesita std::vector

    sólo tienen la función de aceptar *int

    MyFunction (int* array,int size); //function prototype

    y pase el boost::array ‘s .de datos() puntero a los datos…

    boost::array<int,4> testArray;
    boost::array<int,5> testArray2;
    
    //Calling the function:
    MyFunction(testArray.data(),4);
    MyFunction(testArray2.data(),5);

    la clave .los datos de() a la gente!!! Si usted desea aumentar las matrices para reemplazar las matrices normales, esta es quizás la forma (sin tener que usar las plantillas y todo eso)

Dejar respuesta

Please enter your comment!
Please enter your name here