newを使用してC ++で2D配列を宣言するにはどうすればよいですか？

newを使用して2D配列を宣言するにはどうすればよいですか？

同様に、「通常の」配列の場合、次のようにします。

int* ary = new int[Size]

だが

int** ary = new int[sizeY][sizeX]

a）動作/コンパイルせず、b）何を達成しない：

int ary[sizeY][sizeX] 

します。

動的2D配列は、基本的に配列へのポインタの配列です。次のように、ループを使用して初期化できます。

int** a = new int*[rowCount];
for(int i = 0; i < rowCount; ++i)
    a[i] = new int[colCount];

上記のcolCount= 5およびのrowCount = 4場合、次のようになります。

int** ary = new int[sizeY][sizeX]

でなければなりません：

int **ary = new int*[sizeY];
for(int i = 0; i < sizeY; ++i) {
    ary[i] = new int[sizeX];
}

そして、クリーンアップは次のようになります：

for(int i = 0; i < sizeY; ++i) {
    delete [] ary[i];
}
delete [] ary;

編集：ディートリッヒエップがコメントで指摘したように、これは正確には軽量ソリューションではありません。別のアプローチは、1つの大きなメモリブロックを使用することです。

int *ary = new int[sizeX*sizeY];

// ary[i][j] is then rewritten as
ary[i*sizeY+j]

が、この人気の答えはあなたの希望インデックス構文を与えるだろう、それは二重に非効率的である：大きく、空間と時間の両方を遅らせます。もっと良い方法があります。

なぜその答えが大きくて遅いのか

提案された解決策は、ポインターの動的配列を作成してから、各ポインターを独自の独立した動的配列に初期化することです。このアプローチの利点は、使い慣れたインデックス構文を提供することです。そのため、x、yの位置にある行列の値を検索する場合は、次のようにします。

int val = matrix[ x ][ y ];

これは、matrix [x]が配列へのポインタを返し、[y]でインデックス付けされるため、機能します。それを分解する：

int* row = matrix[ x ];
int  val = row[ y ];

便利ですね [x] [y]構文が好きです。

しかし、このソリューションには大きな欠点があります。

どうして？

それが太っていると同時に遅いという理由は、実際には同じです。行列の各「行」は、個別に割り当てられた動的配列です。ヒープの割り当ては、時間とスペースの両方でコストがかかります。アロケータは割り当てに時間がかかり、O（n）アルゴリズムを実行することもあります。また、アロケータは、行の配列のそれぞれに、ブックキーピングとアライメントのために追加のバイトを「パディング」します。その余分なスペースは...まあ...余分なスペースがかかります。デアロケータがしますまた、あなたが苦労して、個々の行の割り当てを自由-INGの、行列の割り当てを解除するために行くときに余分な時間がかかります。考えているだけで汗だくになる。

それが遅いもう一つの理由があります。これらの個別の割り当ては、メモリの不連続な部分に存在する傾向があります。1つの行がアドレス1,000にあり、別の行がアドレス100,000にある可能性があります。これは、マトリックスをトラバースしているときに、野生の人のように記憶を飛び越えていることを意味します。これにより、キャッシュミスが発生し、処理時間が大幅に遅くなる傾向があります。

したがって、絶対にかわいい[x] [y]インデックス構文が必要な場合は、そのソリューションを使用してください。迅速性と小型化が必要な場合（およびそれらを気にしない場合、なぜC ++で作業しているのですか？）、別のソリューションが必要です。

別のソリューション

より良い解決策は、マトリックス全体を単一の動的配列として割り当て、独自の（わずかに）巧妙なインデックス計算を使用してセルにアクセスすることです。索引付けの計算はごくわずかですが賢いです。いや、それはまったく賢くない：それは明白です。

class Matrix
{
    ...
    size_t index( int x, int y ) const { return x + m_width * y; }
};

このindex()関数（私が想像しているのm_widthは、マトリックスのを知る必要があるため、クラスのメンバーであると想定しています）を指定すると、マトリックス配列内のセルにアクセスできます。行列配列は次のように割り当てられます：

array = new int[ width * height ];

だから、遅い、太いソリューションでこれに相当するもの：

array[ x ][ y ]

...これは迅速で小さなソリューションです：

array[ index( x, y )]

悲しい、私は知っています。しかし、あなたはそれに慣れるでしょう。そしてあなたのCPUはあなたに感謝します。

C ++ 11では、次のことが可能です。

auto array = new double[M][N]; 

この方法では、メモリは初期化されません。これを初期化するには、代わりに次のようにします。

auto array = new double[M][N]();

サンプルプログラム（ "g ++ -std = c ++ 11"でコンパイル）：

#include <iostream>
#include <utility>
#include <type_traits>
#include <typeinfo>
#include <cxxabi.h>
using namespace std;

int main()
{
    const auto M = 2;
    const auto N = 2;

    // allocate (no initializatoin)
    auto array = new double[M][N];

    // pollute the memory
    array[0][0] = 2;
    array[1][0] = 3;
    array[0][1] = 4;
    array[1][1] = 5;

    // re-allocate, probably will fetch the same memory block (not portable)
    delete[] array;
    array = new double[M][N];

    // show that memory is not initialized
    for(int r = 0; r < M; r++)
    {
        for(int c = 0; c < N; c++)
            cout << array[r][c] << " ";
        cout << endl;
    }
    cout << endl;

    delete[] array;

    // the proper way to zero-initialize the array
    array = new double[M][N]();

    // show the memory is initialized
    for(int r = 0; r < M; r++)
    {
        for(int c = 0; c < N; c++)
            cout << array[r][c] << " ";
        cout << endl;
    }

    int info;
    cout << abi::__cxa_demangle(typeid(array).name(),0,0,&info) << endl;

    return 0;
}

出力：

2 4 
3 5 

0 0 
0 0 
double (*) [2]

静的配列の例から、ギザギザの配列ではなく長方形配列が必要だと思います。次のものを使用できます。

int *ary = new int[sizeX * sizeY];

その後、次のように要素にアクセスできます。

ary[y*sizeX + x]

でdelete []を使用することを忘れないでくださいary。

C ++ 11以降でこれをお勧めする2つの一般的なテクニックがあります。1つはコンパイル時のディメンション用で、もう1つはランタイム用です。どちらの回答も、均一な2次元配列（ギザギザのない配列）が必要だと想定しています。

時間ディメンションのコンパイル

使用std::arrayのをstd::arrayしてから使用してnewヒープ上にそれを置くために：

// the alias helps cut down on the noise:
using grid = std::array<std::array<int, sizeX>, sizeY>;
grid * ary = new grid;

この場合も、コンパイル時に寸法のサイズがわかっている場合にのみ機能します。

ランタイムディメンション

実行時にのみ既知のサイズを持つ2次元配列を実現する最良の方法は、それをクラスにラップすることです。クラスはoperator []1次元配列を割り当て、次にオーバーロードして最初の次元のインデックスを提供します。これは、C ++では2D配列が行優先であるため機能します。

^{（http://eli.thegreenplace.net/2015/memory-layout-of-multi-dimensional-arrays/から取得）}

メモリの連続したシーケンスは、パフォーマンス上の理由から優れており、クリーンアップも簡単です。以下は、多くの便利なメソッドを省略しているが、基本的な考え方を示しているクラスの例です。

#include <memory>

class Grid {
  size_t _rows;
  size_t _columns;
  std::unique_ptr<int[]> data;

public:
  Grid(size_t rows, size_t columns)
      : _rows{rows},
        _columns{columns},
        data{std::make_unique<int[]>(rows * columns)} {}

  size_t rows() const { return _rows; }

  size_t columns() const { return _columns; }

  int *operator[](size_t row) { return row * _columns + data.get(); }

  int &operator()(size_t row, size_t column) {
    return data[row * _columns + column];
  }
}

したがって、std::make_unique<int[]>(rows * columns)エントリを持つ配列を作成します。operator []行にインデックスを付けるオーバーロードします。int *行の先頭を指すを返します。これは、列の通常の方法で逆参照することができます。ことを注意make_unique必要であれば、最初++ 14 Cでの船ができますが、C ++ 11でそれをポリフィルすることができます。

これらのタイプの構造がオーバーロードすることも一般的ですoperator()。

  int &operator()(size_t row, size_t column) {
    return data[row * _columns + column];
  }

^{技術的にはnewここでは使用していませんが、からに移動しstd::unique_ptr<int[]>て/ int *を使用するのは簡単です。newdelete}

この質問は私を悩ませていました-良い解決策がすでに存在していることは十分にありふれた問題であり、ベクトルのベクトルや独自の配列のインデックス付けよりも良いものです。

何かがC ++に存在するはずであるが存在しない場合、最初に確認する場所はboost.orgです。そこで、Boost多次元配列ライブラリmulti_arrayを見つけました。multi_array_ref独自の1次元配列バッファーをラップするために使用できるクラスも含まれています。

なぜSTL：vectorを使用しないのですか？とても簡単で、ベクターを削除する必要はありません。

int rows = 100;
int cols = 200;
vector< vector<int> > f(rows, vector<int>(cols));
f[rows - 1][cols - 1] = 0; // use it like arrays

「配列」を初期化して、デフォルト値を指定することもできます

const int DEFAULT = 1234;
vector< vector<int> > f(rows, vector<int>(cols, DEFAULT));

ソース：C / C ++で2、3（またはマルチ）次元配列を作成する方法？

2D配列は基本的に1Dのポインター配列であり、すべてのポインターは1D配列をポイントしており、実際のデータを保持します。

ここで、Nは行、Mは列です。

動的割り当て

int** ary = new int*[N];
  for(int i = 0; i < N; i++)
      ary[i] = new int[M];

埋める

for(int i = 0; i < N; i++)
    for(int j = 0; j < M; j++)
      ary[i][j] = i;

印刷する

for(int i = 0; i < N; i++)
    for(int j = 0; j < M; j++)
      std::cout << ary[i][j] << "\n";

自由

for(int i = 0; i < N; i++)
    delete [] ary[i];
delete [] ary;

GNU C ++で隣接する多次元配列を割り当てる方法は？「標準」構文を機能させるGNU拡張機能があります。

問題はオペレーターの新しい[]にあるようです。代わりに演算子newを使用してください：

double (* in)[n][n] = new (double[m][n][n]);  // GNU extension

そして、それだけです。C互換の多次元配列を取得します...

typedefはあなたの友達です

戻って他の多くの回答を調べた後、他の多くの回答はパフォーマンスの問題に悩まされているか、異常または負担の多い構文を使用して配列を宣言するか、配列にアクセスする必要があるため、より深い説明が必要であることがわかりました要素（または上記すべて）。

まず、この回答は、コンパイル時に配列の次元を知っていることを前提としています。その場合、これは最高のパフォーマンスを提供し、標準の配列構文を使用して配列要素にアクセスできるため、これが最良のソリューションです。

これにより最高のパフォーマンスが得られる理由は、すべての配列を連続したメモリブロックとして割り当てるためです。つまり、ページミスが少なくなり、空間的な局所性が向上する可能性があります。ループに割り当てると、割り当てループが他のスレッドやプロセスによって（場合によっては複数回）中断される可能性があるため、または単にたまたま利用可能な小さな空のメモリブロックを埋めるアロケータ。

その他の利点は、単純な宣言構文と標準配列アクセス構文です。

C ++ではnewを使用：

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {

typedef double (array5k_t)[5000];

array5k_t *array5k = new array5k_t[5000];

array5k[4999][4999] = 10;
printf("array5k[4999][4999] == %f\n", array5k[4999][4999]);

return 0;
}

またはcallocを使用したCスタイル：

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {

typedef double (*array5k_t)[5000];

array5k_t array5k = calloc(5000, sizeof(double)*5000);

array5k[4999][4999] = 10;
printf("array5k[4999][4999] == %f\n", array5k[4999][4999]);

return 0;
}

この問題は15年間私を悩ませてきました。また、提供されたすべてのソリューションは私にとって満足のいくものではありませんでした。動的な多次元配列をメモリ内で連続してどのように作成しますか？今日、私はようやく答えを見つけました。次のコードを使用して、それを行うことができます。

#include <iostream>

int main(int argc, char** argv)
{
    if (argc != 3)
    {
        std::cerr << "You have to specify the two array dimensions" << std::endl;
        return -1;
    }

    int sizeX, sizeY;

    sizeX = std::stoi(argv[1]);
    sizeY = std::stoi(argv[2]);

    if (sizeX <= 0)
    {
        std::cerr << "Invalid dimension x" << std::endl;
        return -1;
    }
    if (sizeY <= 0)
    {
        std::cerr << "Invalid dimension y" << std::endl;
        return -1;
    }

    /******** Create a two dimensional dynamic array in continuous memory ******
     *
     * - Define the pointer holding the array
     * - Allocate memory for the array (linear)
     * - Allocate memory for the pointers inside the array
     * - Assign the pointers inside the array the corresponding addresses
     *   in the linear array
     **************************************************************************/

    // The resulting array
    unsigned int** array2d;

    // Linear memory allocation
    unsigned int* temp = new unsigned int[sizeX * sizeY];

    // These are the important steps:
    // Allocate the pointers inside the array,
    // which will be used to index the linear memory
    array2d = new unsigned int*[sizeY];

    // Let the pointers inside the array point to the correct memory addresses
    for (int i = 0; i < sizeY; ++i)
    {
        array2d[i] = (temp + i * sizeX);
    }



    // Fill the array with ascending numbers
    for (int y = 0; y < sizeY; ++y)
    {
        for (int x = 0; x < sizeX; ++x)
        {
            array2d[y][x] = x + y * sizeX;
        }
    }



    // Code for testing
    // Print the addresses
    for (int y = 0; y < sizeY; ++y)
    {
        for (int x = 0; x < sizeX; ++x)
        {
            std::cout << std::hex << &(array2d[y][x]) << ' ';
        }
    }
    std::cout << "\n\n";

    // Print the array
    for (int y = 0; y < sizeY; ++y)
    {
        std::cout << std::hex << &(array2d[y][0]) << std::dec;
        std::cout << ": ";
        for (int x = 0; x < sizeX; ++x)
        {
            std::cout << array2d[y][x] << ' ';
        }
        std::cout << std::endl;
    }



    // Free memory
    delete[] array2d[0];
    delete[] array2d;
    array2d = nullptr;

    return 0;
}

値sizeX = 20およびsizeY = 15でプログラムを呼び出すと、出力は次のようになります。

0x603010 0x603014 0x603018 0x60301c 0x603020 0x603024 0x603028 0x60302c 0x603030 0x603034 0x603038 0x60303c 0x603040 0x603044 0x603048 0x60304c 0x603050 0x603054 0x603058 0x60305c 0x603060 0x603064 0x603068 0x60306c 0x603070 0x603074 0x603078 0x60307c 0x603080 0x603084 0x603088 0x60308c 0x603090 0x603094 0x603098 0x60309c 0x6030a0 0x6030a4 0x6030a8 0x6030ac 0x6030b0 0x6030b4 0x6030b8 0x6030bc 0x6030c0 0x6030c4 0x6030c8 0x6030cc 0x6030d0 0x6030d4 0x6030d8 0x6030dc 0x6030e0 0x6030e4 0x6030e8 0x6030ec 0x6030f0 0x6030f4 0x6030f8 0x6030fc 0x603100 0x603104 0x603108 0x60310c 0x603110 0x603114 0x603118 0x60311c 0x603120 0x603124 0x603128 0x60312c 0x603130 0x603134 0x603138 0x60313c 0x603140 0x603144 0x603148 0x60314c 0x603150 0x603154 0x603158 0x60315c 0x603160 0x603164 0x603168 0x60316c 0x603170 0x603174 0x603178 0x60317c 0x603180 0x603184 0x603188 0x60318c 0x603190 0x603194 0x603198 0x60319c 0x6031a0 0x6031a4 0x6031a8 0x6031ac 0x6031b0 0x6031b4 0x6031b8 0x6031bc 0x6031c0 0x6031c4 0x6031c8 0x6031cc 0x6031d0 0x6031d4 0x6031d8 0x6031dc 0x6031e0 0x6031e4 0x6031e8 0x6031ec 0x6031f0 0x6031f4 0x6031f8 0x6031fc 0x603200 0x603204 0x603208 0x60320c 0x603210 0x603214 0x603218 0x60321c 0x603220 0x603224 0x603228 0x60322c 0x603230 0x603234 0x603238 0x60323c 0x603240 0x603244 0x603248 0x60324c 0x603250 0x603254 0x603258 0x60325c 0x603260 0x603264 0x603268 0x60326c 0x603270 0x603274 0x603278 0x60327c 0x603280 0x603284 0x603288 0x60328c 0x603290 0x603294 0x603298 0x60329c 0x6032a0 0x6032a4 0x6032a8 0x6032ac 0x6032b0 0x6032b4 0x6032b8 0x6032bc 0x6032c0 0x6032c4 0x6032c8 0x6032cc 0x6032d0 0x6032d4 0x6032d8 0x6032dc 0x6032e0 0x6032e4 0x6032e8 0x6032ec 0x6032f0 0x6032f4 0x6032f8 0x6032fc 0x603300 0x603304 0x603308 0x60330c 0x603310 0x603314 0x603318 0x60331c 0x603320 0x603324 0x603328 0x60332c 0x603330 0x603334 0x603338 0x60333c 0x603340 0x603344 0x603348 0x60334c 0x603350 0x603354 0x603358 0x60335c 0x603360 0x603364 0x603368 0x60336c 0x603370 0x603374 0x603378 0x60337c 0x603380 0x603384 0x603388 0x60338c 0x603390 0x603394 0x603398 0x60339c 0x6033a0 0x6033a4 0x6033a8 0x6033ac 0x6033b0 0x6033b4 0x6033b8 0x6033bc 0x6033c0 0x6033c4 0x6033c8 0x6033cc 0x6033d0 0x6033d4 0x6033d8 0x6033dc 0x6033e0 0x6033e4 0x6033e8 0x6033ec 0x6033f0 0x6033f4 0x6033f8 0x6033fc 0x603400 0x603404 0x603408 0x60340c 0x603410 0x603414 0x603418 0x60341c 0x603420 0x603424 0x603428 0x60342c 0x603430 0x603434 0x603438 0x60343c 0x603440 0x603444 0x603448 0x60344c 0x603450 0x603454 0x603458 0x60345c 0x603460 0x603464 0x603468 0x60346c 0x603470 0x603474 0x603478 0x60347c 0x603480 0x603484 0x603488 0x60348c 0x603490 0x603494 0x603498 0x60349c 0x6034a0 0x6034a4 0x6034a8 0x6034ac 0x6034b0 0x6034b4 0x6034b8 0x6034bc 

0x603010: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 
0x603060: 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 
0x6030b0: 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 
0x603100: 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 
0x603150: 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 
0x6031a0: 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 
0x6031f0: 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 
0x603240: 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 
0x603290: 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 
0x6032e0: 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 
0x603330: 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 
0x603380: 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 
0x6033d0: 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 
0x603420: 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 
0x603470: 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299

ご覧のとおり、多次元配列はメモリ内で隣接しており、2つのメモリアドレスが重複していません。配列を解放するルーチンでさえ、単一の列（または配列の表示方法に応じて行）ごとに動的にメモリを割り当てる標準的な方法よりも簡単です。配列は基本的に2つの線形配列で構成されるため、これら2つだけを解放する必要があります（解放できます）。

この方法は、同じ概念で2次元以上に拡張できます。私はここではそれをしませんが、その背後にあるアイデアを思いついたら、それは簡単な作業です。

このコードが私と同じくらいあなたに役立つことを願っています。

この回答の目的は、他の人がまだカバーしていない新しいものを追加することではなく、@ Kevin Loneyの回答を拡張することです。

あなたは軽量宣言を使用することができます：

int *ary = new int[SizeX*SizeY]

アクセス構文は次のとおりです。

ary[i*SizeY+j]     // ary[i][j]

しかし、これはほとんどの人にとって扱いにくく、混乱を招く可能性があります。したがって、次のようにマクロを定義できます。

#define ary(i, j)   ary[(i)*SizeY + (j)]

これで、非常によく似た構文を使用して配列にアクセスできますary(i, j) // means ary[i][j]。これには、シンプルで美しいという利点があります。同時に、インデックスの代わりに式を使用する方が簡単で、混乱が少なくなります。

たとえば、ary [2 + 5] [3 + 8]にアクセスするary(2+5, 3+8)には、複雑な外観の代わりに書き込むことができary[(2+5)*SizeY + (3+8)]ます。つまり、かっこが節約され、読みやすくなります。

注意事項：

• 構文は非常に似ていますが、同じではありません。
• 配列を他の関数に渡す場合SizeYは、同じ名前で渡す必要があります（またはグローバル変数として宣言する必要があります）。

または、複数の関数で配列を使用する必要がある場合は、次のようにマクロ定義の別のパラメーターとしてSizeYを追加することもできます。

#define ary(i, j, SizeY)  ary[(i)*(SizeY)+(j)]

あなたはアイデアを得ます。もちろん、これは長くなりすぎて役に立ちませんが、+と*の混乱を防ぐことができます。

これは絶対にお勧めできません。ほとんどの経験豊富なユーザーにとっては悪い習慣として非難されますが、その優雅さのために共有することに抵抗できませんでした。

編集：
任意の数の配列で機能するポータブルソリューションが必要な場合は、次の構文を使用できます。

#define access(ar, i, j, SizeY) ar[(i)*(SizeY)+(j)]

次に、アクセス構文を使用して、任意のサイズで任意の配列を呼び出しに渡すことができます。

access(ary, i, j, SizeY)      // ary[i][j]

PS：私はこれらをテストしましたが、g ++ 14およびg ++ 11コンパイラで同じ構文が（左辺値と右辺値の両方として）機能します。

これを試してください：

int **ary = new int* [sizeY];
for (int i = 0; i < sizeY; i++)
    ary[i] = new int[sizeX];

ここでは、2つのオプションがあります。最初のものは、配列の配列またはポインターのポインターの概念を示しています。画像でわかるように、アドレスが連続しているため、2番目の方法を使用します。

#include <iostream>

using namespace std;


int main(){

    int **arr_01,**arr_02,i,j,rows=4,cols=5;

    //Implementation 1
    arr_01=new int*[rows];

    for(int i=0;i<rows;i++)
        arr_01[i]=new int[cols];

    for(i=0;i<rows;i++){
        for(j=0;j<cols;j++)
            cout << arr_01[i]+j << " " ;
        cout << endl;
    }


    for(int i=0;i<rows;i++)
        delete[] arr_01[i];
    delete[] arr_01;


    cout << endl;
    //Implementation 2
    arr_02=new int*[rows];
    arr_02[0]=new int[rows*cols];
    for(int i=1;i<rows;i++)
        arr_02[i]=arr_02[0]+cols*i;

    for(int i=0;i<rows;i++){
        for(int j=0;j<cols;j++)
            cout << arr_02[i]+j << " " ;
        cout << endl;
    }

    delete[] arr_02[0];
    delete[] arr_02;


    return 0;
}

プロジェクトがCLI（共通言語ランタイムサポート）の場合、次のようになります。

配列クラスを使用できますが、作成時に取得するものは使用できません。

#include <array>
using namespace std;

つまり、std名前空間を使用して配列ヘッダーを含めるときに取得する非管理対象配列クラスではなく、std名前空間と配列ヘッダーで定義された非管理対象配列クラスではなく、CLIの管理対象クラス配列です。

このクラスを使用すると、任意のランクの配列を作成できます。

以下のコードは、2行と3列、int型の新しい2次元配列を作成し、 "arr"という名前を付けます。

array<int, 2>^ arr = gcnew array<int, 2>(2, 3);

これで、配列内の要素にアクセスし、名前を付けて1つの角括弧のみを記述[]し、その中に行と列を追加して、コンマで区切ることができます,。

以下のコードは、上記の前のコードですでに作成した配列の2行1列の要素にアクセスします。

arr[0, 1]

この行のみを書き込むことは、そのセルの値を読み取ること、つまりこのセルの値を取得する=ことですが、等号を追加すると、そのセルに値を書き込むことになります。つまり、このセルに値を設定します。もちろん、+ =、-=、* =、および/ =演算子を数値にのみ使用することもできます（int、float、double、__ int16、__ int32、__ int64など）。

プロジェクトがCLIでない場合#include <array>、もちろんstd名前空間のアンマネージ配列クラスを使用できますが、問題はこの配列クラスがCLI配列とは異なることです。このタイプのアレイの作成は、^サインとgcnewキーワードを削除する必要があることを除いて、CLIと同じです。ただし、残念ながら、<>括弧内の2番目のintパラメーターは、配列のランクではなく長さ（つまりサイズ）を指定します。

この種類の配列でランクを指定する方法はありません。ランクはCLI配列の機能のみです。。

std配列は、c ++の通常の配列のように動作します。たとえばint*、ポインタを使用して定義した後：new int[size]、またはポインタを使用せずに定義しますint arr[size]。 fill、begin、end、sizeなどのように、通常の配列は何も提供しません。

ただし、標準配列は通常のC ++配列と同様に1次元配列です。しかし、通常のc ++を1次元配列から2次元配列にする方法について他の人たちが提案した解決策のおかげで、たとえばMehrdad Afshariの考えに従って、次のコードを書くことができます。

array<array<int, 3>, 2> array2d = array<array<int, 3>, 2>();

このコード行は、「ジャグ配列」を作成します。「ジャグ配列」は、その各セルが別の1次元配列を指す、またはポイントする1次元配列です。

1次元配列内のすべての1次元配列が長さ/サイズが等しい場合、array2d変数を実際の2次元配列として扱うことができます。さらに、特殊なメソッドを使用して行または列を扱うことができます。念のため、2D配列では、そのstd配列がサポートしています。

Kevin Loneyのソリューションを使用することもできます。

int *ary = new int[sizeX*sizeY];

// ary[i][j] is then rewritten as
ary[i*sizeY+j]

ただし、std配列を使用する場合、コードは異なるようにする必要があります。

array<int, sizeX*sizeY> ary = array<int, sizeX*sizeY>();
ary.at(i*sizeY+j);

そして、まだstd配列のユニークな機能を持っています。

[]かっこを使用してstd配列の要素に引き続きアクセスでき、at関数を呼び出す必要がないことに注意してください。また、std配列の要素の総数を計算して保持する新しいint変数を定義して割り当て、その値を使用する代わりに、その値を使用することもできます。sizeX*sizeY

独自の2次元配列ジェネリッククラスを定義し、2次元配列クラスのコンストラクターを定義して2つの整数を受け取り、新しい2次元配列の行と列の数を指定し、整数の2つのパラメーターを受け取るget関数を定義できます。 2次元配列の要素にアクセスしてその値を返し、3つのパラメーターを受け取る関数を設定します。最初の2つは2次元配列の行と列を指定する整数で、3番目のパラメーターは素子。そのタイプは、ジェネリッククラスで選択したタイプによって異なります。

あなたは使用して、すべてこれを実装することができるようになりますどちらか通常のC ++の配列（ポインタまたはなし）または 2のようなあるいは、他の人が提案していることのアイデアのSTDアレイと使用1を、そしてCLI配列のように使用して簡単にそれを作りますC＃で定義、割り当て、使用できる次元配列。

ポインタを使用して配列を定義することから始めます（1行目）：

int** a = new int* [x];     //x is the number of rows
for(int i = 0; i < x; i++)
    a[i] = new int[y];     //y is the number of columns

以下の例が役立つかもしれません、

int main(void)
{
    double **a2d = new double*[5]; 
    /* initializing Number of rows, in this case 5 rows) */
    for (int i = 0; i < 5; i++)
    {
        a2d[i] = new double[3]; /* initializing Number of columns, in this case 3 columns */
    }

    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            a2d[i][j] = 1; /* Assigning value 1 to all elements */
        }
    }

    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cout << a2d[i][j] << endl;  /* Printing all elements to verify all elements have been correctly assigned or not */
        }
    }

    for (int i = 0; i < 5; i++)
        delete[] a2d[i];

    delete[] a2d;


    return 0;
}

要素がメモリに順次割り当てられる整数の2D配列が必要な場合は、次のように宣言する必要があります。

int (*intPtr)[n] = new int[x][n]

ここで、xの代わりに任意の次元を記述できますが、nは2つの場所で同じでなければなりません。例

int (*intPtr)[8] = new int[75][8];
intPtr[5][5] = 6;
cout<<intPtr[0][45]<<endl;

印刷する必要があります6。

場合によっては、私にとって最適なソリューションを提供します。特に、[サイズ]がわかっている場合は、配列の1次元がわかります。たとえば、char [20]の配列のさまざまなサイズの配列が必要な場合など、charの配列に非常に役立ちます。

int  size = 1492;
char (*array)[20];

array = new char[size][20];
...
strcpy(array[5], "hola!");
...
delete [] array;

キーは、配列宣言の括弧です。

私はこれをエレガントではなく、FAST、EASY、WORKINGシステムで使用しました。システムが大きなサイズの配列を作成してパーツにアクセスできるようにする唯一の方法は、パーツを切り取らないことです。なぜ機能しないのかわかりません。

#define DIM 3
#define WORMS 50000 //gusanos

void halla_centros_V000(double CENW[][DIM])
{
    CENW[i][j]=...
    ...
}


int main()
{
    double *CENW_MEM=new double[WORMS*DIM];
    double (*CENW)[DIM];
    CENW=(double (*)[3]) &CENW_MEM[0];
    halla_centros_V000(CENW);
    delete[] CENW_MEM;
}

次の答えが提供されなかったかどうかはわかりませんが、2D配列の割り当てにローカル最適化を追加することにしました（たとえば、正方行列は1つの割り当てのみで実行されます）。 int** mat = new int*[n]; mat[0] = new int [n * n];

ただし、上記の割り当ての直線性のため、削除は次のようになります。 delete [] mat[0]; delete [] mat;

2D配列を動的に宣言する：

    #include<iostream>
    using namespace std;
    int main()
    {
        int x = 3, y = 3;

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

        for(int i = 0; i<y; i++)
        {
            ptr[i] = new int[y];
        }
        srand(time(0));

        for(int j = 0; j<x; j++)
        {
            for(int k = 0; k<y; k++)
            {
                int a = rand()%10;
                ptr[j][k] = a;
                cout<<ptr[j][k]<<" ";
            }
            cout<<endl;
        }
    }

上記のコードでは、ダブルポインターを取得して動的メモリを割り当て、列の値を指定しました。ここで割り当てられるメモリは列のみですが、行に対してはforループが必要で、すべての行に動的メモリを割り当てます。これで、2D配列と同じようにポインターを使用できます。上記の例では、2D配列（ポインター）に乱数を割り当てました。これはすべて、2D配列のDMAに関するものです。

動的配列を作成するときにこれを使用しています。クラスまたは構造体がある場合。そして、これはうまくいきます。例：

struct Sprite {
    int x;
};

int main () {
   int num = 50;
   Sprite **spritearray;//a pointer to a pointer to an object from the Sprite class
   spritearray = new Sprite *[num];
   for (int n = 0; n < num; n++) {
       spritearray[n] = new Sprite;
       spritearray->x = n * 3;
  }

   //delete from random position
    for (int n = 0; n < num; n++) {
        if (spritearray[n]->x < 0) {
      delete spritearray[n];
      spritearray[n] = NULL;
        }
    }

   //delete the array
    for (int n = 0; n < num; n++) {
      if (spritearray[n] != NULL){
         delete spritearray[n];
         spritearray[n] = NULL;
      }
    }
    delete []spritearray;
    spritearray = NULL;

   return 0;
  }