Joel 이 C 프로그래밍 언어 (일명 : K & R)의 스택 오버플로 팟 캐스트 # 34 에서 지적한 바와 같이 C 에 배열의이 속성에 대한 언급이 있습니다.a[5] == 5[a]

Joel은 포인터 산술로 인한 것이지만 여전히 이해하지 못한다고 말합니다. 왜 그렇a[5] == 5[a] 습니까?

C 표준은 []연산자를 다음과 같이 정의합니다 .

a[b] == *(a + b)

따라서 다음과 같이 a[5]평가됩니다.

*(a + 5)

다음으로 5[a]평가됩니다.

*(5 + a)

a배열의 첫 번째 요소에 대한 포인터입니다. a[5](5 개)의 값입니다 요소 에서 추가 a와 같은 인 *(a + 5), 초등학교 수학에서 우리가 그가 (또한이 동일 알고는 교환 법칙이 성립 ).

배열 액세스는 포인터 측면에서 정의되기 때문입니다. a[i]는 의미있는 것으로 정의되며 *(a + i), 이는 정류 적입니다.

다른 답변에서 무언가를 놓치고 있다고 생각합니다.

그렇습니다. p[i]정의는이며 *(p+i), 덧셈은 덧셈이되므로 *(i+p)이며, []연산자 의 정의에 따라 동일합니다 i[p].

(에서 array[i]배열 이름은 암시 적으로 배열의 첫 번째 요소에 대한 포인터로 변환됩니다.)

그러나 더하기의 commutativity가이 경우에 명백한 것은 아닙니다.

두 피연산자가 같은 유형이거나 공통 유형으로 승격 된 다른 숫자 유형 인 경우, commutativity는 다음과 같이 완벽하게 이해 x + y == y + x됩니다.

그러나이 경우 포인터 연산에 대해 구체적으로 이야기하고 있습니다. 한 피연산자는 포인터이고 다른 피연산자는 정수입니다. (정수 + 정수는 다른 연산이며 포인터 + 포인터는 의미가 없습니다.)

C 표준의 +연산자 ( N1570 6.5.6)에 대한 설명 은 다음과 같습니다.

또한 두 피연산자 모두 산술 유형을 갖거나 한 피연산자는 완전한 객체 유형에 대한 포인터이고 다른 피연산자는 정수 유형이어야합니다.

그것은 쉽게 말할 수 있습니다 :

또한 두 피연산자 모두 산술 유형을 가지거나 왼쪽 피연산자는 완전한 객체 유형에 대한 포인터이고 오른쪽 피연산자 는 정수 유형이어야합니다.

이 경우 모두 i + p와 i[p]불법이 될 것입니다.

C ++ 용어로, 우리는 실제로 +다음과 같이 느슨하게 설명 될 수있는 두 세트의 오버로드 연산자를 가지고 있습니다.

pointer operator+(pointer p, integer i);

과

pointer operator+(integer i, pointer p);

그중 첫 번째 만이 실제로 필요합니다.

왜 이런 식입니까?

C ++은 B (배열 인덱스의 교환 법칙이 명시 1972에서 설명한에서있어 C에서이 정의 유전 B에 대한 사용자의 참조 에서있어) BCPL 아니라 짝수로를 받고있다 (수동 일자 1967), 이전 언어 (CPL? Algol?).

따라서 배열 인덱싱은 덧셈의 관점에서 정의되고, 포인터와 정수의 덧셈도 계산적이며 수십 년 전 C의 조상 언어로 거슬러 올라갑니다.

이 언어들은 현대 C보다 훨씬 덜 타이핑되었습니다. 특히, 포인터와 정수의 구별은 종종 무시되었습니다. (초기 C 프로그래머들은 unsigned키워드를 언어에 추가 하기 전에 포인터를 부호없는 정수로 사용하기도했습니다 .) 따라서 피연산자가 다른 유형이기 때문에 비정규 식을 추가하는 아이디어는 해당 언어의 디자이너에게는 발생하지 않았을 것입니다. 사용자가 정수, 포인터 또는 그 밖의 다른 것을 포함하여 두 개의 "사물"을 추가하고자한다면 언어에 의존하지 않았습니다.

그리고 수년에 걸쳐이 규칙을 변경하면 기존 코드가 손상되었을 수 있습니다 (1989 ANSI C 표준이 좋은 기회 였을 수도 있음).

포인터를 왼쪽에 놓고 정수를 오른쪽에 놓도록 C 및 / 또는 C ++를 변경하면 일부 기존 코드가 손상 될 수 있지만 실제 표현력이 손실되지는 않습니다.

그래서 지금 우리가 arr[3]하고 3[arr]후자의 형태가 바깥에 표시해서는 안하지만, 정확히 같은 일을 의미 IOCCC .

그리고 물론

 ("ABCD"[2] == 2["ABCD"]) && (2["ABCD"] == 'C') && ("ABCD"[2] == 'C')

이것의 주된 이유는 C가 설계되었을 때 70 년대에 컴퓨터에 많은 메모리가 없었기 때문에 (64KB는 많았으므로) C 컴파일러는 구문 검사를 많이하지 않았기 때문입니다. 따라서 " X[Y]"은 (는) " *(X+Y)"

" +="및 " ++"구문 도 설명합니다 . " A = B + C" 형식의 모든 항목 은 동일한 컴파일 된 형식을가집니다. 그러나 B가 A와 동일한 객체 인 경우 어셈블리 수준 최적화를 사용할 수 있습니다. 그러나 컴파일러는 그것을 인식하기에 충분히 밝지 않았으므로 개발자는 ( A += C)해야했습니다. 마찬가지로 Cwas 1인 경우 다른 어셈블리 수준 최적화를 사용할 수 있었으며 컴파일러는이를 인식하지 못했기 때문에 개발자가 명시 적으로 만들어야했습니다. (더 최근에는 컴파일러가 사용하므로 요즘 구문은 거의 필요하지 않습니다)

Dinah의 문제에 대해 아무도 언급하지 않은 것 sizeof:

포인터에는 정수만 추가 할 수 있으며 두 개의 포인터를 함께 추가 할 수는 없습니다. 이렇게하면 정수에 포인터를, 포인터에 정수를 추가 할 때 컴파일러는 크기를 고려해야하는 비트를 항상 알고 있습니다.

말 그대로 질문에 대답하십시오. 항상 그런 것은 아닙니다x == x

double zero = 0.0;
double a[] = { 0,0,0,0,0, zero/zero}; // NaN
cout << (a[5] == 5[a] ? "true" : "false") << endl;

인쇄물

false

이 추악한 구문이 "유용"하거나 같은 배열의 위치를 ​​참조하는 인덱스 배열을 다루고 싶을 때 아주 재미있을 수 있습니다. 중첩 된 대괄호를 대체하고 코드를 더 읽기 쉽게 만들 수 있습니다!

int a[] = { 2 , 3 , 3 , 2 , 4 };
int s = sizeof a / sizeof *a;  //  s == 5

for(int i = 0 ; i < s ; ++i) {  

           cout << a[a[a[i]]] << endl;
           // ... is equivalent to ... 
           cout << i[a][a][a] << endl;  // but I prefer this one, it's easier to increase the level of indirection (without loop)

}

물론 실제 코드에는 유스 케이스가 없다고 확신하지만 어쨌든 흥미 롭습니다. :)

좋은 질문 / 답변.

C 포인터와 배열이 동일 하지 않다는 점을 지적하고 싶지만 ,이 경우 차이점은 필수는 아닙니다.

다음 선언을 고려하십시오.

int a[10];
int* p = a;

이어 a.out, 심볼은 a배열의 선두의 어드레스로하고, 심볼 p포인터가 저장되는 주소이고, 그 메모리 위치에 대한 포인터의 값은 상기 어레이의 시작이다.

C의 포인터에 대해서는

a[5] == *(a + 5)

그리고 또한

5[a] == *(5 + a)

따라서 사실이다 a[5] == 5[a].

답이 아니라 생각을위한 음식입니다. 클래스에 오버로드 된 인덱스 / 첨자 연산자가 있으면 표현식 0[x]이 작동하지 않습니다.

class Sub
{
public:
    int operator [](size_t nIndex)
    {
        return 0;
    }   
};

int main()
{
    Sub s;
    s[0];
    0[s]; // ERROR 
}

우리는 int 클래스에 액세스 할 수 없으므로이 작업을 수행 할 수 없습니다 :

class int
{
   int operator[](const Sub&);
};

C의 포인터와 배열에 대한 설명이 아주 훌륭합니다. 테드 젠슨 (Ted Jensen)의 있습니다.

테드 젠슨은 다음과 같이 설명했다.

실제로 이것은 사실입니다. a[i]*(a + i) 문제없이 대체 할 수 있습니다 . 실제로 컴파일러는 두 경우 모두 동일한 코드를 만듭니다. 따라서 포인터 산술은 배열 인덱싱과 동일합니다. 어느 구문이든 동일한 결과를 생성합니다.

이것은 포인터와 배열이 같은 것이 아니라고 말하는 것이 아닙니다. 우리는 배열의 주어진 요소를 식별하기 위해 두 가지 구문 중 하나를 선택할 수 있는데, 하나는 배열 인덱싱을 사용하고 다른 하나는 포인터 산술을 사용하여 동일한 결과를 산출합니다.

이제이 마지막 표현식을 살펴보면, 그 일부가 .. (a + i)+ 연산자와 C 표현식의 규칙을 사용하여 이러한 표현식이 정식이라는 간단한 추가입니다. 즉 (a + i)는와 같습니다 (i + a). 따라서 우리는 *(i + a)처럼 쉽게 쓸 수 있습니다 *(a + i). 그러나 *(i + a)올 수 있었다 i[a]! 이 모든 것에서 다음과 같은 호기심이 생깁니다.

char a[20];

쓰기

a[3] = 'x';

글쓰기와 동일

3[a] = 'x';

나는 그 질문에 대한 답을 알고 있지만이 설명을 공유하는 것을 거부 할 수 없었다.

컴파일러 디자인의 원리를 기억 a합니다. int배열이고 크기 int가 2 바이트이고 기본 주소 a가 1000이라고 가정합니다.

어떻게 a[5]작동합니다 ->

Base Address of your Array a + (5*size of(data type for array a))
i.e. 1000 + (5*2) = 1010

그래서,

마찬가지로 C 코드가 3 주소 코드로 분류 5[a]되면->

Base Address of your Array a + (size of(data type for array a)*5)
i.e. 1000 + (2*5) = 1010 

따라서 기본적으로 두 명령문 모두 메모리에서 동일한 위치를 가리 키므로 a[5] = 5[a].

이 설명은 배열의 음수 인덱스가 C에서 작동하는 이유이기도합니다.

즉 내가 접근 a[-5]하면 나에게 줄 것이다

Base Address of your Array a + (-5 * size of(data type for array a))
i.e. 1000 + (-5*2) = 990

위치 990의 객체를 반환합니다.

에서 C 배열 , arr[3]그리고 3[arr]동일하며, 자신의 해당 포인터 표기법은 *(arr + 3)에 *(3 + arr). 그러나 반대로 [arr]3거나하는 [3]arr등, 올바르지 않은 및 구문 오류로 발생합니다 (arr + 3)*및 (3 + arr)*올바른 표현이 아니다. 이유는 역 참조 연산자가 주소 이후가 아니라 표현식에서 생성 된 주소 앞에 배치되어야하기 때문입니다.

C 컴파일러에서

a[i]
i[a]
*(a+i)

배열의 요소를 참조하는 다른 방법입니다! (전세계가 아님)

이제 조금 역사가 있습니다. 다른 언어 중에서도 BCPL은 C의 초기 개발에 상당히 큰 영향을 미쳤습니다. BCPL에서 다음과 같이 배열을 선언 한 경우 :

let V = vec 10

실제로는 10 단어가 아닌 11 단어의 메모리를 할당했습니다. 따라서 C와 달리 이름 지정 V는 해당 위치로 이동하여 배열의 0 번째 요소의 주소를 선택했습니다. 따라서 BCPL의 배열 간접 참조

let J = V!5

J = !(V + 5)배열의 기본 주소를 얻기 위해 V를 페치해야 했으므로 실제로 BCPL 구문을 사용하여 수행해야 했습니다. 따라서 V!5및5!V 동의어였다. 일화적인 관찰로서 WAFL (Warwick Functional Language)은 BCPL로 작성되었으며, 내 기억을 최대한 활용하기 위해 데이터 스토리지로 사용되는 노드에 액세스하기 위해 전자보다 후자의 구문을 사용하는 경향이있었습니다. 이것은 35 년에서 40 년 전의 것이 었으므로 나의 기억은 조금 녹슬 었습니다. :)

여분의 스토리지 단어를 사용하지 않고 컴파일러가 어레이의 기본 주소를 나중에 명명 할 때 삽입하도록하는 혁신. C 역사 보고서에 따르면 이것은 구조가 C에 추가 된 시점에서 발생했습니다.

하는 것으로 !BCPL에 단항 접두사 연산자와 간접을하고 두 경우 모두 진 중위 연산자, 둘이었다. 이진 형식에는 간접 처리를 수행하기 전에 두 피연산자가 추가 된 것이 포함되어 있습니다. BCPL (및 B)의 단어 지향적 특성을 고려할 때 이것은 실제로 많은 의미가 있습니다. 「포인터와 정수」의 제한은, 데이터 형을 취득했을 때에 C에 필요 sizeof하게되어 일이되었습니다.

글쎄, 이것은 언어 지원 때문에 가능한 기능입니다.

컴파일러는 a[i]로 해석 *(a+i)하고 표현식은로 5[a]평가됩니다 *(5+a). 덧셈은 교환 적이므로 둘 다 동일하다는 것이 밝혀졌습니다. 따라서 표현은true .

C에서

 int a[]={10,20,30,40,50};
 int *p=a;
 printf("%d\n",*p++);//output will be 10
 printf("%d\n",*a++);//will give an error

포인터는 "가변"

배열 이름은 "니모닉"또는 "동의어"

p++; 유효하지만 a++ 유효하지 않습니다

a[2] 이 둘의 내부 연산이 다음과 같기 때문에 2 [a]와 같습니다.

내부적으로 계산 된 "포인터 산술"

*(a+3) 같다 *(3+a)

포인터 유형

1) 데이터에 대한 포인터

int *ptr;

2) 데이터에 대한 const 포인터

int const *ptr;

3) const 데이터에 대한 const 포인터

int const *const ptr;

배열은 목록에서 (2) 유형입니다 . 한 번에 하나의 주소가 해당 포인터에서 초기화
될 때 배열 을 정의하면 프로그램에서 const 값을 변경하거나 수정할 수 없다는 것을 알기 때문에 컴파일시 오류 가 발생합니다 시각

큰 차이 내가 찾은입니다 ...

주소로 포인터를 다시 초기화 할 수 있지만 배열과 동일한 경우는 아닙니다.

======
그리고 당신의 질문으로 돌아가는
a[5]것은 아무것도 아니지만 *(a + 5)
당신은
a -리스트에 (2) 유형의 포인터처럼 주소 (사람들이 기본 주소라고 부릅니다)를 포함 함으로써 쉽게 이해할 수 있습니다
[] -그 연산자는 pointer로 교체 가능 *.

마지막으로 ...

a[5] == *(a +5) == *(5 + a) == 5[a]