C ++ dynamisch zugewiesen Array von Arrays statisch dimensionierte

Question

ich brauche eine Struktur zu schaffen, die eine variable Anzahl von 'char [2]' s hält, d.h. statische Arrays von 2 Zeichen.

Meine Frage ist, wie kann ich Speicher für x Anzahl der Zeichen zuteilen [2].

Ich habe versucht, diese (unter der Annahme int x definiert ist):

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

(es hat nicht funktioniert)

Ich weiß, ich könnte std :: vector verwenden als Container, aber ich bin gespannt, wie es mit rohen Zeigern getan würde.

Ich bin sehr neu in C ++ und versuchen zu lernen.

Answer 1

In Ihrem Code, die Art von ‚m‘ entspricht nicht Ihren ‚neuen‘ Anruf. Was Sie wollen, ist:

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

m ist ein Zeiger auf Arrays von 2 Zeichen, und rufen Sie neu eine Reihe von x-Arrays von 2 Zeichen und Punkt m auf dem ersten zu erhalten.

Answer 2

Ich glaube, dass der folgende Code besser lesbar als char[n][2] ist:

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

Wenn wir Kenntnis von der inneren Struktur von wchar, wird der Code besser lesbar, wenn wir es erklären, wie folgt:

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

Und schließlich, weil wir verwenden C ++, keine Notwendigkeit, C-Arrays zu verwenden:

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;

Eine weitere ziemlich sichere Option mit der Kompilierung Bereichsprüfung:

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

Sie würde die Größe des Arrays am Ende zu bestimmen und dann neu verwenden, und behandeln es als ein zweidimensionales Array.

Aber für eine gute Diskussion zu diesem Thema können Sie wollen, betrachten: http://www.velocityreviews.com/forums/t283481-dynamic- mehrdimensionale-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 Mehrdimensionale Arrays (wobei alle bis auf die ersten Abmessungen konstant sind) sind aneinander angrenzend angeordnet.

Wenn Sie einen (möglicherweise gezackt) mehrdimensionales Array wollen, die eine 1D-Array von 1d-Arrays ist, dann müssen Sie eine Schleife:

  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;