C++ 포인터 처음 배우기: &와 * 연산자, swap·배열 순회, 초보자가 하는 첫 실수
이 글의 핵심
포인터가 어렵게 느껴지는 이유는 변수의 값과 변수의 위치라는 두 가지를 동시에 생각해야 하기 때문입니다. 선언할 때의 *와 사용할 때의 *가 다른 뜻이라는 점을 먼저 정리하고, 함수에서 원본 값을 바꾸거나 큰 데이터를 복사 없이 넘길 때 포인터가 왜 필요한지, 참조와 비교해 언제 무엇을 쓰면 되는지까지 초보자 눈높이로 설명합니다.
포인터를 집 주소로 이해하기
비유: 포인터는 “집 주소”와 같습니다.
변수 = 집 (실제 데이터가 있는 곳)
포인터 = 집 주소 (집이 어디 있는지 알려주는 정보)이 비유에서 중요한 점은 주소를 적은 쪽지도 어딘가에 보관되어 있다는 것입니다. 포인터 역시 변수이므로 자기만의 메모리 공간을 차지하고(64비트 환경에서 보통 8바이트), 그 공간에 “다른 변수의 주소”라는 숫자를 담습니다. 포인터를 처음 배울 때 헷갈리는 이유는 대부분 “포인터 변수 자체의 값(주소)“과 “그 주소에 있는 값”을 한 번에 생각해야 하기 때문입니다. 아래 예제에서 이 두 가지를 계속 구분해 보겠습니다.
또 하나, 쪽지에 적힌 주소가 여전히 유효한 집인지는 쪽지가 알려 주지 않습니다. 집이 철거되어도 쪽지의 주소는 그대로 남아 있습니다. 포인터 관련 버그의 대부분은 이 한 문장으로 설명됩니다.
기본 개념
변수와 주소
int age = 25; // 변수: 값을 저장
int* ptr = &age; // 포인터: 주소를 저장
// &age: age 변수의 주소를 가져옴
// ptr: age의 주소를 저장하는 포인터그림으로 이해:
메모리 주소 변수명 값
0x1000 age 25
0x2000 ptr 0x1000 (age의 주소)그림의 주소는 설명용 숫자이고, 실제로 출력해 보면 0x7ffd5e3c처럼 훨씬 큰 값이 나옵니다. 실행할 때마다 주소가 바뀌는 것도 정상입니다. 운영체제가 보안을 위해 스택과 힙의 시작 위치를 무작위로 배치(ASLR)하기 때문입니다. 그래서 “주소 값 자체”를 파일에 저장했다가 다음 실행에서 다시 쓰는 것은 의미가 없습니다.
int* ptr의 int는 “이 주소에 int가 있다”는 정보입니다. 주소는 숫자일 뿐이라서, 그 위치에 무엇이 있는지 알아야 몇 바이트를 어떻게 읽을지 정할 수 있습니다. 그래서 double 변수의 주소를 int*에 담으려고 하면 cannot convert 'double*' to 'int*' 컴파일 에러가 납니다.
포인터 선언
int* ptr; // int를 가리키는 포인터
double* ptr2; // double을 가리키는 포인터
char* ptr3; // char를 가리키는 포인터
// * 위치는 상관없음 (스타일 차이)
int *ptr; // 같은 의미
int * ptr; // 같은 의미*의 위치가 문법적으로는 상관없지만, 한 줄에 여러 변수를 선언할 때는 결과가 달라집니다. int* a, b;는 a와 b가 모두 포인터처럼 보이지만, 실제로 *는 바로 뒤의 변수 하나에만 붙기 때문에 a는 int*, b는 그냥 int입니다. 이 때문에 C 계열에서는 int *a, *b;처럼 *를 변수 이름에 붙여 쓰는 스타일도 많습니다. 가장 안전한 방법은 포인터는 한 줄에 하나씩 선언하는 것입니다.
그리고 *가 선언문에서는 “이 변수는 포인터다”라는 뜻이고, 식에서는 “이 주소가 가리키는 값”(역참조)이라는 뜻이라는 점을 꼭 구분해야 합니다. 같은 기호가 두 가지 역할을 하는 것이 포인터를 처음 배울 때 가장 큰 혼란의 원인입니다. &도 마찬가지로 식에서는 주소 연산자, 선언문에서는 참조(int& ref)를 뜻합니다.
주소 연산자 (&)
int x = 10;
int* ptr = &x; // x의 주소를 ptr에 저장
std::cout << x; // 10 (값)
std::cout << &x; // 0x7fff... (주소)
std::cout << ptr; // 0x7fff... (주소, &x와 같음)역참조 연산자 (*)
int x = 10;
int* ptr = &x;
std::cout << *ptr; // 10 (ptr이 가리키는 값)
*ptr = 20; // ptr이 가리키는 곳의 값을 20으로 변경
std::cout << x; // 20 (x가 변경됨!)이 예제가 포인터의 핵심입니다. *ptr = 20은 ptr을 바꾸는 것이 아니라 ptr에 적힌 주소로 찾아가서 그곳의 값을 바꿉니다. 그곳이 바로 x이므로 x를 직접 건드리지 않았는데도 x가 20이 됩니다. 같은 메모리를 가리키는 이름이 두 개(x와 *ptr) 생긴 셈입니다. 이 성질 덕분에 함수가 호출한 쪽의 변수를 바꿀 수 있고, 반대로 이 성질 때문에 “누가 이 값을 바꿨는지” 추적하기 어려워지기도 합니다.
실전 예제
예제 1: 값 교환 (Swap)
// ❌ 잘못된 방법 (값 복사)
void swap_wrong(int a, int b) {
int temp = a;
a = b;
b = temp;
// 함수 끝나면 a, b는 원래대로!
}
// ✅ 올바른 방법 (포인터 사용)
void swap(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
int main() {
int x = 10, y = 20;
swap_wrong(x, y);
std::cout << x << ", " << y; // 10, 20 (변경 안 됨)
swap(&x, &y);
std::cout << x << ", " << y; // 20, 10 (변경됨!)
}swap_wrong이 실패하는 이유는 C++의 함수 인자가 기본적으로 값으로 복사되어 전달되기 때문입니다. a와 b는 x, y의 복사본이라서 함수 안에서 아무리 바꿔도 원본과는 관계가 없고, 함수가 끝나면 복사본은 사라집니다. swap은 값 대신 주소를 복사해서 넘깁니다. 주소가 복사되어도 가리키는 곳은 같으므로, *a와 *b로 원본을 직접 바꿀 수 있습니다.
실무 C++에서는 같은 일을 참조로 void swap(int& a, int& b)처럼 쓰고, 호출도 swap(x, y)로 더 깔끔합니다. 표준 라이브러리의 std::swap도 참조 방식입니다. 그런데 포인터 버전을 먼저 이해해 두면 참조가 “자동으로 역참조되는 포인터”처럼 동작한다는 점이 자연스럽게 이해됩니다. 참고로 함수 이름을 swap으로 짓고 using namespace std;를 쓰면 std::swap과 이름이 겹쳐 의도와 다른 함수가 호출되거나 모호성 에러가 날 수 있으니, 연습용 함수는 my_swap처럼 이름을 다르게 두는 편이 안전합니다.
예제 2: 배열과 포인터
int arr[5] = {1, 2, 3, 4, 5};
int* ptr = arr; // 배열 이름은 첫 번째 요소의 주소
std::cout << *ptr; // 1 (첫 번째 요소)
std::cout << *(ptr+1); // 2 (두 번째 요소)
std::cout << ptr[2]; // 3 (세 번째 요소)정확히 말하면 배열 이름이 곧 주소인 것은 아니고, 배열이 대부분의 식에서 첫 번째 요소의 주소로 자동 변환(decay)됩니다. 차이가 드러나는 대표적인 곳이 sizeof입니다. sizeof(arr)는 배열 전체 크기인 20(4바이트 × 5)이지만, sizeof(ptr)는 포인터 크기인 8입니다. 배열을 함수 매개변수로 넘기면 포인터로 바뀌기 때문에, 함수 안에서 sizeof(arr) / sizeof(arr[0])로 개수를 구하려 하면 엉뚱한 값(8 / 4 = 2)이 나옵니다. 초보자가 가장 많이 겪는 배열 버그 중 하나이며, 그래서 C++에서는 std::array나 std::vector, 또는 C++20의 std::span을 쓰는 것이 권장됩니다.
ptr[2]가 *(ptr + 2)와 같다는 것도 알아 두면 좋습니다. 대괄호 연산은 사실 포인터 산술의 줄임말입니다. 그리고 포인터는 배열이 몇 칸인지 모르기 때문에 ptr[10]처럼 범위를 벗어나도 컴파일러가 막아 주지 않습니다. 이 경우는 미정의 동작으로, 옆 변수의 값을 읽거나 덮어쓰는 조용한 버그가 되기 쉽습니다.
자주 하는 실수
실수 1: 초기화하지 않은 포인터
// ❌ 위험한 코드
int* ptr;
*ptr = 10; // 어디를 가리키는지 모름! (미정의 동작: 크래시할 수도, 조용히 다른 메모리를 덮어쓸 수도)
// ✅ 올바른 코드
int* ptr = nullptr; // 아무것도 가리키지 않음
// 또는
int x;
int* ptr = &x; // x를 가리킴함수 안의 지역 변수는 초기화하지 않으면 그 메모리에 원래 남아 있던 값을 그대로 갖습니다. 포인터라면 그 값이 임의의 주소가 되는데, 운이 좋으면 접근할 수 없는 주소라 즉시 Segmentation fault로 죽고, 운이 나쁘면 프로그램의 다른 변수를 가리켜서 조용히 데이터를 망가뜨립니다. 두 번째 경우가 훨씬 위험합니다. 크래시는 원인 근처에서 나지만, 데이터 오염은 한참 뒤 전혀 다른 곳에서 이상한 값으로 드러나기 때문입니다.
nullptr로 초기화하는 이유는 “잘못 쓰면 확실하게 죽게” 만들기 위해서입니다. 널 포인터를 역참조하면 대부분의 환경에서 즉시 크래시가 나므로 디버거로 원인을 바로 찾을 수 있습니다. 컴파일러 경고를 켜 두는 것도 큰 도움이 됩니다. GCC/Clang의 -Wall -Wextra는 초기화하지 않은 변수 사용을 warning: 'ptr' is used uninitialized 같은 경고로 알려 줍니다.
실수 2: 포인터와 값 혼동
int x = 10;
int* ptr = &x;
// ❌ 잘못된 코드
ptr = 20; // 컴파일 에러! (주소에 값을 대입)
// ✅ 올바른 코드
*ptr = 20; // ptr이 가리키는 값을 20으로 변경ptr = 20;은 GCC 기준 error: invalid conversion from 'int' to 'int*' 에러가 납니다. 정수를 주소로 바로 쓸 수 없게 막아 주는 것이니 오히려 고마운 에러입니다. 반대 방향 실수는 에러 없이 통과해서 더 까다롭습니다. 예를 들어 두 포인터를 비교하면서 if (p1 == p2)라고 쓰면 가리키는 값이 같은지가 아니라 같은 주소를 가리키는지를 비교합니다. 값을 비교하려면 if (*p1 == *p2)여야 합니다. C 스타일 문자열(const char*)을 ==로 비교했는데 내용이 같아도 false가 나오는 것도 같은 이유입니다.
실수 3: 댕글링 포인터
// ❌ 위험한 코드
int* ptr;
{
int x = 10;
ptr = &x;
} // x가 사라짐
*ptr = 20; // 사라진 변수 접근! (미정의 동작)
// ✅ 올바른 코드
int* ptr = new int(10); // 동적 할당
*ptr = 20;
delete ptr; // 사용 후 해제댕글링(dangling) 포인터는 “이미 사라진 집의 주소가 적힌 쪽지”입니다. 이 코드가 특히 까다로운 이유는 대개 크래시가 나지 않는다는 점입니다. x가 있던 스택 메모리는 해제되어도 운영체제에 반환되는 것이 아니라 다음 함수 호출이 재사용할 뿐이라서, *ptr = 20은 대부분 아무 문제 없이 실행되는 것처럼 보입니다. 그러다 나중에 다른 함수가 그 자리를 쓰면서 값이 바뀌거나, 반대로 이 대입이 다른 함수의 지역 변수를 덮어씁니다.
“올바른 코드”의 핵심은 new 자체가 아니라 값이 필요한 동안 살아 있는 곳에 두는 것입니다. 이 예제라면 x를 블록 밖에 선언하는 것이 가장 간단한 해결책입니다. new로 할당하면 수명이 스코프와 무관해지지만, 대신 delete를 직접 책임져야 한다는 새 문제가 생깁니다. 댕글링 포인터가 실무에서 가장 흔하게 나오는 형태는 함수가 지역 변수의 주소를 반환하는 경우(int* f() { int x = 1; return &x; })입니다. 컴파일러가 warning: address of local variable 'x' returned로 경고해 주므로 경고를 절대 무시하지 않는 것이 좋습니다.
제가 처음 C++를 배울 때 가장 오래 헤맨 버그도 이 유형이었습니다. std::vector에 원소를 넣고 그 원소의 주소를 포인터로 저장해 둔 뒤, 벡터에 원소를 더 추가했더니 저장한 포인터가 엉뚱한 값을 가리키기 시작했습니다. 벡터가 공간이 부족해지면 더 큰 메모리로 통째로 이사하면서 옛 주소가 무효가 되기 때문입니다. 지역 변수가 사라지는 경우만 조심하면 된다고 생각하기 쉽지만, 컨테이너 안의 원소도 언제든 “철거”될 수 있다는 점을 기억해야 합니다.
포인터 vs 참조자
// 포인터
int x = 10;
int* ptr = &x;
*ptr = 20; // 역참조 필요
// 참조자 (더 쉬움)
int& ref = x;
ref = 20; // 역참조 불필요권장: 초보자는 참조자부터 배우는 것이 좋습니다.
참조는 “이미 있는 변수의 또 다른 이름”입니다. 포인터와 비교하면 세 가지가 다릅니다. 참조는 선언할 때 반드시 초기화해야 하고(int& ref;는 컴파일 에러), 한 번 정해지면 다른 변수를 가리키도록 바꿀 수 없으며, 정상적인 코드에서는 널이 될 수 없습니다. 이 제약 덕분에 참조를 받는 함수는 “값이 없을 수도 있다”를 걱정하지 않아도 됩니다.
반대로 포인터가 필요한 경우는 이 제약이 방해가 될 때입니다. “없음”을 표현해야 할 때(nullptr), 가리키는 대상을 도중에 바꿔야 할 때(연결 리스트의 next), 배열을 순회하며 주소를 옮겨 가야 할 때입니다. 함수 매개변수라면 “반드시 있는 값”은 참조, “없을 수도 있는 값”은 포인터로 받는다는 규칙이 실무에서도 널리 쓰입니다.
동적 메모리 할당
new와 delete
// 단일 변수 할당
int* ptr = new int; // 메모리 할당
*ptr = 10; // 값 저장
delete ptr; // 메모리 해제
// 초기값과 함께 할당
int* ptr2 = new int(25);
delete ptr2;
// 배열 할당
int* arr = new int[100]; // 100개 정수 배열
arr[0] = 1;
delete[] arr; // 배열 해제 ([] 필수!)지역 변수는 스택에 만들어져 함수가 끝나면 자동으로 사라지지만, new로 만든 값은 힙에 만들어져 delete를 호출할 때까지 남아 있습니다. 함수가 끝난 뒤에도 값이 살아 있어야 하거나, 실행 중에야 크기를 알 수 있을 때 힙을 씁니다.
new와 delete, new[]와 delete[]는 반드시 짝을 맞춰야 합니다. new int[100]으로 만든 배열을 delete arr로 지우면 미정의 동작입니다. int처럼 단순한 타입에서는 겉보기에 문제가 없을 수 있지만, 소멸자가 있는 클래스 배열이라면 첫 번째 원소의 소멸자만 호출되거나 힙이 손상되어 나중에 free(): invalid pointer 같은 에러로 죽습니다. new int;처럼 괄호 없이 할당하면 값이 초기화되지 않는다는 점도 주의해야 합니다. new int()나 new int{}는 0으로 초기화됩니다.
메모리 누수 주의
// ❌ 메모리 누수
void leak() {
int* ptr = new int(10);
// delete 안 함!
} // ptr 사라지지만 메모리는 남음
// ✅ 올바른 코드
void no_leak() {
int* ptr = new int(10);
// ... 사용 ...
delete ptr; // 반드시 해제
}no_leak도 사실 완벽하지 않습니다. // ... 사용 ... 부분에서 return으로 일찍 빠져나가거나 예외가 발생하면 delete까지 도달하지 못해 똑같이 누수가 생깁니다. 함수가 길어지고 분기가 많아질수록 모든 경로에 delete를 챙기기는 사실상 불가능합니다. 그래서 모던 C++에서는 new/delete를 직접 쓰지 않고 std::unique_ptr(아래 FAQ 참고)나 std::vector처럼 스코프를 벗어나면 자동으로 해제하는 객체에 맡깁니다. 이 원칙을 RAII라고 부릅니다.
누수는 짧게 실행되고 끝나는 프로그램에서는 운영체제가 종료 시 메모리를 회수하므로 티가 나지 않습니다. 문제가 되는 것은 서버나 게임처럼 오래 도는 프로그램인데, 반복문 안에서 조금씩 새는 메모리가 몇 시간에 걸쳐 쌓이다 결국 메모리 부족으로 종료됩니다. 컴파일할 때 -fsanitize=address를 붙이면 프로그램 종료 시 누수된 할당 위치를 알려 줍니다.
포인터 산술 연산
int arr[5] = {10, 20, 30, 40, 50};
int* ptr = arr;
std::cout << *ptr; // 10
std::cout << *(ptr+1); // 20
std::cout << *(ptr+2); // 30
// 포인터 증가
ptr++;
std::cout << *ptr; // 20
// 배열처럼 사용
ptr[0]; // 20
ptr[1]; // 30ptr + 1은 주소에 1을 더하는 것이 아니라 가리키는 타입 한 칸만큼 이동합니다. int가 4바이트라면 주소는 실제로 4만큼 커집니다. 포인터에 타입이 붙어 있는 또 하나의 이유가 이것입니다. double*이라면 8바이트씩, char*라면 1바이트씩 움직입니다.
포인터 산술은 같은 배열 안에서만 의미가 있습니다. 배열의 끝 바로 다음 위치(arr + 5)까지는 가리켜도 되지만 역참조하면 안 되고, 그보다 더 나가거나 배열 앞으로 벗어나면 가리키는 것만으로도 미정의 동작입니다. 위 코드에서 ptr++ 이후 ptr[0]이 20인 것처럼, 포인터를 옮기면 인덱스의 기준도 함께 옮겨진다는 점도 헷갈리기 쉬운 부분입니다. 실무에서는 포인터를 직접 증가시키기보다 인덱스나 범위 기반 for를 쓰는 편이 실수가 적습니다.
포인터를 쓰는 이유
함수에서 값 변경
void increment(int* num) {
(*num)++;
}
int main() {
int x = 10;
increment(&x);
std::cout << x; // 11 (변경됨)
}대용량 데이터 전달
// ❌ 비효율적 (복사)
void process(std::vector<int> data) { // 전체 복사!
// ...
}
// ✅ 효율적 (포인터 또는 참조)
void process(std::vector<int>* data) { // 주소만 전달
// ...
}
// ✅ 더 좋은 방법 (참조)
void process(const std::vector<int>& data) { // 참조 (권장)
// ...
}원소 100만 개짜리 벡터를 값으로 넘기면 호출할 때마다 약 4MB를 새로 할당하고 복사합니다. 포인터나 참조는 주소 하나(8바이트)만 넘기므로 크기와 관계없이 비용이 같습니다. 참조 버전을 권장하는 이유는 const를 붙여 “읽기만 하겠다”는 약속을 타입에 표시할 수 있고, 널 체크가 필요 없으며, 호출할 때 process(v)처럼 &를 붙이지 않아도 되기 때문입니다. 포인터 버전은 nullptr이 들어올 수 있으므로 함수 안에서 매번 확인해야 합니다. 참고로 int, double 같은 작은 기본 타입은 값으로 넘기는 것이 오히려 빠르거나 같으므로 참조로 바꿀 필요가 없습니다.
동적 크기 배열
int n;
std::cin >> n;
// 컴파일 타임에 크기를 모름
int* arr = new int[n]; // 런타임에 크기 결정
// ... 사용 ...
delete[] arr;C++ 표준에서 int arr[n];처럼 실행 중에 정해지는 크기로 배열을 선언하는 것(VLA)은 허용되지 않습니다. GCC는 확장 기능으로 컴파일해 주지만 MSVC에서는 error C2131: expression did not evaluate to a constant가 나고, 스택에 큰 배열을 만들다 스택 오버플로를 일으키기도 쉽습니다. 이 예제가 new int[n]을 쓰는 이유입니다. 다만 실제 코드에서는 std::vector<int> arr(n); 한 줄이 같은 일을 하면서 delete[]도, 크기 추적도 알아서 해 주므로 이것을 쓰는 것이 정답입니다.
FAQ
Q1: 포인터는 왜 어렵다고 하나요?
A: 개념은 간단하지만, 실수하면 크래시가 나기 때문입니다.
어려운 이유:
- 초기화 안 하면 크래시
- delete 안 하면 메모리 누수
- 이중 delete하면 크래시
- 사라진 변수 접근하면 크래시
해결법: 모던 C++의 스마트 포인터 사용
#include <memory>
std::unique_ptr<int> ptr = std::make_unique<int>(10);
// 자동으로 delete됨 (안전!)Q2: nullptr은 무엇인가요?
A: “아무것도 가리키지 않음”을 나타내는 특수한 값입니다.
int* ptr = nullptr; // 아무것도 가리키지 않음
if (ptr == nullptr) {
std::cout << "포인터가 비어있음" << std::endl;
}
// 사용 전 체크 (안전)
if (ptr != nullptr) {
*ptr = 10; // 안전하게 사용
}주의: NULL(구식) 대신 nullptr(C++11) 사용 권장
Q3: 포인터와 배열의 관계는?
A: 배열 이름은 첫 번째 요소의 주소입니다.
int arr[5] = {1, 2, 3, 4, 5};
// 배열 이름 = 첫 번째 요소의 주소
int* ptr = arr; // &arr[0]과 같음
// 동일한 표현
arr[2]; // 3
ptr[2]; // 3
*(arr+2); // 3
*(ptr+2); // 3Q4: 이중 포인터는 무엇인가요?
A: 포인터를 가리키는 포인터입니다.
int x = 10;
int* ptr = &x; // x의 주소
int** ptr2 = &ptr; // ptr의 주소
std::cout << x; // 10
std::cout << *ptr; // 10
std::cout << **ptr2; // 10
// ptr2 → ptr → x사용 시기:
- 2차원 배열 동적 할당
- 함수에서 포인터 값 변경
- 고급 자료구조 (트리, 그래프)
Q5: 포인터 없이 C++를 배울 수 있나요?
A: 모던 C++에서는 가능합니다!
포인터 대신 사용:
// 포인터 (구식)
int* ptr = new int(10);
delete ptr;
// 스마트 포인터 (모던)
auto ptr = std::make_unique<int>(10);
// 자동 해제
// 참조자 (더 쉬움)
int x = 10;
int& ref = x;
ref = 20; // 간단!권장 학습 순서:
- 참조자 먼저 배우기
- 스마트 포인터 배우기
- 포인터는 나중에 (필요할 때)
Q6: 포인터는 언제 꼭 써야 하나요?
A: 다음 경우에 필요합니다.
필수 사용:
- C 라이브러리 사용 (OpenGL, SDL 등)
- 시스템 프로그래밍
- 임베디드 개발
- 레거시 코드 유지보수
대안 가능:
- 일반 애플리케이션: 참조자, 스마트 포인터
- 게임 개발: 대부분 스마트 포인터
- 웹 서버: 참조자로 충분
결론: 모던 C++에서는 raw 포인터를 직접 쓸 일이 많이 줄었습니다.
심화: const 포인터 vs 포인터를 통한 const (실무에서 자주 헷갈림)
int x = 1;
const int* p1 = &x; // 가리키는 int가 const (p1로 값 변경 불가)
int* const p2 = &x; // 포인터 자체가 const (다른 주소로 못 바꿈)
const int* const p3 = &x; // 둘 다 const읽는 팁: 선언에서 const가 *의 앞에 있으면 “가리키는 값”, 뒤에 있으면 “포인터 자체”로 외우는 팀도 많습니다.
심화: void*·정렬·uintptr_t
C API와 맞닿을 때 void*가 나옵니다. C++에서는 역참조 전에 올바른 타입으로 static_cast 하며, 주소를 정수로 다룰 때는 uintptr_t (<cstdint>)를 씁니다.
#include <new>
alignas(int) std::byte buffer[64]; // int 정렬을 보장해야 함
auto* p = new (buffer) int(42); // placement new: 이미 있는 메모리에 객체 생성
// 잘못된 예: 임의 주소를 int*로만 캐스팅하면 정렬·alias 규칙 위반 가능std::byte 배열은 정렬이 1바이트라서 alignas(int) 없이 int를 생성하면 정렬되지 않은 주소에 객체가 놓일 수 있습니다. x86에서는 대개 느려질 뿐이지만, 일부 ARM 환경에서는 정렬 오류로 프로그램이 종료됩니다. void*를 받는 C API 콜백(qsort의 비교 함수, 스레드 시작 함수의 void* arg)에서도 같은 원칙이 적용됩니다. 넘길 때의 원래 타입으로 정확히 되돌려서 써야 하며, 다른 타입으로 해석하면 컴파일러가 막아 주지 않습니다.
성능: 포인터 역참조 자체는 보통 한두 사이클 수준이지만, 캐시 미스·가상 호출·동기화가 지배적인 경우가 많습니다. “포인터가 느리다”기보다 메모리 접근 패턴을 먼저 의심하세요.
심화: 디버깅 가이드 (GDB·Sanitizer)
| 상황 | 도구 |
|---|---|
| 랜덤 크래시 | AddressSanitizer (-fsanitize=address) |
| 힙 손상 의심 | ASan + -fsanitize=undefined (일부 환경) |
| 누수 | LeakSanitizer(ASan에 포함), Valgrind |
| “어디서 깨졌는지” | GDB watch on *ptr, bt |
// GDB: 포인터가 유효한 객체를 가리키는지 의심될 때
// print ptr
// x/4wx ptr (메모리 덤프, 주의: 유효하지 않으면 세그폴트)심화: 흔한 실수 패턴 (추가)
| 패턴 | 왜 위험한가 | 대안 |
|---|---|---|
이중 delete | 미정의 동작 | delete 후 nullptr 대입 또는 스마트 포인터 |
vector 재할당 후 옛 반복자 | 무효화 | 인덱스·reserve로 범위 고정 |
reinterpret_cast 남용 | strict aliasing 위반 | std::bit_cast(C++20) 또는 설계 변경 |
| C 스타일 가변 인자 + 포인터 | 타입 불일치 | 모던 API로 교체 |
심화: 실전 미니 예제 — 연결 리스트 노드 (교육용)
struct Node {
int value{};
Node* next{nullptr};
};
void push_front(Node*& head, int v) {
auto* n = new Node{v, head};
head = n;
}
void free_list(Node* head) {
while (head) {
Node* next = head->next;
delete head;
head = next;
}
}실무에서는 std::unique_ptr
같이 보면 좋은 글
- C++ 스택 vs 힙 | 재귀에서 프로그램이 죽는 이유와 스택 오버플로우 사례
- C++ 관찰 포인터: 소유하지 않는 참조를 원시 포인터·weak_ptr로 표현하는 기준
- C++ 함수 처음 만들기
- C++ 클래스와 객체