포인터

이전 장에서 변수는 식별자(이름)로 액세스할 수 있는 컴퓨터 메모리의 위치로 설명되었습니다. 이런 식으로 프로그램은 메모리에 있는 데이터의 물리적 주소에 대해 신경 쓸 필요가 없습니다. 변수를 참조해야 할 때마다 단순히 식별자를 사용합니다.

C++ 프로그램의 경우 컴퓨터의 메모리는 크기가 1바이트이고 각각 ​​고유한 주소를 가진 일련의 메모리 셀과 같습니다. 이러한 단일 바이트 메모리 셀은 1바이트보다 큰 데이터 표현이 연속적인 주소를 갖는 메모리 셀을 점유할 수 있도록 하는 방식으로 정렬됩니다.

이러한 방식으로 각 셀은 고유한 주소를 통해 메모리에서 쉽게 찾을 수 있습니다. 예를 들어, 주소가 있는 메모리 셀은 1776항상 주소가 있는 셀 바로 다음에 옵니다.1775및 가 있는 것보다 앞에 1777오고 는 뒤에 정확히 1,000개의 셀이 있고 이전에는 정확히 7761,000개의 셀 이 2776있습니다.

변수가 선언되면 그 값을 저장하는 데 필요한 메모리에 메모리의 특정 위치(메모리 주소)가 할당됩니다. 일반적으로 C++ 프로그램은 변수가 저장되는 정확한 메모리 주소를 능동적으로 결정하지 않습니다. 다행히도 그 작업은 프로그램이 실행되는 환경에 맡겨집니다. 일반적으로 런타임 시 특정 메모리 위치를 결정하는 운영 체제입니다. 그러나 프로그램이 특정 위치에 있는 데이터 셀에 액세스하기 위해 런타임 중에 변수의 주소를 얻을 수 있는 것이 유용할 수 있습니다.

 

주소 연산자(&)

변수의 주소는 변수 이름 앞에 앰퍼샌드 기호( &)를 붙여서 얻을 수 있으며, 이를 주소 연산자라고 합니다. 예를 들어:

foo = &myvar;

이것은 변수의 주소 myvar를 foo; 변수 이름 앞에 주소 연산자 ( )를 붙임으로써 더 이상 변수 자체의 내용을 에 할당하지 않고 주소 myvar를 할당합니다 . 메모리에 있는 변수의 실제 주소는 런타임 전에 알 수 없지만 일부 개념을 명확히 하기 위해 런타임 중에 메모리 주소에 배치 된다고 가정해 보겠습니다 . 이 경우 다음 코드 조각을 고려하십시오.&foo

 

myvar = 25;
foo = &myvar;
bar = myvar;

이를 실행한 후 각 변수에 포함된 값은 다음 다이어그램에 나와 있습니다.

먼저 값 25을 myvar(메모리의 주소가 라고 가정한 변수) 에 할당했습니다 1776. 두 번째 명령문 은 의 주소를

할당 합니다 . 마지막으로 세 번째 명령문은 에 포함된 값을 에 할당 합니다 . 이것은 이전 장에서 이미 여러 번 수행된 표준 할당 작업입니다. 두 번째 문장과 세 번째 문장의 주요 차이점은 주소 연산자 ( )의 모양입니다. 다른 변수의 주소를 저장하는 변수

 

foo이전 예에서)는 C++에서 포인터 라고 하는 것 입니다. 포인터는 저수준 프로그래밍에서 많이 사용되는 언어의 매우 강력한 기능입니다. 잠시 후에 포인터를 선언하고 사용하는 방법을 살펴보겠습니다.

 

역참조 연산자(*)

방금 보았듯이 다른 변수의 주소를 저장하는 변수를 포인터 라고 합니다 . 포인터는 주소가 저장되어 있는 변수를 "가리키는" 것입니다.

포인터의 흥미로운 속성은 포인터가 가리키는 변수에 직접 액세스하는 데 사용할 수 있다는 것입니다. 이것은 포인터 이름 앞에 역참조 연산자 ( *)를 사용하여 수행됩니다. 연산자 자체는 "가 가리키는 값"으로 읽을 수 있습니다.

따라서 이전 예의 값에 따라 다음 명령문은 다음과 같습니다.

 

baz = *foo;

baz이것은 " 이 가리키는 값과 같음 "으로 읽을 수 있으며 foo명령문은 실제로 값 25을 baz에 할당합니다. 왜냐하면 foois 이고 (위의 예 1776에 따라) 가 가리키는 값은 입니다. 가 값 을 참조하는 반면 (식별자 앞에 별표 가 있음) 은 address 에 저장된 값을 참조하는 것으로 이 경우에는 임을 명확하게 구별하는 것이 중요합니다 . 역참조 연산자 를 포함하거나 포함하지 않는 것의 차이점에 주목하세요 (이 두 표현식 각각을 읽는 방법에 대한 설명을 추가했습니다).177625

foo1776*foo*177625

따라서 참조 및 역참조 연산자는 상호 보완적입니다.

• &는 주소 연산자 이며 간단히 "~의 주소"로 읽을 수 있습니다.
• *역 참조 연산자 이며 "다음이 가리키는 값"으로 읽을 수 있습니다.

따라서 그것들은 서로 반대되는 의미를 갖습니다. 로 얻은 주소 &는 로 역참조될 수 있습니다 *.

이전에 다음 두 가지 할당 작업을 수행했습니다.

 

myvar = 25;
foo = &myvar;

이 두 문장 바로 뒤에 다음 식은 모두 true를 결과로 나타냅니다.

myvar == 25
&myvar == 1776
foo == 1776
*foo == 25

에 수행된 할당 작업을 고려하면 첫 번째 표현식은 매우 명확 myvar합니다 myvar=25. 두 번째는 의 주소 &를 반환하는 주소 연산자( )를 사용 myvar합니다 1776. 두 번째 표현식이 true이고 에 대해 수행된 할당 작업이 였기 때문에 세 번째 표현식은 다소 분명 foo합니다 foo=&myvar. 네 번째 표현식은 "가 가리키는 값"으로 읽을 수 있는 역참조 연산자 ( )를 사용하며, 가 가리키는 값 은 실제로 입니다. 따라서 가 가리키는 주소 가 변경되지 않는 한 다음 표현식도 마찬가지임을 추론할 수 있습니다.

*foo == myvar

포인터 선언

포인터가 가리키는 값을 직접 참조할 수 있는 기능으로 인해 포인터는 또는 a char를 가리킬 때와 포인터가 가리킬 때 다른 속성을 갖습니다 . 역참조되면 유형을 알아야 합니다. 그리고 이를 위해 포인터 선언에는 포인터가 가리키는 데이터 유형이 포함되어야 합니다. 포인터 선언은 다음 구문을 따릅니다. 여기서 포인터가 가리키는 데이터 유형입니다. 이 유형은 포인터 자체의 유형이 아니라 포인터가 가리키는 데이터 유형입니다. 예를 들어:

int * number;
char * character;
double * decimals;

다음은 세 가지 포인터 선언입니다. 각각은 서로 다른 데이터 유형을 가리키도록 되어 있지만 실제로는 모두 포인터이고 모두 메모리에서 동일한 양의 공간을 차지할 가능성이 높습니다(포인터의 메모리 크기는 플랫폼에 따라 다릅니다. 프로그램이 실행되는 곳). 그럼에도 불구하고 그들이 가리키는 데이터는 동일한 양의 공간을 차지하지 않으며 동일한 유형도 아닙니다. 첫 번째 데이터는 a , int두 번째 데이터는 a char, 마지막 데이터는 a 를 가리킵니다 double. 따라서 이 세 가지 예제 변수는 모두 포인터이지만 실제로는 가리키는 유형 에 따라 각각 , , 및 각각 int*다른 char*유형 을 갖습니다. 별표(double*

*) 포인터를 선언할 때 사용되는 포인터는 포인터(유형 복합 지정자의 일부임)임을 의미할 뿐이며 , 조금 앞서 본 역참조 연산자 와 혼동해서는 안 되지만 별표( *)로 작성되기도 합니다. 그것들은 단순히 같은 기호로 표현되는 두 가지 다른 것입니다.

포인터에 대한 예를 살펴보겠습니다.

// my first pointer
#include <iostream>
using namespace std;

int main ()
{
  int firstvalue, secondvalue;
  int * mypointer;

  mypointer = &firstvalue;
  *mypointer = 10;
  mypointer = &secondvalue;
  *mypointer = 20;
  cout << "firstvalue is " << firstvalue << '\n';
  cout << "secondvalue is " << secondvalue << '\n';
  return 0;
}

첫 번째 값은 10입니다.
두 번째 값은 20입니다.

둘 다 프로그램에서 직접적으로 값을 설정하지 않더라도 둘 다 를 사용하여 간접적으로 값을 설정 firstvalue하게 됩니다 . 이것이 발생하는 방법입니다. 먼저 주소 연산자( )를 사용하여 첫 번째 값의 주소가 할당됩니다 . 그런 다음 가 가리키는 값에 의 값이 할당됩니다 . 이 순간 가 의 메모리 위치를 가리키고 있기 때문에 실제로 의 값이 수정 됩니다. 포인터가 프로그램에서 수명 동안 다른 변수를 가리킬 수 있음을 보여주기 위해 이 예제에서는 동일한 포인터를 사용하여 프로세스를 반복합니다 . 다음은 조금 더 정교한 예입니다.

// more pointers
#include <iostream>
using namespace std;

int main ()
{
  int firstvalue = 5, secondvalue = 15;
  int * p1, * p2;

  p1 = &firstvalue;  // p1 = address of firstvalue
  p2 = &secondvalue; // p2 = address of secondvalue
  *p1 = 10;          // value pointed to by p1 = 10
  *p2 = *p1;         // value pointed to by p2 = value pointed to by p1
  p1 = p2;           // p1 = p2 (value of pointer is copied)
  *p1 = 20;          // value pointed to by p1 = 20
  
  cout << "firstvalue is " << firstvalue << '\n';
  cout << "secondvalue is " << secondvalue << '\n';
  return 0;
}

첫 번째 값은 10입니다.
두 번째 값은 20입니다.

각 할당 작업에는 각 행을 읽는 방법에 대한 설명이 포함됩니다. 즉, 앰퍼샌드( &)를 "주소"로, 별표( *)를 "가 가리키는 값"으로 대체합니다. 역참조 연산자 ( ) 가 있는 것과 없는 모두 포인터 및

가 있는 표현식이 있습니다 . 역참조 연산자 (*) 를 사용하는 표현식의 의미는 그렇지 않은 표현식과 매우 다릅니다. 이 연산자가 포인터 이름 앞에 올 때 표현식은 가리키는 값을 참조하는 반면 이 연산자 없이 포인터 이름이 나타나면 포인터 자체의 값(즉, 포인터가 가리키는 주소)을 나타냅니다. 주의를 환기시킬 수 있는 또 다른 사항은 다음과 같습니다.p1p2*

int * p1, * p2;

이것은 이전 예제에서 사용된 두 포인터를 선언합니다. 그러나 두 포인터 모두 유형 (포인터 ) *을 갖기 위해 각 포인터에 별표( )가 있음에 유의 하십시오. 이는 우선 순위 규칙으로 인해 필요합니다. 대신 코드가 다음과 같을 경우:int*int

int * p1, p2;

p1실제로 type int*이지만 p2type int입니다. 이 목적을 위해 공백은 전혀 중요하지 않습니다. 그러나 어쨌든 포인터당 하나의 별표를 넣는 것만 기억하면 명령문당 여러 포인터를 선언하는 데 관심이 있는 대부분의 포인터 사용자에게 충분합니다. 또는 더 나은 방법은 각 변수에 대해 다른 명령문을 사용하는 것입니다.

포인터와 배열

배열의 개념은 포인터의 개념과 관련이 있습니다. 실제로 배열은 첫 번째 요소에 대한 포인터와 매우 유사하게 작동하며 실제로 배열은 항상 적절한 유형의 포인터로 암시적으로 변환될 수 있습니다. 예를 들어 다음 두 선언을 고려하십시오.

int myarray [20];
int * mypointer;

다음 할당 작업이 유효합니다.

mypointer = myarray;

그 후, mypointer및 myarray는 동등하고 매우 유사한 속성을 갖습니다. 주요 차이점은 mypointer다른 주소를 할당할 수 있는 반면 myarray아무 것도 할당할 수 없으며 항상 type 의 20개 요소로 구성된 동일한 블록을 나타냅니다 int. 따라서 다음 할당은 유효하지 않습니다.

myarray = mypointer;

배열과 포인터를 혼합하는 예를 살펴보겠습니다.

// more pointers
#include <iostream>
using namespace std;

int main ()
{
  int numbers[5];
  int * p;
  p = numbers;  *p = 10;
  p++;  *p = 20;
  p = &numbers[2];  *p = 30;
  p = numbers + 3;  *p = 40;
  p = numbers;  *(p+4) = 50;
  for (int n=0; n<5; n++)
    cout << numbers[n] << ", ";
  return 0;
}

10, 20, 30, 40, 50,

포인터와 배열은 동일한 작업 집합을 지원하며 둘 다 동일한 의미를 갖습니다. 주요 차이점은 포인터에는 새 주소를 할당할 수 있지만 배열에는 할당할 수 없다는 것입니다.

배열에 대한 장에서 대괄호( [])는 배열 요소의 인덱스를 지정하는 것으로 설명되었습니다. 사실 이 대괄호는 오프셋 연산자 로 알려진 역참조 연산자 입니다. 그들은 뒤따르는 변수를 역참조하는 것처럼 역참조 *하지만 역참조되는 주소에 대괄호 사이의 숫자를 추가하기도 합니다. 예를 들어:

a[5] = 0;       // a [offset of 5] = 0
*(a+5) = 0;     // pointed to by (a+5) = 0

이 두 표현식은 if a가 포인터일 뿐만 ​​아니라 if a가 배열인 경우에도 동일하고 유효합니다. 배열인 경우 해당 이름을 첫 번째 요소에 대한 포인터처럼 사용할 수 있음을 기억하십시오.

포인터 초기화

포인터가 정의되는 바로 그 순간에 특정 위치를 가리키도록 포인터를 초기화할 수 있습니다.

int myvar;
int * myptr = &myvar;

이 코드 이후의 변수의 결과 상태는 다음과 같습니다.

int myvar;
int * myptr;
myptr = &myvar;

포인터가 초기화될 때 초기화되는 것은 포인터가 가리키는 주소(즉, myptr)이며, 결코 값이 가리키지 않습니다(즉, *myptr). 따라서 위의 코드는 다음과 혼동되어서는 안 됩니다.

int myvar;
int * myptr;
*myptr = &myvar;

어쨌든 많은 의미가 없을 것입니다 (그리고 유효한 코드가 아닙니다).

포인터 선언(라인 2) 의 별표( *)는 포인터임을 나타낼 뿐이며, 이는 역참조 연산자(라인 3에서와 같이)가 아닙니다. 두 가지 모두 같은 기호를 사용하기 위해 발생합니다 *. . 항상 그렇듯이 공백은 관련이 없으며 표현의 의미를 변경하지 않습니다.

포인터는 변수의 주소(위의 경우와 같이) 또는 다른 포인터(또는 배열)의 값으로 초기화될 수 있습니다.

int myvar;
int *foo = &myvar;
int *bar = foo;

포인터 산술

포인터에서 산술 연산을 수행하는 것은 일반 정수 유형에서 수행하는 것과 약간 다릅니다. 우선 덧셈과 뺄셈 연산만 허용됩니다. 다른 것들은 포인터의 세계에서 의미가 없습니다. 그러나 더하기와 빼기는 포인터가 가리키는 데이터 유형의 크기에 따라 포인터와 약간 다른 동작을 합니다.

기본 데이터 유형이 도입되었을 때 유형의 크기가 서로 다른 것을 보았습니다. 예를 들어: char항상 1바이트의 크기를 가지며 일반적 short으로 그보다 크며 훨씬 더 큽니다. 이들의 정확한 크기는 시스템에 따라 다릅니다. 예를 들어 주어진 시스템에서 1바이트를 사용하고 2바이트를 사용하고 4를 사용한다고 가정해 보겠습니다.intlongcharshortlong

이제 이 컴파일러에서 세 개의 포인터를 정의한다고 가정합니다.

char *mychar;
short *myshort;
long *mylong;

그리고 우리는 그것들이 각각 메모리 위치 1000, 2000, 를 가리킨다는 것을 알고 3000있습니다.

따라서 다음과 같이 작성하면

++mychar;
++myshort;
++mylong;

mychar, 예상대로 값 1001을 포함합니다. 그러나 명확하지 않은 것은 myshort값 2002를 포함하고 mylong각각이 한 번만 증가했음에도 불구하고 3004를 포함합니다. 그 이유는 포인터에 1을 추가할 때 동일한 유형의 다음 요소를 가리키도록 포인터가 만들어지기 때문에 포인터가 가리키는 유형의 바이트 단위 크기가 포인터에 추가되기 때문입니다.

이것은 포인터에 숫자를 더하거나 뺄 때 모두 적용됩니다. 다음과 같이 작성하면 정확히 동일하게 발생합니다.

mychar = mychar + 1;
myshort = myshort + 1;
mylong = mylong + 1;

증가( ++) 및 감소( --) 연산자와 관련하여 둘 다 식의 접두사 또는 접미사로 사용할 수 있지만 동작에 약간의 차이가 있습니다. 접두사로 증분은 식을 평가하기 전에 발생하고 접미사로, 증분은 표현식이 평가된 후에 발생합니다. *이는 포인터 증가 및 감소 표현식에도 적용되며, 이는 역참조 연산자( ) 도 포함하는 더 복잡한 표현식의 일부가 될 수 있습니다 . 연산자 우선 순위 규칙을 기억하면 증가 및 감소와 같은 후위 연산자가 역참조 연산자( *)와 같은 접두 연산자보다 우선 순위가 높다는 것을 기억할 수 있습니다. 따라서 다음 표현식:

*p++

와 동일합니다 *(p++). 그리고 그것이 하는 일은 p(이제 다음 요소를 가리키도록) 의 값을 높이는 것입니다. 그러나 ++가 접미사로 사용되기 때문에 전체 표현식은 원래 포인터가 가리키는 값으로 평가됩니다(증가되기 전에 가리킨 주소). ).

기본적으로 다음은 증가 연산자의 접두사 및 접미사 버전이 있는 역참조 연산자의 네 가지 가능한 조합입니다(감소 연산자에도 동일하게 적용됨).

*p++   // same as *(p++): increment pointer, and dereference unincremented address
*++p   // same as *(++p): increment pointer, and dereference incremented address
++*p   // same as ++(*p): dereference pointer, and increment the value it points to
(*p)++ // dereference pointer, and post-increment the value it points to 

이러한 연산자와 관련된 일반적이지만 그렇게 간단하지 않은 명령문은 다음과 같습니다.

*p++ = *q++;

 및 모두 ++보다 우선 순위가 높기 때문에 증분 연산자( )는 접두사가 아니라 접미사로 사용되므로 에 할당된 값 은 둘 다 앞에 있고 증분됩니다. 그런 다음 둘 다 증가합니다. 대략 다음과 같습니다.*pq++*p*qpq

*p = *q;
++p;
++q;

항상 그렇듯이 괄호는 표현에 가독성을 더하여 혼동을 줄입니다.

포인터와 const

포인터를 사용하여 해당 주소로 변수에 액세스할 수 있으며 이 액세스에는 가리키는 값 수정이 포함될 수 있습니다. 그러나 포인터 값을 읽기 위해 액세스할 수 있지만 수정할 수는 없는 포인터를 선언하는 것도 가능합니다. 이를 위해서는 포인터가 가리키는 유형을 로 한정하는 것으로 충분합니다 const. 예를 들어:

int x;
int y = 10;
const int * p = &y;
x = *p;          // ok: reading p
*p = x;          // error: modifying p, which is const-qualified

여기 p에서 변수를 가리 키지만 const한정된 방식으로 가리킵니다. 즉, 가리킨 값을 읽을 수는 있지만 수정할 수는 없습니다. 또한 표현식 &y은 type int*이지만 type 의 포인터에 할당됩니다 const int*. 이것은 허용됩니다: 비 const에 대한 포인터는 암시적으로 const에 대한 포인터로 변환될 수 있습니다. 그러나 그 반대는 아닙니다! 안전 기능으로 에 대한 포인터 const는 암시적으로 non- 에 대한 포인터로 변환할 수 없습니다 const.

요소 에 대한 포인터의 사용 사례 중 하나는 const함수 매개변수입니다. 매개변수가 아닌 포인터를 사용 const하는 함수는 인수로 전달된 값을 수정할 수 있지만 포인터를 매개변수로 사용하는 함수는 수정할 const수 없습니다.

// pointers as arguments:
#include <iostream>
using namespace std;

void increment_all (int* start, int* stop)
{
  int * current = start;
  while (current != stop) {
    ++(*current);  // increment value pointed
    ++current;     // increment pointer
  }
}

void print_all (const int* start, const int* stop)
{
  const int * current = start;
  while (current != stop) {
    cout << *current << '\n';
    ++current;     // increment pointer
  }
}

int main ()
{
  int numbers[] = {10,20,30};
  increment_all (numbers,numbers+3);
  print_all (numbers,numbers+3);
  return 0;
}

11
21
31

print_all상수 요소를 가리키는 포인터를 사용합니다 . 이러한 포인터는 수정할 수 없는 상수 내용을 가리키지만 자체적으로는 일정하지 않습니다. 즉, 포인터가 가리키는 내용을 수정할 수는 없지만 포인터는 계속 증가하거나 다른 주소를 할당할 수 있습니다.

그리고 이것은 constness에 대한 두 번째 차원이 포인터에 추가되는 곳입니다. 포인터 자체도 const일 수 있습니다. 그리고 이것은 const를 포인트 타입(별표 뒤)에 추가하여 지정합니다.

int x;
      int *       p1 = &x;  // non-const pointer to non-const int
const int *       p2 = &x;  // non-const pointer to const int
      int * const p3 = &x;  // const pointer to non-const int
const int * const p4 = &x;  // const pointer to const int

및 포인터 의 구문 const은 확실히 까다로우며 각 용도에 가장 적합한 경우를 인식하려면 약간의 경험이 필요한 경향이 있습니다. 어쨌든, 포인터(및 참조)에 대한 일관성을 나중에 보다 빨리 얻는 것이 중요하지만, 포인터와 포인터의 조합에 처음 노출되는 경우 모든 것을 파악하는 것에 대해 너무 걱정할 필요는 없습니다 const. 다음 장에서 더 많은 사용 사례가 나타날 것입니다. with 포인터

의 구문에 약간의 혼란을 더하기 위해 한정자는 정확히 같은 의미로 뾰족한 유형 앞이나 뒤에 올 수 있습니다.

const int * p2a = &x;  //      non-const pointer to const int
int const * p2b = &x;  // also non-const pointer to const int

별표를 둘러싼 공백과 마찬가지로 이 경우 const의 순서는 단순히 스타일의 문제입니다. 이 장에서는 접두사 const를 사용합니다. 역사적 이유로 이것이 더 확장된 것처럼 보이지만 둘 다 정확히 동일합니다. 각 스타일의 장점은 여전히 ​​인터넷에서 치열하게 논의되고 있습니다.

포인터와 문자열 리터럴

앞에서 지적했듯이 문자열 리터럴 은 null로 끝나는 문자 시퀀스를 포함하는 배열입니다. 이전 섹션에서 문자열 리터럴은 에 직접 삽입되어 cout문자열을 초기화하고 문자 배열을 초기화하는 데 사용되었습니다.

그러나 직접 액세스할 수도 있습니다. 문자열 리터럴은 모든 문자와 종료 null 문자를 포함하는 적절한 배열 유형의 배열이며, 각 요소는 유형 const char(리터럴이므로 수정할 수 없음)입니다. 예를 들어:

const char * foo = "hello";

이것은 에 대한 리터럴 표현으로 배열을 선언한 "hello"다음 첫 번째 요소에 대한 포인터가 에 할당됩니다 foo. 그것이 주소 1702에서 시작하는 메모리 위치에 저장되어 있다고 상상 하면 이전 선언을 다음 과 "hello"같이 나타낼 수 있습니다.

여기 foo에 포인터가 있고 값 1702가 포함되어 있습니다. 1702는 실제로 두 주소 모두 이것들. 포인터 는 일련의 문자를 가리킵니다. 포인터와 배열은 표현식에서 본질적으로 같은 방식으로 동작하기 때문에 null로 끝나는 문자 시퀀스의 배열과 같은 방식으로 문자에 액세스하는 데 사용할 수 있습니다. 예를 들어:'h'"hello"

*(foo+4)
foo[4]

두 표현식 모두 'o'(배열의 다섯 번째 요소) 값을 갖습니다.

 

포인터에 대한 포인터

C++에서는 포인터를 가리키는 포인터를 사용할 수 있으며, 이 포인터는 차례로 데이터(또는 다른 포인터도 가리킴)를 가리킵니다. 구문 *에는 포인터 선언의 각 간접 참조 수준에 대해 별표( )가 필요합니다.

char a;
char * b;
char ** c;
a = 'z';
b = &a;
c = &b;

7230이것은 , 8092, 및 의 각 변수에 대해 임의로 선택된 메모리 위치를 10502다음과 같이 나타낼 수 있습니다.

각 변수의 값은 해당 셀 내부에 표시되고 메모리의 해당 주소는 그 아래 값으로 표시됩니다.

이 예제의 새로운 점은 c포인터에 대한 포인터인 variable 이며 세 가지 다른 간접 참조 수준에서 사용할 수 있으며 각각은 다른 값에 해당합니다.

• c유형 char**및 값8092
• *c유형 char*및 값7230
• **c유형 char및 값'z'

void pointer

포인터 의 void유형은 특별한 유형의 포인터입니다. C++에서 void유형이 없음을 나타냅니다. 따라서 void포인터는 유형이 없는 값을 가리키는 포인터입니다.

이것은 void정수 값이나 부동 소수점에서 문자열에 이르기까지 모든 데이터 유형을 가리킬 수 있으므로 포인터에 큰 유연성을 제공합니다. 그 대가로 그것들은 큰 한계가 있습니다: 그들이 가리키는 데이터는 직접 역참조될 수 없으며(역참조할 유형이 없기 때문에 논리적입니다), 그런 이유로 void포인터의 모든 주소는 일부 주소로 변환되어야 합니다. 역참조되기 전에 구체적인 데이터 유형을 가리키는 다른 포인터 유형.

가능한 용도 중 하나는 함수에 일반 매개변수를 전달하는 것일 수 있습니다. 예를 들어:

// increaser
#include <iostream>
using namespace std;

void increase (void* data, int psize)
{
  if ( psize == sizeof(char) )
  { char* pchar; pchar=(char*)data; ++(*pchar); }
  else if (psize == sizeof(int) )
  { int* pint; pint=(int*)data; ++(*pint); }
}

int main ()
{
  char a = 'x';
  int b = 1602;
  increase (&a,sizeof(a));
  increase (&b,sizeof(b));
  cout << a << ", " << b << '\n';
  return 0;
}

예, 1603

sizeof인수의 크기를 바이트 단위로 반환하는 C++ 언어에 통합된 연산자입니다. 비동적 데이터 유형의 경우 이 값은 상수입니다. 따라서 예를 들어 는 항상 1바이트 크기를 sizeof(char)갖기 때문에 1 입니다.char

유효하지 않은 포인터 및 널 포인터

원칙적으로 포인터는 변수의 주소나 배열 요소의 주소와 같은 유효한 주소를 가리킵니다. 그러나 포인터는 유효한 요소를 참조하지 않는 주소를 포함하여 실제로 모든 주소를 가리킬 수 있습니다. 이에 대한 일반적인 예는 초기화되지 않은 포인터 와 배열의 존재하지 않는 요소에 대한 포인터입니다.

int * p;               // uninitialized pointer (local variable)

int myarray[10];
int * q = myarray+20;  // element out of bounds 

p값을 포함하는 것으로 알려진 주소를 가리키 거나 가리키지 않지만 위의 명령문 중 어느 q것도 오류를 일으키지 않습니다. C++에서 포인터는 해당 주소에 실제로 무언가가 있는지 여부에 관계없이 모든 주소 값을 사용할 수 있습니다. 오류를 일으킬 수 있는 것은 그러한 포인터를 역참조하는 것입니다(즉, 실제로 가리키는 값에 액세스하는 경우). 이러한 포인터에 액세스하면 런타임 중 오류에서 임의의 값에 액세스하는 것에 이르기까지 정의되지 않은 동작이 발생합니다.

그러나 때때로 포인터는 유효하지 않은 주소가 아니라 명시적으로 아무데도 가리킬 필요가 없습니다. 그러한 경우, 모든 포인터 유형이 취할 수 있는 특별한 값이 있습니다: null 포인터 값 . 이 값은 두 가지 방법으로 C++에서 표현할 수 있습니다. 정수 값 0 또는nullptr예어:

int * p = 0;
int * q = nullptr;

여기에서 p및 둘 q다 null 포인터 입니다. 즉, 명시적으로 아무 곳도 가리키지 않으며 실제로 둘 다 동일하게 비교됩니다. 모든 null 포인터 는 다른 null 포인터 와 동일하게 비교 됩니다. null 포인터 값 NULL을 참조하기 위해 이전 코드에서 정의된 상수가 사용되는 것을 보는 것도 매우 일반적입니다 .

int * r = NULL;

NULL표준 라이브러리의 여러 헤더에 정의되어 있으며 일부 null 포인터 상수 값(예: 0또는 nullptr)의 별칭으로 정의됩니다. 널 포인터 와 포인터를

혼동하지 마십시오 ! 널 포인터 는 포인터가 "아무데도"를 가리키고 있음을 나타내기 위해 취할 수 있는 값이고, 포인터 는 특정 유형 없이 어딘가를 가리킬 수 있는 포인터 유형입니다. 하나는 포인터에 저장된 값을 참조하고 다른 하나는 포인터가 가리키는 데이터 유형을 나타냅니다.voidvoid

함수에 대한 포인터

C++에서는 함수에 대한 포인터를 사용하여 작업을 수행할 수 있습니다. 이것의 일반적인 용도는 함수를 다른 함수에 대한 인수로 전달하는 것입니다. 함수에 대한 포인터는 일반 함수 선언과 동일한 구문으로 선언됩니다. 단, 함수 이름은 괄호()로 묶이고 *이름 앞에 별표( )가 삽입됩니다.

// pointer to functions
#include <iostream>
using namespace std;

int addition (int a, int b)
{ return (a+b); }

int subtraction (int a, int b)
{ return (a-b); }

int operation (int x, int y, int (*functocall)(int,int))
{
  int g;
  g = (*functocall)(x,y);
  return (g);
}

int main ()
{
  int m,n;
  int (*minus)(int,int) = subtraction;

  m = operation (7, 5, addition);
  n = operation (20, m, minus);
  cout <<n;
  return 0;
}

8

위의 예에서 minus는 유형의 매개변수가 두 개 있는 함수에 대한 포인터입니다 int. 함수를 가리키도록 직접 초기화됩니다 subtraction.

int (* minus)(int,int) = subtraction;