C ++ matriz asignada dinámicamente de matrices estáticamente dimensionadas

Question

Necesito crear una estructura que contenga un número variable de 'char [2]', es decir, matrices estáticas de 2 caracteres.

Mi pregunta es, ¿cómo asigno memoria para x número de caracteres [2].

Intenté esto (suponiendo que int x está definido):

char** m = NULL;
m = new char[x][2];
...
delete [] m;

(no funcionó)

Me doy cuenta de que podría usar std :: vector < char [2] > como contenedor, pero tengo curiosidad por saber cómo se haría con punteros en bruto.

Soy muy nuevo en C ++ e intento aprender.

Answer 1

En su código, el tipo de 'm' no coincide con su llamada 'nueva'. Lo que quieres es:

char (*m)[2] = NULL;
m = new char[x][2];
...
delete [] m;

m es un puntero a matrices de 2 caracteres, y llama a new para obtener una matriz de matrices x de 2 caracteres y apunta m en la primera.

Answer 2

Creo que el siguiente código es más legible que char[n][2]:

typedef char wchar[2];   // array of two chars
const size_t n = 100;    // some const
wchar* x = new wchar[n]; // array of wchars, where wchar is array of two chars

// here is still a problem that you could write the following
x[5][5] = 0;             // not what you expected?

delete[] x;              // clean up

Si conocemos la estructura interna de wchar, el código será más legible si lo declaramos de la siguiente manera:

// using struct is just gives names to chars in wchar, without performance drop
struct wchar {
  char h;
  char l;
};

...

const size_t n = 100;    // some const
wchar* x = new wchar[n]; // array of wchars

x[0].h = 0;
x[0].l = 0;

delete[] x;              // clean up

Y finalmente, debido a que usamos C ++, no es necesario usar matrices C:

const size_t n = 100;    // some const   
typedef std::tr1::array<wchar, n> my_arr;
my_arr* x = new my_arr;

(*x)[0].h = 0;
(*x)[0].l = 0;

delete x;

Una opción más segura con la comprobación del rango de tiempo de compilación:

template<int n_max>
struct array_n {
    char v[2*n_max];

    template<size_t n, size_t s> 
    char& get() {
        BOOST_STATIC_ASSERT( s < 2 );
        BOOST_STATIC_ASSERT( n < n_max );
        return v[n*2+s];
    };  
};

int main( int argc, char**argv)
{
    const size_t n = 100;    // some const   
    typedef array_n<100> my_arr;
    my_arr* x = new my_arr;

    x->get<10, 1>() = 0;   // ok
    x->get<50, 0>() = 0;   // ok
    x->get<10, 2>() = 0;   // compile time error
    x->get<500, 0>() = 0;  // compile time error

    delete x;
}

Answer 3

Terminaría determinando el tamaño de la matriz, y luego usaría nueva, y la trataría como una matriz bidimensional.

Pero, para una buena discusión sobre esto, es posible que desee mirar: http://www.velocityreviews.com/forums/t283481-dynamic- multidimensional-arrays.html

Answer 4

unsigned x=10;
typedef char A2[2];
A2 *m=new A2[x];
m[0][1]='a';
m[9][0]='b';
delete[] m;

Las matrices multidimensionales C (donde todas menos las primeras dimensiones son constantes) se presentan contiguamente.

Si desea una matriz multidimensional (potencialmente irregular) que es una matriz 1d de matrices 1d, entonces debe realizar un bucle:

  char **m=new char *[x];
  for (unsigned i=0;i<x;++i) m[i]=new char[2];
  ...
  for (unsigned i=0;i<x;++i) delete[] m[i];
  delete[] m;