C/C++에 들쭉날쭉한 어레이가 있습니까?

C/C++에 들쭉날쭉한 어레이가 있습니까?

C나 C++에 들쭉날쭉한 배열 같은 것이 있습니까?

다음 내용을 컴파일할 때:

int jagged[][] = { {0,1}, {1,2,3} };

다음 오류가 발생합니다.

error: 다차원 배열로 'expected' 선언은 첫 번째 차원을 제외한 모든 차원에 대한 경계를 가져야 합니다.

CI에서는 포인터 배열을 사용합니다.

예를 들어 다음과 같습니다.

int *jagged[5];

jagged[0] = malloc(sizeof(int) * 10);
jagged[1] = malloc(sizeof(int) * 3);

등.

여러 가지 방법이 있습니다.다른 방법은 다음과 같습니다.

int jagged_row0[] = {0,1};
int jagged_row1[] = {1,2,3};
int *jagged[] = { jagged_row0, jagged_row1 };

초기화만 원한다면 다음과 같이 말할 수 있습니다.

int jagged[][3] = { {0,1}, {1,2,3} };

배열은 여전히 [2][3] 모양을 가질 것입니다.실제 들쭉날쭉한 배열을 원하는 경우 동적으로 작성해야 합니다.C++를 사용하고 있다면 A를 사용해야 합니다.std::vector, 경건한 대로

C++에서는 다음과 같이 구성됩니다.

std::vector<std::vector<int> > myArray;

myArray.push_back(std::vector<int>());
myArray.push_back(std::vector<int>());

myArray[0].push_back(0);
myArray[0].push_back(1);

myArray[1].push_back(1);
myArray[1].push_back(2);
myArray[1].push_back(3);

이제 myArray[0][0] 등으로 요소에 액세스할 수 있습니다.

C99에서는 다음을 수행할 수 있습니다.

int jagged_row0[] = {0,1};
int jagged_row1[] = {1,2,3};

int (*jagged[])[] = { &jagged_row0, &jagged_row1 }; // note the ampersand

// also since compound literals are lvalues ...
int (*jagged2[])[] = { &(int[]){0,1}, &(int[]){1,2,3} };  

여기서 (램피온의 답변과 비교할 때) 유일한 차이점은 어레이가 포인터로 붕괴되지 않고 다른 수준의 간접 지시를 통해 개별 어레이에 액세스해야 한다는 것입니다 (예:).*jagged[0]- 그리고 각 행의 크기를 기록해야 합니다. 즉.sizeof(*jagged[0])컴파일하지 않을 것입니다) - 하지만 뼛속까지 들쭉날쭉합니다 ;)

오류가 발생한 이유는 적어도 외부 차원에 대한 경계를 지정해야 하기 때문입니다.

int jagged[][3] = {{0,1},{1,2,3}};

jagged[0] int의 2-요소 배열과 jagged[1]의 3-요소 배열은 사용할 수 없습니다. N-요소 배열은 M-요소 배열과 다른 유형이며(여기서 N!= M) 배열의 모든 요소는 동일한 유형이어야 합니다.

다른 사람들이 위에서 제안한 것처럼 int에 대한 포인터 배열로 들쭉날쭉한 모양을 만드는 것입니다. 이렇게 하면 각 요소가 서로 다른 크기의 정수 배열을 가리킬 수 있습니다.

int row0[] = {0,1};
int row1[] = {1,2,3};
int *jagged[] = {row0, row1};

row0 및 row1이 서로 다른 유형(int의 2-element vs. 3-element arrays of int)임에도 불구하고 이니셜라이저의 컨텍스트에서는 둘 다 동일한 유형(int *)으로 암시적으로 변환됩니다.

C++11 이니셜라이저 목록을 사용하면 다음과 같이 더 간결하게 작성할 수 있습니다.

#include <vector>
#include <iostream>

int main() {
    // declare and initialize array
    std::vector<std::vector<int>> arr = {{1,2,3}, {4,5}};
    // print content of array
    for (auto row : arr) {
        for (auto col : row)
            std::cout << col << " ";
        std::cout << "\n";
    }
}

출력은 다음과 같습니다.

$ g++ test.cc -std=c++11 && ./a.out
1 2 3 
4 5 

참고용:

• http://en.cppreference.com/w/cpp/utility/initializer_list

c의 compound 리터럴을 사용하여 메모리에서 연속적으로 나타나는 진정한 들쭉날쭉한 배열을 다음과 같이 초기화할 수도 있습니다.

int (*arr[]) = { (int []) {0, 1}, (int []){ 2, 3, 4}, (int []){5, 6, 7, 8} }

이것은 기억 속에서 연속적으로 전개될 것입니다.

cpp에서 동적 할당을 사용함으로써 들쭉날쭉한 배열을 만들 수 있습니다.

예를 들어,

#include<iostream>
using namespace std;
    
int main(){
    int n;
    cout<<"Enter n:";
    cin>>n;
    
    cout<<"Enter elements:"; 
    int **p = new int *[n];
    
    for(int i=0;i<n;i++){
        p[i] = new int[i+1];
        for(int j=0;j<(i+1);j++){
            cin>>p[i][j];
        }
    } 
    
    cout<<"Jagged Array:"<<endl; 
    for(int i=0;i<n;i++){
        for(int j=0;j<(i+1);j++){
            cout<<p[i][j]<<" ";           
        }
        cout<<endl;
    }
    
    for(int i=0;i<n;i++){
        delete []p[i];
    }
    delete []p;
}
    

위해서n=3과 같은 . ,과 에서 을 을 에서 과

• 입력: 3

요소 입력:
1
1 2
1 2 3
들쭉날쭉한 배열:
1
1 2
1 2 3

//
//jaggedArrays.cpp
//
//program to implement jagged arrays in c++
//
#include<iostream>
#include<iomanip>
using namespace std;

int main()
{
    int rows, i, j;
    cout << endl << "Enter no of rows : ";
    cin >> rows;

    int columnsSizeOfEachRow[rows];

    cout << endl;
    for( i = 0 ; i < rows ; i++ )
    {
        cout << "Enter column size for row no " << i + 1 << " : ";
        cin >> columnsSizeOfEachRow[i];
    }
    
    int *jaggedArray[rows];
    for (i = 0 ; i < rows ; i++)
        jaggedArray[i] = new int[columnsSizeOfEachRow[i]];
    
    cout << endl;
    for(i = 0 ; i < rows ; i++)
    {
        for ( j = 0 ; j < columnsSizeOfEachRow[i] ;j++)
        {
            cout << "Array[" << i + 1 << "][" << j + 1 << "] << ";
            cin >> jaggedArray[i][j];
        }
        cout << endl;
    }

    cout << endl << endl << "Jagged array is as follows : " << endl;
    for( i = 0 ; i < rows ; i++)
    {
        for ( j = 0 ; j < columnsSizeOfEachRow[i] ;j++)
            cout << setw(3) <<jaggedArray[i][j] << " ";
        cout << endl;
    }    

    return 0;
}

c++/c에는 들쭉날쭉한 배열이 존재하지만 구문이 상당히 복잡하기 때문에 많은 것을 처리해야 합니다.

There are two types of jagged arrays in c++.
1) 정적 들쭉날쭉한 배열(A 2d array in which the size will be a constant number and there will be different number of columns in each row).
2) 동적 들쭉날쭉한 배열(A 2d array in which the size will be any number taken from user and there will be different number of columns in each row)

JAGGED )

배열 및 포인터 사용

• 1) 필요한 행 수와 함께 1-D 어레이 선언
• 2) 각 배열의 크기(행의 요소에 대한 배열)는 행의 열(또는 요소) 수가 됩니다.
• 3) 화살표의 주소를 저장할 1-D 포인터 배열을 선언합니다.
• 4) 1-D 배열의 크기는 들쭉날쭉한 배열에서 원하는 행의 개수입니다.

#include<iostream>
#include<string>
using namespace std;
int main()
{
    int row0[4] = { 1,2,3,4 };
    int row1[2] = { 5,6 };
    int* jagged[2] = { row0,row1 };
    int Size[2] = { 4,2 }, k = 0;
    for (int i = 0; i < 2; i++)
    {
        int* ptr = jagged[i];
        for (int j = 0; j < Size[k]; j++)
        {
            cout << *ptr << "";
            ptr++;
        }
        cout << endl;
        k++;
        jagged[i]++;
    }
    return 0;
}

출력은 다음과 같습니다.

---

1234
56

---

Jagged ) Jagged

포인터 배열 사용

• 1) 포인터 배열 선언(jagged array)
• 2) 이 배열의 크기는 들쭉날쭉한 배열에 필요한 행의 개수가 됩니다.
• 3) 배열의 각 포인터에 대해 이 행에 원하는 요소 수만큼 메모리를 할당합니다.

#include<iostream>
#include<string>
using namespace std;
int main()
{
    //2 rows
    int* jagged[2];

    //Allocate memeory for the elements in the row 0
    jagged[0] = new int[1];

    //Allocate memory for the elements in row 1
    jagged[1] = new int[5];

    //Array to hold the size of each row
    int Size[2] = { 1,5 },k = 0, number = 100;

    //User enters the numbers
    for (int i = 0; i < 2; i++)
    {
        int* p = jagged[i];

        for (int j = 0; j < Size[k]; j++)
        {
            *p = number++;

            //move the pointer
            p++;
        }
        k++;
    }
    k = 0;

    //Display elements in Jagged array
    for (int i = 0; i < 2; i++)
    {
        int* q = jagged[i];
        for (int j = 0; j < Size[k]; j++)
        {
            cout << *q << "";
            //move the pointer to the next element
            q++;
        }
        cout << endl;
        k++;
        //move the pointer to the next row
        jagged[i]++;
    }
    delete[] jagged[0];
    delete[] jagged[1];
    return 0;
}

The output is as follows

---

100
101102103104105

---

아니요, C나 C++에는 들쭉날쭉한 다차원 배열이 없습니다.일부 메모리 비용(예: 배열에 대한 포인터 배열)으로 유사한 기능을 수행하는 다양한 구성을 만들 수 있지만 실제 C 스타일 다차원 배열은 만들 수 없습니다.

그 이유는 C-스타일 어레이는 몇 차원이든 메타데이터가 없는 연속적인 메모리 영역을 차지하기 때문입니다.기억력 측면에서는 모두 단일차원입니다.추가 차원의 기능을 제공하는 것은 포인터 산술의 영리함(포인터를 행 크기로 배열하는 것)뿐입니다.직렬로 배치된 들쭉날쭉한 배열은 행 크기가 다르기 때문에 일정한 값으로 스트로드할 수 없어 데이터 크기에 따라 추가 저장이 필요하므로 C 타입 시스템에서는 표현이 불가능합니다.

포인터 다차원 배열 붕괴를 고려할 때 더 명확해집니다. 포인터 붕괴에 배열, 함수에 다차원 배열 전달

. 가 .must have bounds for all dimensions except the first한 모든 한 이 을 하는 하기 입니다 을 입니다 하기 하는 을 이 을

언급URL : https://stackoverflow.com/questions/1083658/do-jagged-arrays-exist-in-c-c