C++ で new を使用して 2 次元配列を宣言するにはどうすればよいですか?
https://stackoverflow.com/questions/936687
-
06-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian質問
new を使用して 2 次元配列を宣言するにはどうすればよいですか?
たとえば、「通常の」配列の場合は次のようにします。
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) アルゴリズムを実行します。そして、アロケーターは、ブックキーピングとアライメントのために、各行配列に追加のバイトを「埋め込み」ます。その余分なスペースには...そうですね...余分なスペースがかかります。割り当て解除者は、 また 行列の割り当てを解除するときは、余分な時間をかけて、個々の行の割り当てを丹念に解放してください。考えただけで汗が出てきます。
遅いのには別の理由があります。これらの個別の割り当ては、メモリの不連続部分に存在する傾向があります。ある行はアドレス 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]
私はあなたが長方形の配列ではなく、ギザギザの1をしたいというあなたの静的配列の例から推測します。あなたは以下を使用することができます：
int *ary = new int[sizeX * sizeY];
そして、あなたがなどの要素にアクセスすることができます：
ary[y*sizeX + x]
aryに[] deleteを使用することを忘れないでください。
私はこのためで推薦する二つの一般的な手法C ++ 11以上、コンパイル時の寸法用と、実行時に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次元配列を達成するための最良の方法は、クラスにそれをラップすることです。クラスは、1Dアレイを割り当て、その後、最初の次元の索引付けを提供するoperator []をオーバーロードします。
C ++での2Dアレイは行優先であるので、これは動作します。
の
（のhttpから撮影：//イーライ.thegreenplace.net / 2015 /メモリレイアウトのマルチ次元アレイ/ の）
メモリの連続した配列は、パフォーマンス上の理由のために良好であり、また、クリーンアップするのは簡単です。ここで有用な方法の多くを省略しますが、基本的な考え方を示した例のクラスがあります：
#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 *を返します。 C ++ 14のものmake_unique最初の船に注意しますが、必要な場合は、C ++ 11のそれをポリフィルすることができます。
それだけでなくoperator()をオーバーロードするための構造のこれらのタイプにも共通です。
int &operator()(size_t row, size_t column) {
return data[row * _columns + column];
}
技術的に私はここnewを使用していないが、それはstd::unique_ptr<int[]> / int *をnewして使用するdeleteから移動するために些細なのです。
この質問は私を悩ませていました。これは十分に一般的な問題なので、ベクトルのベクトルや独自の配列インデックスのローリングよりも優れた解決策がすでに存在しているはずです。
何かが C++ に存在するはずなのに存在しない場合、最初に探すべき場所は次のとおりです。 ブースト.org. 。そこで見つけたのが、 ブースト多次元配列ライブラリ、 multi_array. 。さらに、 multi_array_ref 独自の 1 次元配列バッファをラップするために使用できるクラス。
なぜSTLを使用していませんか？だから、簡単に、そしてあなたがベクトルを削除する必要はありません。
int rows = 100;
int cols = 200;
vector< vector<int> > f(rows, vector<int>(cols));
f[rows - 1][cols - 1] = 0; // use it like arrays
の2次元アレイは、基本的にすべてのポインタは、実際のデータを保持する1次元アレイを指しているポインタの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つの線形アレイで構成されているので、これらのみ両者はでなければならない（ことができる）解放されます。
この方法は、同じ概念でつ以上の次元に拡張することができます。私はここでそれを行うことはありませんが、あなたがその背後にアイデアを得るとき、それは簡単な作業です。
私はそれが私を助けたとして、このコードは、あなたのように多くのを助けることを願っています。
これをやってみます：
int **ary = new int[sizeY];
for (int i = 0; i < sizeY; i++)
ary[i] = new int[sizeX];
この回答の目的は、他の人がまだカバーしていない新しいものを追加することではなく、@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)]
わかりますね。もちろん、これは長すぎて役に立ちませんが、それでも + と * の混同を防ぐことができます。
これは明確に推奨されるものではなく、ほとんどの経験豊富なユーザーから悪い習慣として非難されるでしょう。しかし、その優雅さのため、私はこれを共有せずにはいられませんでした。
追記：これをテストしたところ、同じ構文が g++14 および g++11 コンパイラーで (左辺値と右辺値の両方として) 機能しました。
ここで、私は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);
これで、名前を指定して配列内の要素にアクセスし、次のように書き込むことができます。 唯一 角括弧 [], 、その中に行と列を追加し、カンマで区切ります。 ,.
以下のコードは、上記のコードですでに作成した配列の 2 行目、1 列目の要素にアクセスします。
arr[0, 1]
この行のみを書くことは、そのセルの値を読み取ることになります。このセルの値を取得しますが、等しい値を追加すると、 = 記号の場合、そのセルに値を書き込もうとしています。つまり、このセルに値を設定します。もちろん、+=、-=、*=、/= 演算子も数値 (int、float、double、__int16、__int32、__int64 など) に対してのみ使用できますが、それはすでにご存知でしょう。
あなたのプロジェクトが ない CLI の場合、次の場合は std 名前空間のアンマネージ配列クラスを使用できます。 #include <array>, もちろんですが、問題は、この配列クラスが CLI 配列とは異なることです。このタイプの配列の作成は CLI と同じですが、 ^ サインと gcnew キーワード。しかし、残念なことに、 <> 括弧は、 長さ（すなわち、サイズ） 配列の、 ない そのランク！
この種の配列ではランクを指定する方法はありません。ランクは CLI 配列の機能です のみ。.
std 配列は、C++ の通常の配列のように動作します。たとえば、ポインターを使用して定義します。 int* その後： new int[size], 、またはポインターなし: int arr[size], ただし、C++ の通常の配列とは異なり、std 配列には、fill、begin、end、size などの配列の要素で使用できる関数が用意されていますが、通常の配列では次のような関数が提供されます。 何もない.
ただし、std 配列は通常の C++ 配列と同様に 1 次元配列です。しかし、通常の C++ 1 次元配列を 2 次元配列に変更する方法について他の人が提案した解決策のおかげで、同じアイデアを std 配列に適用することができます。Mehrdad Afshari のアイデアによれば、次のコードを書くことができます。
array<array<int, 3>, 2> array2d = array<array<int, 3>, 2>();
このコード行により、 「ギザギザ配列」, これは、その各セルが別の 1 次元配列であるか、別の 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 次元配列内の要素にアクセスしてその値を返す set 関数。最初の 2 つは 2 次元配列の行と列を指定する整数で、3 番目のパラメータは の新しい値です。要素。その型は、ジェネリック クラスで選択した型によって異なります。
これをすべて実装するには、次を使用します。 どちらか 通常の C++ 配列 (ポインターの有無にかかわらず) または std 配列を使用し、他の人が提案したアイデアの 1 つを使用して、cli 配列のように、または C# で定義、割り当て、使用できる 2 次元配列のように使いやすくします。
ポインタ（ライン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
私は特定のケースでは、私にとって最高の作品ソリューションをご残っています。 1は、[サイズ？]配列の1次元を知っている場合は特に。例えば、我々は文字の配列の大きさを変化させるのアレイが必要な場合は、文字の配列のために非常に有用である[20]。
int size = 1492;
char (*array)[20];
array = new char[size][20];
...
strcpy(array[5], "hola!");
...
delete [] array;
キーが配列宣言の括弧である。
私はこれではないエレガントなく、FAST、EASYと作業システムを使用していました。働くことができない理由は、大きなサイズの配列とアクセス部品を作成できるようにするシステムのための唯一の方法は部品でそれを切断することなくあるので、私は表示されません。
#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;
}
の例では、役立つかもしれないの下には、
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;
}
動的2次元配列を宣言
#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;
}
}
さて、上記のコードでは、私たちは二重のポインタを取り、それを動的メモリを割り当てられ、列の値を与えました。ここで割り当てられたメモリがある列だけのために、今の行のために私達はちょうどループのために必要な、すべての行の動的メモリの値を割り当てます。今、私たちは私たちが使用するだけの方法2次元配列のポインタを使用することができます。上記の例では、私達の2次元アレイ（ポインタ）は、すべての2次元アレイのDMAについて.Itsに乱数を割り当てられます。
私はこれを使用しています。あなたは、クラスまたは構造体を持っている場合。そして、これは動作します。例：
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;
}
これはそれほど詳細なものではありませんが、非常に簡略化したものです。
int *arrayPointer = new int[4][5][6]; // ** LEGAL**
int *arrayPointer = new int[m][5][6]; // ** LEGAL** m will be calculated at run time
int *arrayPointer = new int[3][5][]; // ** ILLEGAL **, No index can be empty
int *arrayPointer = new int[][5][6]; // ** ILLEGAL **, No index can be empty
覚えて：
1.最初のインデックスのみが実行時変数になれます。他のインデックスは一定である必要があります
2.インデックスを空のままにすることはできません。
他の回答で述べたように、電話してください
delete arrayPointer;
配列の使用が完了したら、配列に関連付けられたメモリの割り当てを解除します。
