Array allocato dinamicamente C ++ di array dimensionati staticamente

Question

Devo creare una struttura che contenga un numero variabile di "char [2]", ovvero array statici di 2 caratteri.

La mia domanda è: come posso allocare memoria per x numero di caratteri [2].

Ho provato questo (supponendo che int x sia definito):

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

(non ha funzionato)

Mi rendo conto che potrei usare std :: vector < char [2] > come contenitore, ma sono curioso di sapere come si farebbe con i puntatori non elaborati.

Sono molto nuovo in C ++ e sto cercando di imparare.

Answer 1

Nel tuo codice, il tipo di 'm' non corrisponde alla tua 'nuova' chiamata. Quello che vuoi è:

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

m è un puntatore ad array di 2 caratteri e tu chiami new per ottenere un array di x array di 2 caratteri e punta m al primo.

Answer 2

Credo che il seguente codice sia più leggibile di 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 siamo a conoscenza della struttura interna di wchar, il codice sarà più leggibile se lo dichiariamo come segue:

// 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 infine, poiché utilizziamo C ++, non è necessario utilizzare le matrici 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;

Un'altra opzione abbastanza sicura con controllo dell'intervallo di tempo di compilazione:

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

Alla fine si determinerebbe la dimensione dell'array, quindi si userebbe nuovo e lo si tratterà come un array bidimensionale.

Ma, per una buona discussione su questo, potresti voler guardare: http://www.velocityreviews.com/forums/t283481-dynamic- multidimensionale-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 array multidimensionali (dove tutte tranne le prime dimensioni sono costanti) sono disposti contigui.

Se si desidera un array multidimensionale (potenzialmente frastagliato) che è un array 1d di array 1d, è necessario eseguire il 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;