새로운 것을 사용하여 C ++로 2D 배열을 어떻게 선언합니까?

Question

새로운 것을 사용하여 2D 배열을 어떻게 선언합니까?

"정상적인"배열의 경우 :

int* ary = new int[Size]

하지만

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

a) 작동/컴파일이없고 b) 무엇을 달성하지 않습니다.

int ary[sizeY][sizeX] 

하다.

Answer 1

동적 2D 배열은 기본적으로 배열입니다 배열에 대한 포인터. 다음과 같은 루프를 사용하여 초기화 할 수 있습니다.

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

위의 colCount= 5 그리고 rowCount = 4, 다음을 생성합니다.

Answer 2

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]

Answer 3

하지만 이 인기있는 대답 원하는 인덱싱 구문을 제공하면 공간과 시간 모두 크고 느리게 비효율적입니다. 더 나은 방법이 있습니다.

그 대답이 크고 느린 이유

제안 된 솔루션은 동적 포인터 배열을 생성 한 다음 각 포인터를 고유 한 독립적 인 동적 배열로 초기화하는 것입니다. 그만큼 이점 이 접근법 중에는 익숙한 인덱싱 구문을 제공한다는 것이므로 위치 X, Y에서 행렬 값을 찾으려면 다음과 같이 말합니다.

int val = matrix[ x ][ y ];

매트릭스 [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는 당신에게 감사 할 것입니다.

Answer 4

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]

Answer 5

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

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

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

ary[y*sizeX + x]

Delete [] on을 사용하는 것을 잊지 마십시오 ary.

Answer 6

C ++ 11 이상에서 권장하는 두 가지 일반적인 기술이 있습니다. 두 답변 모두 균일 한 2 차원 배열 (들쭉날쭉 한 배열이 아님)을 원한다고 가정합니다.

시간 치수를 컴파일합니다

a 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://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에서 첫 번째 배송이지만 필요한 경우 C ++ 11으로 폴리 플릴을 할 수 있습니다.

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

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

^{기술적으로 나는 사용하지 않았습니다 new 여기,하지만 이동하는 것은 사소한 일입니다 std::unique_ptr<int[]> 에게 int * 그리고 사용 new/delete.}

Answer 7

이 질문은 저를 괴롭 혔습니다. 좋은 솔루션이 이미 존재 해야하는 것은 일반적인 문제입니다. 벡터의 벡터 또는 자체 배열 인덱싱보다 더 나은 것입니다.

C ++에 무언가가 존재해야하지만 그렇지 않은 경우 가장 먼저 볼 수있는 곳은 boost.org. 거기에서 나는 그것을 발견했다 다차원 배열 라이브러리 부스트, multi_array. 그것은 심지어 a를 포함합니다 multi_array_ref 자신의 1 차원 배열 버퍼를 감싸는 데 사용할 수있는 클래스.

Answer 8

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

원천: C/C ++에서 2, 3 (또는 다중) 치수 배열을 만드는 방법은 무엇입니까?

Answer 9

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;

Answer 10

GNU C ++에서 인접한 다차원 배열을 할당하는 방법은 무엇입니까? "표준"구문이 작동 할 수있는 GNU 확장 기능이 있습니다.

문제는 운영자에게서 나온 것 같습니다 []. 대신 운영자를 사용하는지 확인하십시오.

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

그리고 그게 전부입니다 : 당신은 C 호환 다차원 배열을 얻습니다 ...

Answer 11

typedef는 당신의 친구입니다

돌아가서 다른 많은 답변을 살펴본 후 다른 답변이 더 깊은 설명이 순서라는 것을 알았습니다. 요소 (또는 위의 모든).

우선,이 답변은 컴파일 시간에 배열의 차원을 알고 있다고 가정합니다. 당신이 그렇게한다면, 이것은 둘 다 줄 최선의 솔루션입니다. 최고의 성능 그리고 당신이 사용할 수 있습니다 표준 배열 구문 배열 요소에 액세스합니다.

이것이 최상의 성능을 제공하는 이유는 모든 배열을 연속 메모리 블록으로 할당하기 때문입니다. 즉, 페이지 누락이 적고 공간 지역이 더 좋을 가능성이 높습니다. 루프를 할당하면 다른 스레드 나 프로세스에 의해 배분 루프가 (여러 번) 중단 될 수 있거나 단순히 작고 빈 메모리 블록을 채우는 할당 자.

다른 이점은 간단한 선언 구문 및 표준 어레이 액세스 구문입니다.

새로운 사용 : C ++에서 :

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

Answer 12

이 문제는 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 개 이상의 차원에 대해 확장 될 수 있습니다. 나는 여기서하지 않을 것이지만, 당신이 그 뒤에 아이디어를 얻을 때, 그것은 간단한 일입니다.

이 코드가 저를 도와주는만큼 도움이되기를 바랍니다.

Answer 13

이것을 시도하십시오 :

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

Answer 14

이 답변의 목적은 다른 사람들이 아직 다루지 않는 새로운 것을 추가하는 것이 아니라 @Kevin Loney의 답변을 확장하는 것입니다.

가벼운 선언을 사용할 수 있습니다.

int *ary = new int[SizeX*SizeY]

Access Syntax는 다음과 같습니다.

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 동일한 이름으로 전달되어야합니다 (또는 대신 글로벌 변수로 선언).

또는 여러 기능으로 배열을 사용해야하는 경우 Macro 정의에서 Sizy를 다른 매개 변수로 추가 할 수 있습니다.

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

당신은 아이디어를 얻습니다. 물론 이것은 너무 길어서 유용하기에는 너무 길지만 여전히 +와 *의 혼란을 막을 수 있습니다.

이것은 확실히 권장되지 않으며, 대부분의 숙련 된 사용자가 나쁜 연습으로 비난받을 것이지만, 우아함 때문에 공유에 저항 할 수 없었습니다.

추신 : 이것을 테스트했으며 G ++ 14 및 G ++ 11 컴파일러에서 동일한 구문이 작동합니다 (LValue 및 RValue).

Answer 15

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

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

Answer 16

프로젝트가 CLI 인 경우 (공통 언어 런타임 지원), 그 다음에:

당신은 당신이 쓸 때 얻는 배열 클래스를 사용할 수 있습니다.

#include <array>
using namespace std;

다시 말해, STD 네임 스페이스를 사용할 때 및 배열 헤더를 포함시킬 때 관리되지 않는 배열 클래스가 아니라 STD 네임 스페이스 및 어레이 헤더에 정의 된 관리되지 않은 배열 클래스가 아니라 CLI의 관리 된 클래스 어레이에 포함됩니다.

이 클래스를 사용하면 배열을 만들 수 있습니다. 계급 당신은 원합니다.

아래의 다음 코드는 2 행과 3 개의 열 및 유형 int의 새로운 2 차원 배열을 만듭니다.

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

이제 배열에서 요소에 액세스 할 수 있습니다. 단 하나 제곱 괄호 [], 그리고 그 안에는 행과 열을 추가하고 쉼표로 분리합니다. ,.

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

arr[0, 1]

이 줄만 쓰는 것이 해당 셀의 값을 읽는 것입니다. 즉,이 셀의 값을 얻는다. = 사인, 당신은 그 셀에 값을 쓰려고합니다. 즉,이 셀의 값을 설정하십시오. 또한 숫자 만 (int, float, double, __int16, __int32, __int64 등)에 대해 +=, -=, *= 및 /= 연산자를 사용할 수 있지만 이미 알고 있습니다.

프로젝트 인 경우 ~ 아니다 CLI, 그러면 관리되지 않는 배열 클래스의 STD 네임 스페이스를 사용할 수 있습니다. #include <array>, 물론, 그러나 문제는이 배열 클래스가 CLI 배열과 다르다는 것입니다. 이 유형의 배열 생성은 CLI와 동일하지만 ^ 사인과 gcnew 예어. 그러나 불행히도 두 번째 int 매개 변수 <> 괄호는 다음을 지정합니다 길이 (예 : 크기) 배열의 ~ 아니다 그 순위!

이러한 종류의 배열에서 순위를 지정할 방법이없고, 순위는 CLI 배열의 기능입니다. 뿐..

STD 배열은 C ++의 일반 배열처럼 행동하며, 예를 들어 포인터로 정의합니다. int* 그리고: new int[size], 또는 포인터없이 : int arr[size], 그러나 C ++의 일반 배열과 달리 STD 배열은 채우기, 시작, 끝, 크기 등과 같은 배열의 요소와 함께 사용할 수있는 기능을 제공하지만 일반 어레이는 제공합니다. 아무것도 아님.

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

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 개의 정수를 수신하고 정수의 두 매개 변수를 수신하는 GET 기능을 정의 할 수 있습니다. 2 차원 배열의 요소에 액세스하고 값을 반환하고 3 개의 매개 변수를 수신하는 함수를 설정합니다. 두 번째 첫 번째는 2 차원 배열에 행과 열을 지정하는 정수이며 세 번째 매개 변수는 다음의 새 값입니다. 요소. 유형은 일반 클래스에서 선택한 유형에 따라 다릅니다.

사용 하여이 모든 것을 구현할 수 있습니다. 어느 하나 일반 C ++ 배열 (포인터 또는없는) 또는 STD 배열 및 다른 사람들이 제안한 아이디어 중 하나를 사용하고 CLI 배열처럼 사용하기 쉽거나 C#에서 정의, 지정 및 사용할 수있는 2 차원 배열처럼 쉽게 사용할 수 있습니다.

Answer 17

포인터 (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

Answer 18

어떤 경우에는 저에게 가장 적합한 솔루션을 남겼습니다. 특히 배열의 한 차원의 [크기]를 알고 있다면. 예를 들어 숯의 배열이 필요하다면 숯의 배열에 매우 유용합니다 [20].

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

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

열쇠는 배열 선언의 괄호입니다.

Answer 19

나는 이것을 우아하지는 않지만 빠르고 쉽고 작업하는 시스템을 사용했습니다. 시스템이 큰 크기 어레이를 만들 수있는 유일한 방법과 액세스 부품을 만들 수있는 유일한 방법은 부품으로 자르지 않기 때문에 왜 작동 할 수 없는지 알지 못합니다.

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

Answer 20

아래 예제는 도움이 될 수 있습니다.

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;
}

Answer 21

동적으로 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;
        }
    }

이제 위의 코드에서 우리는 이중 포인터를 가져 와서 동적 메모리를 할당하고 열의 값을 주었다. 여기서 할당 된 메모리는 열에 대해서만 가능합니다. 이제 행의 경우 우리는 단지 루프 용 A가 필요하고 모든 행에 동적 메모리를 할당합니다. 이제 2D 배열을 사용하는 방식 만 포인터를 사용할 수 있습니다. 위의 예에서는 2D 배열 (포인터)에 임의 숫자를 할당했습니다.

Answer 22

동적 배열을 만들 때 이것을 사용하고 있습니다. 수업이나 구조물이있는 경우. 그리고 이것은 작동합니다. 예시:

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;
  } 

Answer 23

이것은 많은 세부 사항이 아니라 상당히 단순화되었습니다.

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;

배열이 완료 될 때 배열과 관련된 메모리를 처리합니다.