초보자에게 C 포인터 (선언 대 단항 연산자)를 설명하는 방법은 무엇입니까?

나는 C 프로그래밍 초보자에게 포인터를 설명하는 데 최근에 기쁨을 느꼈으 며 다음과 같은 어려움에 부딪쳤다. 포인터를 사용하는 방법을 이미 알고 있다면 전혀 문제가되지 않을 수 있지만 다음 예제를 분명하게 살펴보십시오.

int foo = 1;
int *bar = &foo;
printf("%p\n", (void *)&foo);
printf("%i\n", *bar);

절대 초보자에게는 출력이 놀랍습니다. 2 행에서 방금 * bar를 & foo로 선언했지만 4 행에서 * bar는 실제로 & foo 대신 foo입니다!

혼란은 * 기호의 모호성에서 비롯됩니다. 2 행에서 포인터를 선언하는 데 사용됩니다. 4 행에서 포인터가 가리키는 값을 가져 오는 단항 연산자로 사용됩니다. 다른 두 가지가 맞습니까?

그러나이 "설명"은 초보자에게 전혀 도움이되지 않습니다. 미묘한 차이를 지적하여 새로운 개념을 소개합니다. 이것을 가르치는 올바른 방법이 될 수 없습니다.

Kernighan과 Ritchie는 어떻게 설명했습니까?

단항 연산자 *는 간접 또는 역 참조 연산자입니다. 포인터에 적용되면 포인터가 가리키는 객체에 액세스합니다. […]

포인터 ip의 선언은 int *ip니모닉으로 만들어졌습니다. 그것은 표현 *ip이 정수 라고 말합니다 . 변수 선언 구문은 변수가 나타날 수있는 표현식 구문과 유사합니다 .

int *ip"" *ip를 반환하는 것처럼 읽을 int까요? 그런데 왜 선언 후 과제가 그 패턴을 따르지 않습니까? 초보자가 변수를 초기화하려면 어떻게해야합니까? int *ip = 1(읽기 : *ip는를 반환 int하고 intis는 1) 예상대로 작동하지 않습니다. 개념적 모델은 일관된 것처럼 보이지 않습니다. 여기에 뭔가 빠졌습니까?

편집 : 여기에 답변 을 요약 하려고했습니다 .

학생들이 *다른 상황 에서 상징 의 의미를 이해 하려면 먼저 상황이 실제로 다르다는 것을 이해해야합니다. 일단 문맥이 다르다는 것을 이해하고 나면 (즉, 과제의 왼쪽과 일반 표현의 차이) 차이가 무엇인지 이해하기에는 너무 많은인지 적 도약이 아닙니다.

먼저 변수 선언에 연산자를 포함 할 수 없다고 설명하십시오 ( -또는+ 변수 선언에 기호 단순히 오류가 발생 함 ). 그런 다음 표현식 (예 : 할당의 오른쪽)에 연산자가 포함될 수 있음을 보여줍니다. 학생이 표현식과 변수 선언이 완전히 다른 상황이라는 것을 이해하도록하십시오.

문맥이 다르다는 것을 이해하면 *기호가 변수 식별자 앞에 변수 선언에 있을 때 '이 변수를 포인터로 선언'을 의미 한다고 설명 할 수 있습니다 . 그런 다음 표현식에서 단항 연산자로 사용될 때 *기호는 '역 참조 연산자'이며 이전 의미가 아니라 '주소의 값'을 의미 한다고 설명 할 수 있습니다 .

학생을 진정으로 확신시키기 위해 C의 제작자는 역 참조 연산자를 의미하는 기호를 사용할 수 있었지만 (즉, @대신 사용할 수 있음 ) 어떤 이유로 든 디자인 사용을 결정했다고 설명합니다 *.

대체로 상황이 다르다는 것을 설명 할 방법이 없습니다. 학생이 상황이 다르다는 것을 이해하지 못하면 그 *상징이 다른 것을 의미 하는 이유를 이해할 수 없습니다 .

속기 이유 :

int *bar = &foo;

귀하의 예에서 혼란 스러울 수있는 것은 다음과 동등한 것으로 잘못 읽는 것이 쉽다는 것입니다.

int *bar;
*bar = &foo;    // error: use of uninitialized pointer bar!

그것이 실제로 의미하는 경우 :

int *bar;
bar = &foo;

이렇게 변수 선언과 할당이 분리 된 상태에서 이렇게 혼동 될 가능성이 없으며 K & R 견적에 설명 된 사용 ↔ 선언 병렬 처리가 완벽하게 작동합니다.

• 첫 번째 라인은 변수를 선언 bar하도록, *bar이다 int.

• 두번째 라인의 어드레스 할당 foo을 bar만들기 *bar(AN int)에 대한 별칭 foo(도를 int).

초보자에게 C 포인터 구문을 도입 할 때는 처음에 이러한 스타일의 포인터 선언을 지정에서 분리하고, 포인터의 기본 개념이 일단 사용되면 혼동 가능성에 대한 적절한 경고와 함께 결합 된 속기 구문 만 소개하는 것이 도움이 될 수 있습니다. C는 충분히 내재화되었습니다.

선언의 부족

선언과 초기화의 차이점을 아는 것이 좋습니다. 변수를 타입으로 선언하고 값으로 초기화합니다. 동시에 둘 다하면 정의라고합니다.

1. int a; a = 42;

int a;
a = 42;

우리는 선언int 이름 을 . 그런 다음 값을 지정하여 초기화합니다 42.

2. int a = 42;

우리는 선언 과 int이름 을 하고 그것에게 그것은으로 초기화되는 값 (42)을 제공합니다 42. 정의.

3. a = 43;

우리가 변수를 사용할 때 우리는 그 변수를 조작 한다고 말합니다 . a = 43할당 작업입니다. 변수 43에 숫자 43을 할당합니다.

말함으로써

int *bar;

bar 를 int에 대한 포인터로 선언 합니다 . 말함으로써

int *bar = &foo;

bar 를 선언 하고 foo 주소로 초기화합니다 .

bar 를 초기화 한 후에는 동일한 연산자 인 별표를 사용하여 foo 값에 액세스하고 작동 할 수 있습니다 . 연산자가 없으면 포인터가 가리키는 주소에 액세스하여 작동합니다.

그 외에도 나는 그림을 말하게했다.

뭐

무슨 일이 일어나고 있는지에 대한 간단한 ASCIIMATION. (여기서 일시 중지하려는 플레이어 버전 )

두 번째 진술 int *bar = &foo;은 다음과 같이 메모리에서 그림으로 볼 수 있습니다.

   bar           foo
  +-----+      +-----+
  |0x100| ---> |  1  |
  +-----+      +-----+ 
   0x200        0x100

이제 주소 가 포함 된 bar유형의 포인터 입니다 . 단항 연산자 를 사용하면 pointer를 사용하여 'foo'에 포함 된 값을 검색하는 것을 연기합니다 . int&foo*bar

편집 : 초보자와의 접근 방식 memory address은 변수의 예 를 설명하는 것 입니다.

Memory Address:모든 변수에는 OS에서 제공 한 것과 관련된 주소가 있습니다. 에서는 int a;, &a변수의 어드레스이다 a.

다음과 C같이 기본 변수 유형을 계속 설명하십시오 .

Types of variables: 변수는 각 유형의 값을 보유 할 수 있지만 주소는 보유 할 수 없습니다.

int a = 10; float b = 10.8; char ch = 'c'; `a, b, c` are variables. 

Introducing pointers: 위에서 말한 것처럼 예를 들어

 int a = 10; // a contains value 10
 int b; 
 b = &a;      // ERROR

변수 는 값을 가질 수는 있지만 주소를 지정할 수 b = a없으므로 할당 할 수는 없지만 포인터 가 필요합니다 .b = &ab

Pointer or Pointer variables :변수에 주소가 포함되어 있으면 포인터 변수라고합니다. *선언에서 포인터임을 알리려면 사용하십시오 .

• Pointer can hold address but not value
• Pointer contains the address of an existing variable.
• Pointer points to an existing variable

여기의 답변과 의견을 보면 문제의 구문이 초보자에게 혼란을 줄 수 있다는 일반적인 동의가있는 것 같습니다. 그들 대부분은 다음 라인을 따라 무언가를 제안합니다.

• 코드를 표시하기 전에 다이어그램, 스케치 또는 애니메이션을 사용하여 포인터 작동 방식을 설명하십시오.
• 구문을 제시 할 때 별표 기호의 두 가지 역할을 설명하십시오 . 많은 튜토리얼에서 해당 부분이 누락되거나 회피됩니다. 혼란이 뒤 따릅니다 ( "초기화 포인터 선언을 선언과 나중 과제로 나눌 때 *를 제거해야합니다."– comp.lang.c FAQ ) 대체 방법을 찾고 싶었지만 이것이 다음과 같습니다. 가는 길.

차이점을 강조하기 위해 int* bar대신 쓸 수 있습니다 int *bar. 이는 K & R "선언 모방 사용"접근 방식을 따르지 않지만 Stroustrup C ++ 접근 방식을 .

*bar정수로 선언하지 않습니다 . 우리는로 선언 bar합니다 int*. 같은 줄에서 새로 생성 된 변수를 초기화하려면 bar, 아닌을 다루는 것이 분명합니다 *bar.int* bar = &foo;

단점 :

• 다중 포인터 선언 문제 ( int* foo, barvs int *foo, *bar)에 대해 학생에게 경고해야합니다 .
• 당신은 상처 의 세계에 대비해야합니다 . 많은 프로그래머들은 변수 이름 옆에 별표가 표시되기를 원하며 스타일을 정당화하기 위해 많은 시간이 걸릴 것입니다. 그리고 많은 스타일 가이드가이 표기법을 명시 적으로 적용합니다 (Linux 커널 코딩 스타일, NASA C 스타일 가이드 등).

편집 : 제안 된 다른 접근 방식 은 K & R "mimic"방법을 사용하지만 "shortshort"구문을 사용하지 않는 것입니다 ( 여기 참조 ). 같은 줄에서 선언과 할당 을 생략 하자마자 모든 것이 훨씬 더 일관성있게 보일 것입니다.

그러나 조만간 학생은 포인터를 함수 인수로 다루어야합니다. 그리고 리턴 타입으로서의 포인터. 그리고 함수를 가리키는 포인터. 당신은 사이의 차이를 설명해야합니다 int *func();및 int (*func)();. 조만간 문제가 발생할 것이라고 생각합니다. 아마 나중이 빠를수록 좋습니다.

K & R 스타일이 선호 int *p되고 Stroustrup 스타일이 선호 되는 이유가 있습니다 int* p. 둘 다 각 언어에서 유효하며 같은 의미이지만 Stroustrup이 다음과 같이 말합니다.

"int * p;"중에서 선택 그리고 "int * p;" 옳고 그름에 관한 것이 아니라 스타일과 강조에 관한 것입니다. C는 표현을 강조했다; 선언은 종종 필요한 악에 지나지 않습니다. 반면에 C ++은 유형에 중점을 둡니다.

자, 여기서 C를 가르치려고 노력하고 있기 때문에, 당신은 그 유형보다 표현을 강조해야한다고 제안 할 것입니다. 그러나 어떤 사람들은 다른 것보다 한 가지 강조점을 더 빨리 잡을 수 있고 그것은 언어가 아닌 그들에 관한 것입니다.

따라서 어떤 사람들int* 은 a가 다른 것과 다르다는 생각으로 시작하고 int거기에서 나가는 것이 더 쉽다는 것을 알게 될 것 입니다.

누군가가 빠르게 용도가 그것을보고의 방법 grok 수없는 경우 int* bar가지고 bar있는 int가 아닌 것 같은,하지만에 대한 포인터를 int, 그들은 신속하게이 볼 수 *bar있다 뭔가 일 까지를 bar, 나머지는 따를 것이다. 일단 그렇게하면 나중에 C 코더가 선호하는 이유를 나중에 설명 할 수 있습니다 int *bar.

아님 모든 사람이 먼저 개념을 이해하는 한 가지 방법이 있다면 처음에는 아무런 문제가 없었을 것이며, 한 사람에게 설명하는 가장 좋은 방법은 다른 사람에게 그것을 설명하는 가장 좋은 방법은 아닙니다.

tl; dr :

Q : 초보자에게 C 포인터 (선언 대 단항 연산자)를 설명하는 방법은 무엇입니까?

A :하지 마십시오. 초보자를위한 포인터를 설명하고 C 구문으로 포인터 개념을 나타내는 방법을 보여줍니다.

나는 C 프로그래밍 초보자에게 포인터를 설명하는 데 최근에 기쁨을 느꼈으 며 다음과 같은 어려움에 부딪쳤다.

C 구문 IMO는 끔찍하지는 않지만 훌륭하지도 않습니다. 포인터를 이미 이해하고 있거나 배우는 데 도움이된다면 큰 방해가되지 않습니다.

따라서 포인터를 설명하는 것으로 시작하여 실제로 이해해야합니다.

• 상자와 화살표 다이어그램으로 설명하십시오. 16 진수 주소가 없으면 관련이없는 경우 다른 상자 또는 null 기호를 가리키는 화살표를 표시하십시오.

• 의사 코드로 설명하십시오 : foo의 주소 와 bar에 저장된 값을 쓰십시오 .

• 그런 다음, 초보자가 포인터가 무엇인지, 그리고 왜, 어떻게 사용하는지 이해하면; 그런 다음 C 구문에 대한 매핑을 보여줍니다.

나는 K & R 텍스트가 개념적 모델을 제공하지 않는 이유는 그들이 이미 포인터를 이해 했기 때문이며 아마도 당시의 다른 모든 유능한 프로그래머도 그랬다고 가정했을 것입니다. 니모닉은 잘 이해 된 개념에서 구문으로의 매핑을 상기시켜줍니다.

이 문제는 C를 배우기 시작할 때 다소 혼란 스럽다.

시작하는 데 도움이되는 기본 원칙은 다음과 같습니다.

1. C에는 몇 가지 기본 유형 만 있습니다.

   • char: 1 바이트 크기의 정수 값.

   • short: 2 바이트 크기의 정수 값.

   • long: 크기가 4 바이트 인 정수 값.

   • long long: 8 바이트 크기의 정수 값.

   • float: 크기가 4 바이트 인 정수가 아닌 값.

   • double: 8 바이트 크기의 정수가 아닌 값.

   각 유형의 크기는 일반적으로 표준이 아닌 컴파일러에 의해 정의됩니다 .

   정수 유형 short, long및 long long일반적으로 다음에 있습니다 int.

   그러나 필수는 아니며 int. 없이 사용할 수 있습니다 .

   또는 state 만 할 수는 int있지만 컴파일러마다 다르게 해석 될 수 있습니다.

   이를 요약하면 다음과 같습니다.

   • short와 동일 short int하지만 반드시 동일 하지는 않습니다 int.

   • long와 동일 long int하지만 반드시 동일 하지는 않습니다 int.

   • long long와 동일 long long int하지만 반드시 동일 하지는 않습니다 int.

   • 주어진 컴파일러에서 int중 하나입니다 short int또는 long int나 long long int.

2. 어떤 유형의 변수를 선언하면 해당 변수를 가리키는 다른 변수를 선언 할 수도 있습니다.

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

   int a;

   int* b = &a;

   본질적으로 각 기본 유형마다 해당 포인터 유형이 있습니다.

   예를 들면 다음 short과 같습니다 short*.

   두 가지 변수 "모양은"이있다 b (아마도 대부분의 초보자를 혼란 무엇의 그) :

   • b유형의 변수로 간주 할 수 있습니다 int*.

   • *b유형의 변수로 간주 할 수 있습니다 int.

   따라서 어떤 사람들은 선언 int* b하고 다른 사람들은 선언 int *b합니다.

   그러나 문제의 사실은이 두 선언이 동일하다는 것입니다 (공백은 의미가 없습니다).

   b정수 값에 대한 포인터로 사용 하거나*b 실제 뾰족한 정수 값으로.

   지정된 값을 얻을 수 있습니다. int c = *b .

   그리고 지정된 값을 설정 (쓰기) 할 수 있습니다 *b = 5.

3. 포인터는 이전에 선언 한 일부 변수의 주소뿐만 아니라 모든 메모리 주소를 가리킬 수 있습니다. 그러나 지정된 메모리 주소에있는 값을 가져 오거나 설정하려면 포인터를 사용할 때주의해야합니다.

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

   int* a = (int*)0x8000000;

   여기에는 a메모리 주소 0x8000000을 가리키는 변수가 있습니다 .

   이 메모리 주소가 프로그램의 메모리 공간 내에 매핑되지 않은 경우 *a, 메모리 액세스 위반으로 인해 사용하는 모든 읽기 또는 쓰기 작업 으로 인해 프로그램이 중단 될 수 있습니다.

   의 값을 안전하게 변경할 수 a있지만의 값을 변경하는 데 매우주의해야합니다 *a.

4. 유형 void*은 사용할 수있는 해당 "값 유형"이 없기 때문에 예외적입니다 (즉, 선언 할 수 없음 void a). 이 유형은 해당 주소에있는 데이터 유형을 지정하지 않고 메모리 주소에 대한 일반적인 포인터로만 사용됩니다.

아마도 조금 더 단계별로 살펴보면 더 쉬울 것입니다.

#include <stdio.h>

int main()
{
    int foo = 1;
    int *bar = &foo;
    printf("%i\n", foo);
    printf("%p\n", &foo);
    printf("%p\n", (void *)&foo);
    printf("%p\n", &bar);
    printf("%p\n", bar);
    printf("%i\n", *bar);
    return 0;
}

각 라인에 출력이있을 것으로 예상 한 것을 알려주고 프로그램을 실행하고 무엇이 나오는지 확인하게하십시오. 그들의 질문을 설명하십시오 (알몸 버전은 확실히 몇 가지를 요구하지만 나중에 스타일, 엄격 성 및 이식성에 대해 걱정할 수 있습니다). 그런 다음, 그들의 생각이 지나친 생각에서 흐릿 해 지거나 점심 식사 후 좀비가되기 전에 값을 취하는 함수와 포인터를 취하는 동일한 함수를 작성하십시오.

내 경험상 "이런 식으로 인쇄되는 이유는 무엇입니까?" 험프 (Hump)를 누른 다음 , 수업이 이해하기 쉬울뿐 아니라 스틱 잉 / 배열 처리와 같은 기본 K & R 자료에 대한 전제로 실습을 통해 기능 매개 변수에 유용한 이유 를 즉시 보여줍니다.

다음 단계에 설명을 얻는 것입니다 당신이 방법 i[0]에 관한 것이다 &i. 그들이 그렇게 할 수 있다면, 그들은 그것을 잊지 않을 것이고, 당신은 구조체에 대해 조금이라도 미리 이야기 할 수 있습니다.

상자와 화살표에 대한 위의 권장 사항도 좋지만 메모리가 어떻게 작동하는지에 대한 완전한 토론으로 빠져 나올 수 있습니다. 이는 어떤 시점에서 발생해야하지만 즉각적인 시점에서 산만해질 수 있습니다. : C에서 포인터 표기법을 해석하는 방법

표현식 의 유형 *bar은 int; 따라서 변수 (및 표현식) 의 유형은 bar입니다 int *. 변수에는 포인터 유형이 있으므로 초기화 프로그램에도 포인터 유형이 있어야합니다.

포인터 변수 초기화와 할당간에 불일치가 있습니다. 그것은 어려운 방법으로 배워야 할 것입니다.

개 이상에 *적용 되는 첫 번째 문서로 읽습니다 .intbar

int  foo = 1;           // foo is an integer (int) with the value 1
int* bar = &foo;        // bar is a pointer on an integer (int*). it points on foo. 
                        // bar value is foo address
                        // *bar value is foo value = 1

printf("%p\n", &foo);   // print the address of foo
printf("%p\n", bar);    // print the address of foo
printf("%i\n", foo);    // print foo value
printf("%i\n", *bar);   // print foo value

int *bar = &foo;

Question 1: 무엇입니까 bar?

Ans: 포인터 변수 (유형 int)입니다. 포인터는 유효한 메모리 위치를 가리켜 야하며 나중에 *해당 위치에 저장된 값을 읽으려면 단항 연산자 를 사용하여 역 참조 (* bar)해야합니다 .

Question 2: 무엇입니까 &foo?

Ans: foo는 int유효한 메모리 위치에 저장된 타입의 변수이며 ,이 위치는 연산자로부터 얻었 &으므로 이제 우리가 가지고있는 것은 유효한 메모리 위치 &foo입니다.

그래서 두 포인터를 합치면 즉, 포인터가 필요한 것은 유효한 메모리 위치였으며 &foo그로 인해 초기화가 좋습니다.

이제 포인터 bar가 유효한 메모리 위치를 가리키고 있으며 그에 저장된 값을 참조 할 수 있습니다.*bar

선언과 표현에서 *의 의미가 다른 초보자를 지적해야합니다. 아시다시피, 식에서 *는 단항 연산자이며 * 선언에서 연산자가 아니며 형식과 결합하여 컴파일러가 포인터 형식임을 알리는 일종의 구문입니다. 초보자에게 "*는 다른 의미를 갖습니다. *의 의미를 이해하려면 *가 사용되는 곳을 찾아야합니다."

악마가 우주에 있다고 생각합니다.

나는 (초보자뿐만 아니라 나 자신도) 쓸 것이다 : int * bar = & foo; int 대신 * bar = & foo;

이것은 구문과 시맨틱 사이의 관계가 무엇인지 분명해야합니다.

이미 여러 가지 역할이 있다는 점에 주목했다.

초보자가 물건을 이해하는 데 도움이되는 또 다른 간단한 아이디어가 있습니다.

"="에는 여러 역할이 있다고 생각하십시오.

할당이 선언과 같은 줄에 사용될 때는 임의의 할당이 아니라 생성자 호출로 생각하십시오.

당신이 볼 때 :

int *bar = &foo;

거의 다음과 같습니다.

int *bar(&foo);

괄호는 별표보다 우선하므로 "& foo"는 "* bar"보다는 "bar"에 훨씬 더 직관적으로 기인합니다.

나는 며칠 전에이 질문을 보았고 Go 블로그에서 Go의 유형 선언에 대한 설명을 읽었습니다 . C 형 선언을 설명하는 것으로 시작합니다.이 답변은 이미 완료된 답변이 더 있다고 생각 하더라도이 스레드에 추가하는 데 유용한 리소스처럼 보입니다.

C는 선언 구문에 대해 독특하고 영리한 접근 방식을 취했습니다. 특별한 문법으로 타입을 설명하는 대신, 선언 될 아이템과 관련된 표현식을 작성하고 그 표현식이 어떤 타입을 가질 것인지를 명시합니다. 그러므로

int x;

x를 int로 선언합니다. 표현식 'x'는 int 유형을 갖습니다. 일반적으로 새 변수의 유형을 작성하는 방법을 알아 보려면 기본 유형으로 평가되는 해당 변수와 관련된 표현식을 작성한 다음 기본 유형을 왼쪽에, 표현식을 오른쪽에 놓으십시오.

따라서 선언

int *p;
int a[3];

'* p'는 int 유형을 가지고 있기 때문에 p는 int에 대한 포인터이고 a [3] (배열의 크기로 펀칭 된 특정 색인 값은 무시)이 있기 때문에 a는 int 배열입니다. int.

(이러한 이해를 함수 포인터 등으로 확장하는 방법을 설명합니다.)

이것은 내가 전에 생각하지 않은 방법이지만 구문의 과부하를 설명하는 매우 간단한 방법처럼 보입니다.

문제가 구문 인 경우 템플릿 / 사용시 동등한 코드를 표시하는 것이 도움이 될 수 있습니다.

template<typename T>
using ptr = T*;

이것은 다음과 같이 사용될 수 있습니다

ptr<int> bar = &foo;

그런 다음 일반 / C 구문을이 C ++ 전용 방법과 비교하십시오. const 포인터를 설명 할 때도 유용합니다.

혼란의 원인은 *기호가 사용되는 사실에 따라 기호가 C에서 다른 의미를 가질 수 있다는 사실에서 발생합니다. 초보자를위한 포인터를 설명하기 위해, *다른 맥락에서 의 기호 의 의미를 설명해야합니다.

선언에서

int *bar = &foo;  

*심볼은 간접 연산자하지 . 대신 bar컴파일러에게 bar에 대한 포인터int 임을 알리는 유형을 지정하는 데 도움이됩니다 . 한편, 명령문에 *표시 될 때 기호 ( 단항 연산자 로 사용되는 경우 )는 간접 처리를 수행합니다. 따라서 진술

*bar = &foo;

자체가 아닌 foo객체에 주소를 할당하기 때문에 잘못되었습니다 .barbar

"int * 막대로 작성하면 별이 실제로 식별자의 일부가 아닌 유형의 일부라는 것이 더 분명해집니다." 그래서 그렇습니다. 그리고 Type과 비슷하지만 하나의 포인터 이름에만 해당됩니다.

"물론 이것은 int * a, b와 같은 직관적이지 않은 것들에 대해 다른 문제를 야기합니다."

여기서는 인간의 논리가 아닌 컴파일러 논리를 사용하고 이해하고 설명해야합니다 (나는 당신 이 인간이지만 컴퓨터를 모방해야합니다 ...).

당신이 쓸 때

int *bar = &foo;

컴파일러는

{ int * } bar = &foo;

즉, 여기에 새로운 변수가 있으며, 그 이름은 bar이고, 그 유형은 int에 대한 포인터이며, 초기 값은 &foo입니다.

그리고 당신은 추가해야합니다 다음 =위의 의미를 초기화하지 않은 허식, 다음 식에 반면 *bar = 2;이 있다 허식

주석 별 편집 :

주의 : 다중 선언의 경우 *다음 변수에만 관련됩니다.

int *bar = &foo, b = 2;

bar는 foo의 주소로 초기화 된 int에 대한 포인터이고 b는 2로 초기화 된 int입니다.

int *bar=&foo, **p = &bar;

bar는 여전히 int에 대한 포인터이고, p는 주소 또는 bar에 초기화 된 int에 대한 포인터에 대한 포인터입니다.

기본적으로 포인터는 배열 표시가 아닙니다. 초보자는 포인터가 배열처럼 보인다고 쉽게 생각합니다. 대부분의 문자열 예제는

"char * pstr"과 비슷합니다.

"char str [80]"

그러나 중요한 것은 포인터가 하위 수준의 컴파일러에서 정수로 취급됩니다.

예제를 보자 ::

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv, char **env)
{
    char str[] = "This is Pointer examples!"; // if we assume str[] is located in 0x80001000 address

    char *pstr0 = str;   // or this will be using with
    // or
    char *pstr1 = &str[0];

    unsigned int straddr = (unsigned int)pstr0;

    printf("Pointer examples: pstr0 = %08x\n", pstr0);
    printf("Pointer examples: &str[0] = %08x\n", &str[0]);
    printf("Pointer examples: str = %08x\n", str);
    printf("Pointer examples: straddr = %08x\n", straddr);
    printf("Pointer examples: str[0] = %c\n", str[0]);

    return 0;
}

결과는 다음과 같습니다. 0x2a6b7ed0 주소는 str []

~/work/test_c_code$ ./testptr
Pointer examples: pstr0 = 2a6b7ed0
Pointer examples: &str[0] = 2a6b7ed0
Pointer examples: str = 2a6b7ed0
Pointer examples: straddr = 2a6b7ed0
Pointer examples: str[0] = T

기본적으로 포인터는 일종의 정수입니다. 주소 제시.

ints는 float 등의 객체라고 설명합니다. 포인터는 값이 메모리의 주소를 나타내는 객체 유형이므로 포인터의 기본값은 NULL입니다.

포인터를 처음 선언 할 때는 type-pointer-name 구문을 사용하십시오. "정수 객체의 주소를 가리킬 수있는 name이라는 정수 포인터"로 읽습니다. int를 'int num1'로 선언하는 방법과 유사하게, Decleration 동안이 구문 만 사용하지만 'int num1'이 아닌 해당 변수를 사용하려는 경우 'num1'만 사용합니다.

int x = 5; // 5의 정수 객체

int * ptr; // 기본적으로 NULL 값을 갖는 정수

포인터가 객체의 주소를 가리 키도록하려면 "주소"로 읽을 수있는 '&'기호를 사용합니다.

ptr = & x; // 이제 값은 'x'의 주소입니다.

포인터는 객체의 주소 일 뿐이므로 해당 주소에 보유 된 실제 값을 얻으려면 포인터 앞에 사용될 때 "가 가리키는 주소의 값"을 의미하는 '*'기호를 사용해야합니다.

std :: cout << * ptr; // 주소에서 값을 출력

' '는 다른 유형의 객체로 다른 결과를 반환하는 '연산자'라고 간단히 설명 할 수 있습니다 . 포인터와 함께 사용될 때 ' '연산자는 더 이상 "곱하기"를 의미하지 않습니다.

변수에 이름과 값이 있고 포인터에 주소 (이름)와 값이있는 방법을 보여주는 다이어그램을 그리고 포인터 값이 int의 주소임을 보여주는 데 도움이됩니다.

포인터는 주소를 저장하는 데 사용되는 변수 일뿐입니다.

컴퓨터의 메모리는 순차적으로 배열 된 바이트 (1 바이트는 8 비트로 구성)로 구성됩니다. 각 바이트에는 배열의 인덱스 또는 아래 첨자와 마찬가지로 숫자가 있으며이를 바이트의 주소라고합니다. 바이트의 주소는 0에서 시작하여 메모리 크기보다 작습니다. 예를 들어 64MB의 RAM에는 64 * 2 ^ 20 = 67108864 바이트가 있습니다. 따라서이 바이트의 주소는 0에서 67108863까지 시작합니다.

변수를 선언 할 때 어떻게되는지 봅시다.

int 마크;

우리가 알고있는 것처럼 int는 4 바이트의 데이터를 차지하므로 (32 비트 컴파일러를 사용한다고 가정) 컴파일러는 메모리에서 4 연속 바이트를 예약하여 정수 값을 저장합니다. 할당 된 4 바이트 중 첫 번째 바이트의 주소를 변수 표시의 주소라고합니다. 4 연속 바이트의 주소가 5004, 5005, 5006 및 5007이라고 가정하면 변수 마크의 주소는 5004입니다.

포인터 변수 선언

이미 말했듯이 포인터는 메모리 주소를 저장하는 변수입니다. 다른 변수와 마찬가지로 사용하기 전에 먼저 포인터 변수를 선언해야합니다. 다음은 포인터 변수를 선언하는 방법입니다.

통사론: data_type *pointer_name;

data_type은 포인터의 유형입니다 (포인터의 기본 유형이라고도 함). pointer_name은 유효한 C 식별자가 될 수있는 변수의 이름입니다.

몇 가지 예를 들어 보자.

int *ip;

float *fp;

int * ip는 ip가 int 유형의 변수를 가리킬 수있는 포인터 변수임을 의미합니다. 즉, 포인터 변수 ip는 int 유형의 변수 주소 만 저장할 수 있습니다. 마찬가지로 포인터 변수 fp는 float 유형의 변수 주소 만 저장할 수 있습니다. 변수 유형 (기본 유형이라고도 함) ip는 int에 대한 포인터이고 fp 유형은 float에 대한 포인터입니다. int에 대한 포인터 유형의 포인터 변수는 기호 적으로 (int *)로 표시 될 수 있습니다. 마찬가지로 float 형식 포인터의 포인터 변수는 (float *)로 나타낼 수 있습니다.

포인터 변수를 선언 한 후 다음 단계는 유효한 메모리 주소를 할당하는 것입니다. 선언 직후에는 가비지 값이 포함되어 메모리의 아무 곳이나 가리킬 수 있으므로 유효한 메모리 주소를 할당하지 않고 포인터 변수를 사용해서는 안됩니다. 할당되지 않은 포인터를 사용하면 예기치 않은 결과가 발생할 수 있습니다. 심지어 프로그램이 중단 될 수도 있습니다.

int *ip, i = 10;
float *fp, f = 12.2;

ip = &i;
fp = &f;

출처 : thecguru 는 지금까지 내가 찾은 가장 간단하지만 자세한 설명입니다.