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;

편집 : Dietrich Epp가 의견에서 지적했듯이 이것은 정확히 가벼운 해결책이 아닙니다. 다른 방법은 하나의 큰 메모리 블록을 사용하는 것입니다.

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]

정적 배열 예제에서 들쭉날쭉 한 배열이 아닌 직사각형 배열을 원한다고 가정합니다. 다음을 사용할 수 있습니다.

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

그런 다음 다음과 같은 요소에 액세스 할 수 있습니다.

ary[y*sizeX + x]

에 delete []를 사용하는 것을 잊지 마십시오 ary.

C ++ 11 이상에서 권장하는 두 가지 일반적인 기술이 있습니다. 하나는 컴파일 시간 차원과 다른 하나입니다. 두 대답 모두 균일 한 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필요한 경우 C에서 첫 번째 선박 ++ (14) 그러나 당신이 11 ++ C에서 그것을 polyfill 수 있습니다.

이러한 유형의 구조 operator()에도 과부하가 발생하는 것이 일반적입니다 .

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

^{기술적으로 내가 사용하지 않은 new여기에,하지만에서 이동하는 사소한 std::unique_ptr<int[]>에 int *사용 된 new/ delete.}

이 질문은 나를 괴롭 혔습니다. 좋은 해결책이 이미 존재해야한다는 일반적인 문제입니다. 벡터 벡터보다 나은 것이거나 자신의 배열 색인을 롤링하는 것입니다.

C ++에 무언가 존재해야하지만 존재하지 않는 경우 가장 먼저 살펴볼 곳은 boost.org 입니다. 거기에 Boost Multidimensional Array Library가multi_array 있습니다. 또한 multi_array_ref1 차원 배열 버퍼를 랩핑하는 데 사용할 수 있는 클래스 도 포함합니다 .

왜 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 연산자 []에서 비롯된 것 같습니다. 대신 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 차원 이상으로 확장 될 수 있습니다. 여기서는하지 않겠지 만 그 아이디어를 이해하면 간단한 작업입니다.

이 코드가 도움이 되었으면 좋겠습니다.

이 답변의 목적은 다른 사람들이 아직 다루지 않은 새로운 것을 추가하는 것이 아니라 @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]

추신 : 나는 이것을 테스트했으며 g ++ 14 및 g ++ 11 컴파일러에서 동일한 구문이 작동합니다 (lvalue와 rvalue 모두).

이것을 시도하십시오 :

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

여기에는 두 가지 옵션이 있습니다. 첫 번째는 배열의 배열 또는 포인터의 포인터 개념을 보여줍니다. 이미지에서 볼 수 있듯이 주소가 인접하기 때문에 두 번째 주소를 선호합니다.

#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);

이제 배열의 요소에 이름으로 액세스하고 하나의 제곱 괄호 만 쓰고 []그 안에 행과 열을 추가하고 쉼표로 구분할 수 있습니다, .

아래 코드는 위의 이전 코드에서 이미 만든 배열의 두 번째 행과 첫 번째 열의 요소에 액세스합니다.

arr[0, 1]

이 줄만 쓰는 것은 해당 셀의 값을 읽는 것입니다. 즉,이 셀의 값을 가져옵니다. = 해당 셀의 값을 쓰려고합니다. 즉,이 셀의 값을 설정합니다. 물론 숫자 만 (int, float, double, __int16, __int32, __int64 등)에 + =,-=, * = 및 / = 연산자를 사용할 수 있지만 이미 알고 있어야합니다.

프로젝트가 CLI 가 아닌 경우 #include <array>물론 std 네임 스페이스의 관리되지 않는 배열 클래스를 사용할 수 있지만 문제는이 배열 클래스가 CLI 배열과 다르다는 것입니다. 이 유형의 배열 만들기는 ^기호와 gcnew키워드 를 제거해야한다는 점을 제외하고 CLI와 동일합니다 . 그러나 불행히도 두 번째 INT 매개 변수를 <>괄호는 지정 길이 (즉, 크기) 배열의, 하지 의 순위를!

이런 종류의 배열에서 순위를 지정할 수있는 방법은 없습니다. rank는 CLI 배열의 기능 일뿐입니다. .

std 배열은 c ++에서 일반 배열처럼 작동합니다. 예를 들어 포인터를 사용하여 정의 int*한 다음 new int[size]포인터를 사용하지 않고 정의 int arr[size]하십시오 .c ++의 일반 배열과 달리 std 배열은 배열의 요소와 함께 사용할 수있는 함수를 제공합니다. 채우기, 시작, 끝, 크기 등과 같지만 일반 배열은 아무것도 제공 하지 않습니다 .

그러나 여전히 표준 배열은 일반 C ++ 배열과 같은 1 차원 배열입니다. 그러나 다른 사람들이 일반적인 c ++ 1 차원 배열을 2 차원 배열로 만드는 방법에 대해 제안한 솔루션 덕분에 Mehrdad Afshari의 아이디어에 따라 동일한 아이디어를 표준 배열에 적용 할 수 있습니다. 예를 들어 다음 코드를 작성할 수 있습니다.

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

이 코드 줄은 "jugged array"를 생성하는데 , 이는 각 셀이 다른 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 차원 배열의 행과 열을 지정하는 정수이고 세 번째 매개 변수는 요소. 유형은 일반 클래스에서 선택한 유형에 따라 다릅니다.

당신은 사용하여 모든이를 구현 할 수있을 것 중 하나 정상적인 C ++ 배열 (포인터 또는없이) 또는 두 개의 같은 또는 다른 사람이 제안하는 아이디어의 표준 배열 사용을하고 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 은 두 위치에서 동일해야합니다. 예

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

6을 인쇄해야합니다.

어떤 경우에는 나에게 가장 적합한 솔루션을 남겨 두었습니다. 특히 배열의 크기를 [크기?]로 알고 있다면 예를 들어 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 배열 할당에 로컬 최적화를 추가하기로 결정했습니다 (예 : 정사각형 행렬은 하나의 할당만으로 수행됩니다). 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;
  }