Soy nuevo en C/C++ y he sido grietas de mi cabeza, pero todavía tengo ni idea de cómo hacer una “estructura” como este

3D de la matriz de C++ usando int [] operador

Se supone que para ser un 3D matriz dinámica usando punteros.

Empecé como este, pero se quedó atascado allí

  int x=5,y=4,z=3;
  int ***sec=new int **[x];

Sería suficiente para saber cómo hacerlo para una estática tamaño de y y z;

Por favor, te agradecería que me puede ayudar.

Gracias de antemano.

OriginalEl autor Marco Aviles | 2010-10-11

7 Comentarios

  1. 21

    Para crear de forma dinámica en 3D array de enteros, es mejor entender 1D y 2D de la matriz de la primera.

    1D array: Usted puede hacer esto muy fácilmente por

    const int MAX_SIZE=128;
    int *arr1D = new int[MAX_SIZE];

    Aquí, estamos creando un int-puntero que apunta a un bloque de memoria donde los números enteros pueden ser almacenados.

    Matriz 2D: Se puede utilizar la solución de arriba 1D array para crear una matriz 2D. En primer lugar, crear un puntero que se debe señalar a un bloque de memoria donde sólo otro número entero que los punteros a cabo, que en última instancia punto a datos reales. Desde nuestros primeros puntos de puntero a un array de punteros por lo que este será llamado como puntero a puntero (doble puntero).

    const int HEIGHT=20;
    const int WIDTH=20;
    
    int **arr2D = new int*[WIDTH];  //create an array of int pointers (int*), that will point to 
                                    //data as described in 1D array.
    for(int i = 0;i < WIDTH; i++){
          arr2D[i] = new int[HEIGHT]; 
    }

    Matriz 3D: Esto es lo que quieres hacer. Aquí usted puede probar tanto el esquema utilizado en los dos casos anteriores. Aplicar la misma lógica de matriz 2D. Diagrama en cuestión explica todo. La primera matriz va a ser un puntero a puntero a puntero (int*** – ya que los puntos a doble punteros). La solución es la siguiente:

    const int X=20;
    const int Y=20;
    const int z=20;
    
    int ***arr3D = new int**[X];
    for(int i =0; i<X; i++){
       arr3D[i] = new int*[Y];
       for(int j =0; j<Y; j++){
           arr3D[i][j] = new int[Z];
           for(int k = 0; k<Z;k++){
              arr3D[i][j][k] = 0;
           }
       }
    }
    También puede utilizar este método para N-matrices de Dimensión N-1 para los bucles.
    tal vez mencionar la correspondiente funcionalidad de eliminar así..
    Shukla En la Matriz 3D de código que de X, y y Z representa la Anchura, la altura y la profundidad ??
    No creo que 3Dimentional matriz como un cuadro que tiene la anchura/altura/profundidad. La forma en que se construyó la matriz 3D es tuvimos que una simple 1D array, cada elemento de esta matriz de puntos a otro 1D array y de nuevo cada elemento de los que señala de nuevo 1D array que contendrá los valores reales. Si puedes visualizar esto, entonces usted tendrá ans a su pregunta, si usted quiere tomar esto como la anchura/altura/profundidad. Si aún necesita ayuda, por favor deje un comentario.
    Yo creo que de esta manera porque estoy tratando de implementar una programación dinámica matriz similar a Needlman wunsch algoritmo

    OriginalEl autor Manish Shukla

  2. 11
    //one-liner
    typedef std::vector<std::vector<std::vector<int> > > ThreeDimensions;
    //expanded
    typedef std::vector<int> OneDimension;
    typedef std::vector<OneDimension> TwoDimensions;
    typedef std::vector<TwoDimension> ThreeDimensions;

    (esto es etiquetados c++, después de todo)

    EDITAR en respuesta a Joe a la pregunta de

    hola de nuevo Joe =) seguro. aquí está el ejemplo:

    #include <vector>
    #include <iostream>
    int main(int argc, char* const argv[]) {
    /* one-liner */
    typedef std::vector<std::vector<std::vector<int> > >ThreeDimensions;
    /* expanded */
    typedef std::vector<int>OneDimension;
    typedef std::vector<OneDimension>TwoDimensions;
    typedef std::vector<TwoDimensions>ThreeDimensions;
    /*
    create 3 * 10 * 25 array filled with '12'
    */
    const size_t NElements1(25);
    const size_t NElements2(10);
    const size_t NElements3(3);
    const int InitialValueForAllEntries(12);
    ThreeDimensions three_dim(NElements3, TwoDimensions(NElements2, OneDimension(NElements1, InitialValueForAllEntries)));
    /* the easiest way to assign a value is to use the subscript operator */
    three_dim[0][0][0] = 11;
    /* now read the value: */
    std::cout << "It should be 11: " << three_dim[0][0][0] << "\n";
    /* every other value should be 12: */
    std::cout << "It should be 12: " << three_dim[0][1][0] << "\n";
    /* get a reference to a 2d vector: */
    TwoDimensions& two_dim(three_dim[1]);
    /* assignment */
    two_dim[2][4] = -1;
    /* read it: */
    std::cout << "It should be -1: " << two_dim[2][4] << "\n";
    /* get a reference to a 1d vector: */
    OneDimension& one_dim(two_dim[2]);
    /* read it (this is two_dim[2][4], aka three_dim[1][2][4]): */
    std::cout << "It should be -1: " << one_dim[4] << "\n";
    /* you can also use at(size_t): */
    std::cout << "It should be 12: " << one_dim.at(5) << "\n";
    return 0;
    }
    +1 por el camino para ir si este diseño de memoria es realmente lo que el OP quiere

    OriginalEl autor justin

  3. 1

    Usted puede probar:

    for(int i=0;i<x;i++) {
    sec[i] = new int *[y];
    for(int j=0;j<y;j++) {
    sec[i][j] = new int [z];
    }
    }

    Y una vez que haya terminado de usar esta memoria puede desasignar como:

    for(int i=0;i<x;i++) {
    for(int j=0;j<y;j++) {
    delete [] sec[i][j];
    }
    delete [] sec[i];
    }
    delete [] sec;

    OriginalEl autor codaddict

  4. 1

    Respuestas exhaustivas.

    Si realmente estás escribiendo esto en C++ (no áspero C) creo que debería echar otro vistazo a esta complicada estructura de datos. OMI rediseño teniendo en cuenta lo que usted está tratando de hacer, sería mejor.

    OriginalEl autor Keynslug

  5. 1

    Lo que estamos tratando de hacer es no idiomática en C++. Por supuesto, usted puede utilizar un int***pointer para esto, pero esto no se recomienda. En C++ tenemos mejores maneras de llegar allí.

    vector<vector<vector<int> > > foo (5,vector<vector<int> >(4, vector<int>(3)));

    Esto va a resultar en algo con el diseño de memoria similar a lo que usted pidió. Se admite la dinámica de cambio de tamaño y el interior de los vectores que tienen diferentes tamaños como en su imagen. Además, usted no tiene que preocuparse acerca de la asignación manual /eliminación de ello. También, los vectores saber su tamaño, por lo que no tiene que recordar en algún lugar.

    Pero si lo que desea es una “rectangular” matriz 3D en donde todos los elementos son consecutivly almacenados en el mismo bloque de memoria, puede utilizar un boost::multiarray.

    OriginalEl autor sellibitze

  6. 0

    ACEPTAR tomemos sus inicios

    int ***sec = new int**[x]; 

    sec es ahora un array de int**s de la longitud x, así que ahora me voy a centrar en hacer el zeroeth elemento sea lo que usted quiere

    sec[0] = new int*[y];

    Ahora s[0] apunta a un array de int*s de longitud y, ahora sólo tiene que conseguir el último bit del árbol de hecho, por lo que

    sec[0][0] = new int[z];

    Y, finalmente, llegar a la forma en que su diagrama

    sec[0][0][z-1] = 0;

    Esto parece un poco como una tarea pregunta, asegúrese de que usted realmente entender la respuesta y por qué funciona.

    sec no es un array. Es un puntero que apunta al primer elemento de una matriz.
    Que es más bien semántica. Para ser justos, en casos como los de tipo int x[10]; x es realmente un puntero al primer elemento de un array, y una matriz de ambos. No hay realmente una diferencia entre ser un puntero al primer elemento de una matriz y ser una matriz.

    OriginalEl autor Aurojit Panda

Dejar respuesta

Please enter your comment!
Please enter your name here