C ++ Matriz alocada dinamicamente de matrizes estaticamente dimensionadas

Question

Eu preciso criar uma estrutura que contém um número variável de 'char [2], ou seja, matrizes estáticas de 2 chars.

Minha pergunta é: como aloco a memória para x número de char [2].

Eu tentei isso (assumindo que int x está definido):

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

(não funcionou)

Eu percebo que poderia usar std :: vetoru003Cchar[2]> Como contêiner, mas estou curioso sobre como isso seria feito com indicadores crus.

Sou muito novo no C ++ e tentando aprender.

Answer 1

No seu código, o tipo de 'm' não corresponde à sua chamada 'nova'. O que você quer é:

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

M é um ponteiro para matrizes de 2 chars, e você liga para o novo para obter uma matriz X de 2 chars e ponto M no primeiro.

Answer 2

Eu acredito que o código a seguir é mais legível do 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

Se estivermos cientes da estrutura interna do WCHO, o código será mais legível se o declararmos da seguinte forma:

// 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

E, finalmente, porque usamos C ++, não há necessidade de usar matrizes 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;

Mais uma opção bastante segura com a verificação do intervalo de tempo de compilação:

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

Você acabaria determinando o tamanho da matriz e depois o usaria e o trataria como uma matriz bidimensional.

Mas, para uma boa discussão sobre isso, você pode querer ver: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;

C matrizes multidimensionais (onde todas, exceto as primeiras dimensões, são constantes) são apresentadas de maneira contígua.

Se você deseja uma matriz multidimensional (potencialmente irregular), que é uma matriz 1D de matrizes 1D, então você deve fazer um loop:

  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;