왜 x [0]! = x [0] [0]! = x [0] [0] [0]입니까?

나는 약간의 C ++을 공부하고 있으며 포인터와 싸우고 있습니다. 다음과 같이 선언하면 3 단계의 포인터를 가질 수 있음을 이해합니다.

int *(*x)[5];

그래서 이것은 *x포인터 인 5 개 요소의 배열에 대한 포인터 int입니다. 또한 내가 알고 x[0] = *(x+0);, x[1] = *(x+1)등등 및 ....

위의 선언에서 왜 그렇 x[0] != x[0][0] != x[0][0][0]습니까?

x에 대한 5 개의 포인터 배열에 대한 포인터 int입니다.
x[0]에 대한 5 개의 포인터 배열 입니다 int.
x[0][0]에 대한 포인터 int입니다.
x[0][0][0]입니다 int.

                       x[0]
   Pointer to array  +------+                                 x[0][0][0]         
x -----------------> |      |         Pointer to int           +-------+
               0x500 | 0x100| x[0][0]---------------->   0x100 |  10   |
x is a pointer to    |      |                                  +-------+
an array of 5        +------+                        
pointers to int      |      |         Pointer to int                             
               0x504 | 0x222| x[0][1]---------------->   0x222                    
                     |      |                                             
                     +------+                                             
                     |      |         Pointer to int                              
               0x508 | 0x001| x[0][2]---------------->   0x001                    
                     |      |                                             
                     +------+                                             
                     |      |         Pointer to int                              
               0x50C | 0x123| x[0][3]---------------->   0x123                    
                     |      |                                             
                     +------+                                             
                     |      |         Pointer to int                              
               0x510 | 0x000| x[0][4]---------------->   0x000                    
                     |      |                                             
                     +------+                                             

당신은 그것을 볼 수 있습니다

• x[0]는 배열이며 표현식에서 사용될 때 첫 번째 요소에 대한 포인터로 변환됩니다 (일부 예외 제외). 따라서 x[0]첫 번째 요소의 주소 x[0][0]는 0x500입니다.
• x[0][0]의 주소가 포함되어 int있는이 0x100.
• x[0][0][0]의 int값을 포함합니다 10.

따라서 x[0]동일하다 &x[0][0]그러므로 및, &x[0][0] != x[0][0].
따라서 x[0] != x[0][0] != x[0][0][0].

x[0] != x[0][0] != x[0][0][0]

자신의 게시물에 따르면

*(x+0) != *(*(x+0)+0) != *(*(*(x+0)+0)+0)`  

이것은 단순화

*x != **x != ***x

왜 평등해야합니까?
첫 번째는 포인터의 주소입니다.
두 번째는 다른 포인터의 주소입니다.
그리고 세 번째는 int가치입니다.

다음은 포인터의 메모리 레이아웃입니다.

   +------------------+
x: | address of array |
   +------------------+
            |
            V
            +-----------+-----------+-----------+-----------+-----------+
            | pointer 0 | pointer 1 | pointer 2 | pointer 3 | pointer 4 |
            +-----------+-----------+-----------+-----------+-----------+
                  |
                  V
                  +--------------+
                  | some integer |
                  +--------------+

x[0]"어드레스 주소",
x[0][0]"포인터 0",
x[0][0][0]"일부 정수"를 나타냅니다.

나는 지금 분명해야한다고 생각한다. 왜 그들은 모두 다르다.

위의 내용은 기본적인 이해를 위해 충분히 가깝기 때문에 내가 쓴 방식으로 썼습니다. 그러나 헥스가 올바르게 지적했듯이 첫 번째 줄은 100 % 정확하지 않습니다. 자세한 내용은 다음과 같습니다.

C 언어의 정의에서 값 x[0]은 정수 포인터의 전체 배열입니다. 그러나 배열은 C에서 실제로 할 수없는 일입니다. 항상 주소 전체 또는 요소를 조작하고 전체 배열을 전체적으로 사용하지 마십시오.

1. 운영자 x[0]에게 전달할 수 있습니다 sizeof. 그러나 그것은 실제로 값을 사용하는 것이 아니며 결과는 유형에만 달려 있습니다.

2. 주소를 가져 와서 xtype의 "address of array" 값을 얻을 수 있습니다 int*(*)[5]. 다시 말해:&x[0] <=> &*(x + 0) <=> (x + 0) <=> x

3. 에서는 모든 다른 콘텍스트 의 값은 x[0]상기 어레이의 첫번째 엘리먼트에 대한 포인터로 붕괴된다. 즉, "address of array"값과 유형이있는 포인터입니다 int**. 효과는 x유형의 포인터로 캐스팅 한 것과 같습니다 int**.

경우 3의 배열 포인터 붕괴로 인해, x[0]궁극적으로 모든 사용은 포인터 배열의 시작을 가리키는 포인터를 생성합니다. 이 호출 printf("%p", x[0])은 "어드레스 주소"라고 표시된 메모리 셀의 내용을 인쇄합니다.

• x[0]가장 바깥 쪽 포인터 ( int에 대한 포인터의 크기 5의 배열에 대한 포인터) 를 역 참조하고 포인터 의 크기 5의 배열을 만듭니다 int.
• x[0][0]최 포인터 역 참조 와 포인터로 결과 인덱스 어레이 int;
• x[0][0][0] 모든 것을 역 참조하여 구체적인 가치를 창출합니다.

그건 그렇고, 이러한 종류의 선언이 의미하는 것에 혼란 스러우면 cdecl을 사용하십시오 .

단계 식으로 단계를 고려하자 x[0], x[0][0]하고 x[0][0][0].

x다음과 같이 정의됩니다

int *(*x)[5];

expression x[0]은 유형의 배열입니다 int *[5]. expression x[0]은 expression 과 동일 하다는 점을 고려하십시오 *x. 즉, 배열에 대한 포인터를 참조하여 배열 자체를 얻습니다. 선언처럼 y와 같이 표시하자

int * y[5];

표현식은와 x[0][0]동일하며 y[0]유형이 int *있습니다. 우리가 선언을했다 z와 같이 표시하자

int *z;

expression x[0][0][0]은 y[0][0]expression z[0]과 동등하며 expression 과 동등하며 type을 갖습니다 int.

그래서 우리는

x[0] 유형이있다 int *[5]

x[0][0] 유형이있다 int *

x[0][0][0] 유형이있다 int

따라서 그것들은 다른 유형의 객체와 다른 크기의 객체입니다.

예를 들어 실행

std::cout << sizeof( x[0] ) << std::endl;
std::cout << sizeof( x[0][0] ) << std::endl;
std::cout << sizeof( x[0][0][0] ) << std::endl;

가장 먼저 말해야 할 것은

x [0] = * (x + 0) = * x;

x [0] [0] = * (* (x + 0) +0) = ** x;

x [0] [0] [0] = * (* (* (x + 0) +0)) = *** x;

따라서 * x ≠ * * x ≠ * * * x

다음 그림에서 모든 것이 명확합니다.

  x[0][0][0]= 2000

  x[0][0]   = 1001

  x[0]      = 10

x [0] [0] [0] = 10 인 경우의 예일뿐입니다.

그리고 어드레스 X [0] [0] [0] 이다 1,001

해당 주소는 x [0] [0] = 1001에 저장됩니다.

x [0] [0]의 주소 는 2000입니다

그 주소는 x [0] = 2000에 저장됩니다

따라서 x [0] [0] [0] ≠ x [0] [0] ≠ x [0]

.

편집

프로그램 1 :

{
int ***x;
x=(int***)malloc(sizeof(int***));
*x=(int**)malloc(sizeof(int**));
**x=(int*)malloc(sizeof(int*));
***x=10;
printf("%d   %d   %d   %d\n",x,*x,**x,***x);
printf("%d   %d   %d   %d   %d",x[0][0][0],x[0][0],x[0],x,&x);
}

산출

142041096 142041112 142041128 10
10 142041128 142041112 142041096 -1076392836

프로그램 2 :

{
int x[1][1][1]={10};
printf("%d   %d   %d   %d \n ",x[0][0][0],x[0][0],x[0],&x);
}

산출

10   -1074058436   -1074058436   -1074058436 

실제 관점에서 배열을 볼 경우 다음과 같이 나타납니다.

x[0]상자로 가득한화물 컨테이너입니다.
x[0][0]화물 컨테이너 안에 신발 상자로 가득 찬 단일 상자입니다.
x[0][0][0]상자 안에,화물 컨테이너 안에있는 단일 신발 상자입니다.

화물 컨테이너의 유일한 상자에있는 유일한 신발 상자 였음에도 불구하고 여전히화물 컨테이너가 아닌 신발 상자입니다

C ++에는 다음과 같은 원칙이 있습니다. 변수 선언은 변수를 사용하는 방법을 정확하게 나타냅니다. 선언을 고려하십시오.

int *(*x)[5];

(더 명확하게) 다음과 같이 다시 작성할 수 있습니다.

int *((*x)[5]);

원칙으로 인해 다음과 같은 이점이 있습니다.

*((*x)[i]) is treated as an int value (i = 0..4)
→ (*x)[i] is treated as an int* pointer (i = 0..4)
→ *x is treated as an int** pointer
→ x is treated as an int*** pointer

따라서:

x[0] is an int** pointer
→ x[0][0] = (x[0]) [0] is an int* pointer
→ x[0][0][0] = (x[0][0]) [0] is an int value

차이를 알아낼 수 있습니다.

다른 유형을 값으로 비교하려고합니다.

주소를 가져 가면 예상보다 더 많은 것을 얻을 수 있습니다

선언에 차이가 있음을 명심하십시오.

 int y [5][5][5];

이후, 원하는 비교를 허용 것 y, y[0], y[0][0], y[0][0][0]서로 다른 값 및 유형하지만 같은 주소를 가질 것

int **x[5];

인접한 공간을 차지하지 않습니다.

x와 x [0]같은 주소를 가지고 있지만, x[0][0]및 x[0][0][0]다른 주소에서 각각

인 p포인터 : 당신이 역 참조를 적재하고 p[0][0]에 해당하는 *((*(p+0))+0).

C 참조 (&) 및 역 참조 (*) 표기법에서 :

p == &p[0] == &(&p[0])[0] == &(&(&p[0])[0])[0])

다음과 같습니다.

p == &*(p+0) == &*(&*(p+0))+0 == &*(&*(&*(p+0))+0)+0

& *를 리팩토링하고 제거하면됩니다.

p == p+0 == p+0+0 == p+0+0+0 == (((((p+0)+0)+0)+0)+0)

다른 대답은 정확하지만 그중 어느 것도 세 가지 모두가 같은 가치를 포함 할 수 없다는 생각을 강조하지 않으므로 어떤 방식 으로든 불완전합니다.

이것이 다른 답변에서 이해할 수없는 이유는 대부분의 상황에서 도움이되고 확실히 합리적이지만 모든 그림이 포인터 x자체를 가리키는 상황을 다루지 않기 때문 입니다.

이것은 구성하기가 쉽지만 이해하기가 다소 어렵습니다. 아래 프로그램에서 세 값을 모두 동일하게 만드는 방법을 살펴 보겠습니다.

참고 : 이 프로그램의 동작은 정의되지 않습니다,하지만 난 포인터가 무언가 흥미로운 데모로 순수 여기를 게시하도록하겠습니다 수 없지만, 안 .

#include <stdio.h>

int main () {
  int *(*x)[5];

  x = (int *(*)[5]) &x;

  printf("%p\n", x[0]);
  printf("%p\n", x[0][0]);
  printf("%p\n", x[0][0][0]);
}

C89 및 C99에서 경고없이 컴파일되며 출력은 다음과 같습니다.

$ ./ptrs
0xbfd9198c
0xbfd9198c
0xbfd9198c

흥미롭게도 세 값은 모두 동일합니다. 그러나 이것은 놀라운 일이 아닙니다! 먼저 프로그램을 분석해 봅시다.

x각 요소가 int에 대한 포인터 유형 인 5 개의 요소 배열에 대한 포인터로 선언 합니다. 이 선언은 런타임 스택에 4 바이트를 할당하거나 구현에 따라 4 바이트를 할당하므로 내 컴퓨터 포인터는 4 바이트이므로 x실제 메모리 위치를 나타냅니다. C 언어 군에서, 그 내용 x은 단지 쓰레기 일 뿐이며, 이전에 사용했던 장소에서 남은 것이므로, 그 x자체는 어느 곳도 가리 키지 않습니다. 분명히 할당 된 공간이 아닙니다.

따라서 자연스럽게 변수의 주소를 x가져다가 어딘가에 놓을 수 있습니다. 이것이 바로 우리가하는 일입니다. 그러나 계속해서 x 자체에 넣겠습니다. &x와 유형이 다르기 때문에 x캐스트를해야 경고가 표시되지 않습니다.

메모리 모델은 다음과 같습니다.

0xbfd9198c
+------------+
| 0xbfd9198c |
+------------+

따라서 주소의 4 바이트 메모리 블록 0xbfd9198c에는 16 진수 값에 해당하는 비트 패턴이 포함 0xbfd9198c됩니다. 충분히 간단합니다.

다음으로 세 가지 값을 인쇄합니다. 다른 답변은 각 표현이 무엇을 의미하는지 설명하므로 관계가 명확해야합니다.

값이 동일하지만 매우 낮은 수준에서만 비트 패턴이 동일하지만 각 식과 관련된 형식 데이터는 해석 된 값이 다르다는 것을 알 수 있습니다. 예를 들어, x[0][0][0]format string을 사용하여 인쇄 %d하면 큰 음수를 얻게되므로 실제로 "값"은 달라 지지만 비트 패턴은 동일합니다.

다이어그램에서 화살표는 다른 메모리 주소가 아닌 동일한 메모리 주소를 가리 킵니다. 그러나 정의되지 않은 동작으로 인해 예상되는 결과를 도출 할 수 있었지만 정의되지 않은 것입니다. 이것은 프로덕션 코드가 아니라 완벽을 기하기위한 데모입니다.

합리적인 상황에서 malloc5 int 포인터의 배열을 만들고 해당 배열에서 가리키는 int를 다시 만드는 데 사용합니다. malloc항상 고유 한 주소를 반환합니다 (메모리가 없으면 NULL 또는 0을 반환하지 않는 한). 이와 같은 자기 참조 포인터에 대해 걱정할 필요가 없습니다.

바라건대 그것은 당신이 찾고있는 완전한 대답입니다. 당신은 기대하지 말아야 x[0], x[0][0]그리고 x[0][0][0]동일하게하지만, 강제로 한 경우에는이 될 수 있습니다. 머릿속에 무언가가 있으면 알려주세요.

의 유형 int *(*x)[5]은 int* (*)[5]즉 int에 대한 5 개의 포인터 배열에 대한 포인터입니다.

• xint에 대한 5 개의 포인터로 구성된 첫 번째 배열의 주소입니다 (유형이있는 주소 int* (*)[5]).
• x[0]int에 대한 5 개 포인터의 첫 번째 배열 주소 (유형이 동일한 주소 int* [5]) (offset address x, 0*sizeof(int* [5])즉 index * size-of-type-being-pointed-to-dereference)
• x[0][0]배열의 int에 대한 첫 번째 포인터입니다 (유형이 동일한 주소 int*) (주소 x by 0*sizeof(int* [5])및 역 참조, 그리고 by 0*sizeof(int*)및 역 참조의 오프셋 주소 ).
• x[0][0][0]int에 대한 포인터가 가리키는 첫 번째 int입니다 (주소 x에 의해 오프셋 주소 x 0*sizeof(int* [5])및 역 참조 및 해당 주소로 0*sizeof(int*)dereference 및 오프셋 및 해당 주소로 dereference 및 오프셋 0*sizeof(int))

의 유형 int *(*y)[5][5][5]은 int* (*)[5][5][5]즉 int에 대한 5x5x5 포인터의 3d 배열에 대한 포인터입니다.

• x 유형이 int 인 5x5x5 포인터의 첫 번째 3d 배열 주소입니다. int*(*)[5][5][5]
• x[0]int에 대한 5x5x5 포인터의 첫 번째 3d 배열 주소 (offset address x by 0*sizeof(int* [5][5][5])및 dereference)
• x[0][0]int에 대한 5x5 포인터의 첫 번째 2D 배열의 주소입니다 (주소 x 0*sizeof(int* [5][5][5])를 오프셋하고 참조를 해제하여 주소를 오프셋 0*sizeof(int* [5][5]))
• x[0][0][0]int에 대한 5 개의 포인터로 구성된 첫 번째 배열의 주소입니다 (주소 x로 0*sizeof(int* [5][5][5])오프셋 및 주소를 역 참조 및 오프셋으로 주소로 0*sizeof(int* [5][5])오프셋 0*sizeof(int* [5])).
• x[0][0][0][0]배열의 int에 대한 첫 번째 포인터입니다 (주소 x 기준 오프셋 0*sizeof(int* [5][5][5])및 역 참조 및 해당 주소 기준 0*sizeof(int* [5][5])오프셋 및 해당 주소 기준 0*sizeof(int* [5])및 오프셋 기준 오프셋 0*sizeof(int*))
• x[0][0][0][0][0]int에 대한 포인터가 가리키는 첫 번째 int입니다 (오프셋 주소 x 기준 0*sizeof(int* [5][5][5])및 역 참조 및 해당 주소 기준으로 0*sizeof(int* [5][5])오프셋 및 해당 주소 기준으로 0*sizeof(int* [5])오프셋 및 해당 주소 기준으로 0*sizeof(int*)오프셋 및 해당 주소 기준 및 오프셋 기준으로 오프셋 0*sizeof(int))

배열 붕괴에 관해서 :

void function (int* x[5][5][5]){
  printf("%p",&x[0][0][0][0]); //get the address of the first int pointed to by the 3d array
}

이는 전달과 동일 int* x[][5][5]하거나 int* (*x)[5][5]그들에게 후자의 모든 부패를 즉. 이것이 x[6][0][0]함수에서 사용하기 위해 컴파일러 경고를 얻지 않지만 x[0][6][0]그 크기 정보가 보존되기 때문에 그렇게 할 것입니다

void function (int* (*x)[5][5][5]){
  printf("%p",&x[0][0][0][0][0]); //get the address of the first int pointed to by the 3d array
}

• x[0] int에 대한 5x5x5 포인터의 첫 번째 3d 배열 주소입니다.
• x[0][0] int에 대한 5x5 포인터의 첫 번째 2d 배열 주소입니다.
• x[0][0][0] int에 대한 5 개의 포인터로 구성된 첫 번째 배열의 주소입니다.
• x[0][0][0][0] 배열의 int에 대한 첫 번째 포인터입니다.
• x[0][0][0][0][0] int에 대한 포인터가 가리키는 첫 번째 int입니다.

마지막 예에서, *(*x)[0][0][0]대신에 의미 적으로 사용하는 것이 훨씬 더 명확 x[0][0][0][0][0]합니다. 첫 번째와 마지막 [0]은 유형 때문에 다차원 배열에 대한 인덱스가 아닌 포인터 역 참조로 해석되기 때문입니다. 그러나 (*x) == x[0]의미에 관계없이 동일 합니다. *****x포인터를 5 번 역 참조하는 것처럼 보일 수도 있지만 실제로는 정확히 유형으로 인해 오프셋, 역 참조, 역 참조, 배열에 대한 2 오프셋 및 역 참조와 동일하게 해석됩니다. 작업을 적용하고 있습니다.

본질적으로 귀하 [0]또는 *a *가 아닌 배열 유형에 대해서는 우선 순위가 우선하기 때문에 오프셋 및 역 참조입니다 *(a + 0).

당신 때 [0]또는 배열 유형은 다음가 다음 나무 등의 역 참조를의 오프셋 (- 그것은 나무 등 동작의 역 참조는 같은 주소를 산출하기 위해 컴파일러에 의해 해결됩니다).**

당신 [0]이나 *1 차원 배열 유형을 가진 유형은 오프셋이며 역 참조입니다

당신 [0]이나 **2 차원 배열 유형 인 경우 오프셋 만, 즉 오프셋과 dem 등원 역 참조입니다.

귀하 [0][0][0]또는 ***3d 배열 유형 인 경우 오프셋 + dem 등원 역 참조, 오프셋 + dem 등원 역 참조, 오프셋 + dem 등원 역 참조, 역 참조입니다. 진정한 역 참조는 어레이 유형이 완전히 제거 된 경우에만 발생합니다.

int* (*x)[1][2][3]형식 의 예는 순서대로 래핑되지 않습니다.

• x 유형이 있습니다 int* (*)[1][2][3]
• *x유형이 있음 int* [1][2][3](오프셋 0 + dem 등원 역 참조)
• **x유형이 있음 int* [2][3](오프셋 0 + dem 등원 역 참조)
• ***x유형이 있음 int* [3](오프셋 0 + dem 등원 역 참조)
• ****x유형이 있음 int*(오프셋 0 + 역 참조)
• *****x유형이 있음 int(오프셋 0 + 역 참조)