C++ const 완벽 가이드 | 'const 정확성' 실전 활용

const 변수

const는 “변경 불가”를 표현해 코드 리뷰에서도 권장됩니다. mutable과 함께 쓰면 캐시·락 등 예외적으로 수정 가능한 멤버를 둘 수 있고, 함수 기초·스마트 포인터와 조합해 읽기 전용 인터페이스를 만들 수 있습니다.

const int x = 10;
// x = 20;  // 에러: const 변수는 수정 불가

const int y;  // 에러: const는 선언 시 초기화 필수

const 함수

class Point {
private:
    int x, y;
    
public:
    Point(int x, int y) : x(x), y(y) {}
    
    // const 멤버 함수 (객체 상태 변경 안함)
    int getX() const { return x; }
    int getY() const { return y; }
    
    // non-const 멤버 함수
    void setX(int newX) { x = newX; }
};

int main() {
    const Point p(10, 20);
    cout << p.getX() << endl;  // OK
    // p.setX(30);  // 에러: const 객체는 non-const 함수 호출 불가
}

const 포인터

const 포인터 패턴

선언	포인터 수정	값 수정	읽는 법
const int* ptr	✅	❌	“포인터 to const int”
int* const ptr	❌	✅	“const 포인터 to int”
const int* const ptr	❌	❌	“const 포인터 to const int”
int const* ptr	✅	❌	const int*와 동일

C/C++ 예제 코드입니다.

int x = 10;
int y = 20;

// 1. 포인터가 가리키는 값이 const
const int* ptr1 = &x;
// *ptr1 = 20;  // 에러
ptr1 = &y;  // OK

// 2. 포인터 자체가 const
int* const ptr2 = &x;
*ptr2 = 20;  // OK
// ptr2 = &y;  // 에러

// 3. 둘 다 const
const int* const ptr3 = &x;
// *ptr3 = 20;  // 에러
// ptr3 = &y;  // 에러

외우는 법: const를 기준으로 오른쪽이 const

const 포인터 시각화

다음은 mermaid 예제 코드입니다.

graph TD
    A[const int* ptr] --> B[ptr 변경 가능]
    A --> C[*ptr 변경 불가]
    
    D[int* const ptr] --> E[ptr 변경 불가]
    D --> F[*ptr 변경 가능]
    
    G[const int* const ptr] --> H[ptr 변경 불가]
    G --> I[*ptr 변경 불가]

const 참조

void process(const vector<int>& v) {
    // v를 읽기만 함 (복사 없음)
    for (int x : v) {
        cout << x << " ";
    }
    // v.push_back(10);  // 에러
}

int main() {
    vector<int> data = {1, 2, 3};
    process(data);  // 복사 없이 전달
}

mutable

mutable 사용 시나리오

시나리오	예시	이유
캐싱	계산 결과 저장	논리적으로 const, 물리적으로 변경
통계	접근 횟수 카운트	관찰만 하는 동작
동기화	mutable mutex	락은 논리적 상태 아님
지연 초기화	첫 접근 시 초기화	읽기 동작이지만 내부 변경

class Cache {
private:
    mutable int accessCount;  // const 함수에서도 수정 가능
    int value;
    
public:
    Cache(int v) : value(v), accessCount(0) {}
    
    int getValue() const {
        accessCount++;  // OK: mutable
        return value;
    }
    
    int getAccessCount() const {
        return accessCount;
    }
};

int main() {
    const Cache cache(42);
    cout << cache.getValue() << endl;  // accessCount 증가
    cout << cache.getAccessCount() << endl;  // 1
}

실전 예시

예시 1: const 정확성

class String {
private:
    char* data;
    size_t length;
    
public:
    String(const char* str) {
        length = strlen(str);
        data = new char[length + 1];
        strcpy(data, str);
    }
    
    ~String() {
        delete[] data;
    }
    
    // const 버전
    const char* c_str() const {
        return data;
    }
    
    // non-const 버전
    char* c_str() {
        return data;
    }
    
    size_t size() const {
        return length;
    }
};

void print(const String& s) {
    cout << s.c_str() << endl;  // const 버전 호출
}

예시 2: const와 반복자

#include <vector>
using namespace std;

void process(const vector<int>& v) {
    // const_iterator 사용
    for (vector<int>::const_iterator it = v.begin(); 
         it != v.end(); ++it) {
        cout << *it << " ";
        // *it = 10;  // 에러
    }
    
    // 또는 auto 사용
    for (auto it = v.cbegin(); it != v.cend(); ++it) {
        cout << *it << " ";
    }
}

예시 3: const와 스레드 안전성

#include <mutex>

class ThreadSafeCounter {
private:
    mutable mutex mtx;  // const 함수에서도 lock 가능
    int count;
    
public:
    ThreadSafeCounter() : count(0) {}
    
    void increment() {
        lock_guard<mutex> lock(mtx);
        count++;
    }
    
    int getCount() const {
        lock_guard<mutex> lock(mtx);  // OK: mutable
        return count;
    }
};

자주 발생하는 문제

문제 1: const 함수에서 멤버 수정

// ❌ 에러
class Bad {
private:
    int x;
    
public:
    void func() const {
        x = 10;  // 에러!
    }
};

// ✅ mutable 사용
class Good {
private:
    mutable int x;
    
public:
    void func() const {
        x = 10;  // OK
    }
};

문제 2: const 오버로딩

class Container {
private:
    int data[10];
    
public:
    // const 버전
    const int& operator const {
        return data[index];
    }
    
    // non-const 버전
    int& operator {
        return data[index];
    }
};

int main() {
    Container c;
    c[0] = 10;  // non-const 버전
    
    const Container cc;
    int x = cc[0];  // const 버전
    // cc[0] = 10;  // 에러
}

문제 3: const_cast

legacyFunction 함수의 구현 예제입니다.

void legacyFunction(char* str) {
    // 레거시 함수 (const 없음)
}

void modernFunction(const char* str) {
    // const_cast로 const 제거 (위험!)
    legacyFunction(const_cast<char*>(str));
}

// ✅ 더 나은 방법: 래퍼 함수
void safeWrapper(const char* str) {
    char* temp = new char[strlen(str) + 1];
    strcpy(temp, str);
    legacyFunction(temp);
    delete[] temp;
}

const 정확성 체크리스트

1. 함수 매개변수

// ❌ 불필요한 복사
void process(vector<int> v) { }

// ✅ const 참조
void process(const vector<int>& v) { }

2. 멤버 함수

class MyClass {
public:
    // ❌ const 누락
    int getValue() { return value; }
    
    // ✅ const 추가
    int getValue() const { return value; }
};

3. 반환 타입

class String {
public:
    // ❌ 내부 데이터 노출
    char* getData() { return data; }
    
    // ✅ const 반환
    const char* getData() const { return data; }
};

컴파일러 최적화

compute 함수의 구현 예제입니다.

// const는 컴파일러 최적화에 도움
void compute(const int* data, int size) {
    // 컴파일러가 data가 변하지 않음을 알고 최적화
    for (int i = 0; i < size; i++) {
        // ...
    }
}

FAQ

Q1: const를 왜 사용하나요?

A:

• 의도 명확화 (이 값은 변하지 않음)
• 버그 방지 (실수로 수정 불가)
• 컴파일러 최적화
• 인터페이스 안전성

Q2: const를 어디에 붙여야 하나요?

A:

• 변하지 않는 변수
• 객체를 수정하지 않는 멤버 함수
• 복사를 피하려는 함수 매개변수

Q3: mutable은 언제 사용하나요?

A:

• 캐싱
• 로깅
• 참조 카운팅
• 뮤텍스

Q4: const_cast는 안전한가요?

A: 위험합니다. 원래 const인 객체를 수정하면 정의되지 않은 동작입니다. 레거시 코드 통합 시에만 사용하세요.

Q5: const와 성능?

A: const 자체는 런타임 오버헤드가 없습니다. 오히려 컴파일러 최적화에 도움이 됩니다.

Q6: const 정확성을 어떻게 시작하나요?

A:

1. 새 코드에서 const 습관화
2. 멤버 함수에 const 추가
3. 함수 매개변수를 const 참조로
4. 점진적으로 개선

관련 글: mutable, 스마트 포인터, 함수 기초, 코드 리뷰 체크리스트.

---

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

• C++ mutable Keyword | “mutable 키워드” 가이드
• C++ 스마트 포인터 | unique_ptr/shared_ptr “메모리 안전” 가이드
• C++ 함수 | “처음 배우는” 함수 만들기 완벽 가이드 [예제 10개]
• C++ 코드 리뷰 | “체크리스트” 20가지 [실무 필수]

관련 글

• [C++ 클린 코드 기초: const, noexcept, ]로 인터페이스 의도 명확히 하기](/blog/cpp-series-38-1-clean-code-const-noexcept-nodiscard/)
• C++ 코드 리뷰 |
• C++ const 에러 |
• C++ mutable Keyword |
• C++ constexpr 함수와 변수 | 컴파일 타임에 계산하기 [#26-1]

심화 부록: 구현·운영 관점

이 부록은 앞선 본문에서 다룬 주제(「C++ const 완벽 가이드 | ‘const 정확성’ 실전 활용」)를 구현·런타임·운영 관점에서 다시 압축합니다. 도메인별 세부 구현은 글마다 다르지만, 입력 검증 → 핵심 연산 → 부작용(I/O·네트워크·동시성) → 관측의 흐름으로 장애를 나누면 원인 추적이 빨라집니다.

내부 동작과 핵심 메커니즘

flowchart TD
  A[입력·요청·이벤트] --> B[파싱·검증·디코딩]
  B --> C[핵심 연산·상태 전이]
  C --> D[부작용: I/O·네트워크·동시성]
  D --> E[결과·관측·저장]

sequenceDiagram
  participant C as 클라이언트/호출자
  participant B as 경계(런타임·게이트웨이·프로세스)
  participant D as 의존성(API·DB·큐·파일)
  C->>B: 요청/이벤트
  B->>D: 조회·쓰기·RPC
  D-->>B: 지연·부분 실패·재시도 가능
  B-->>C: 응답 또는 오류(코드·상관 ID)

• 불변 조건(Invariant): 버퍼 경계, 프로토콜 상태, 트랜잭션 격리, FD 상한 등 단계별로 문장으로 적어 두면 디버깅 비용이 줄어듭니다.
• 결정성: 순수 층과 시간·네트워크·스케줄에 의존하는 층을 분리해야 테스트와 장애 분석이 쉬워집니다.
• 경계 비용: 직렬화, 인코딩, syscall 횟수, 락 경합, 할당·GC, 캐시 미스를 의심 목록에 둡니다.
• 백프레셔: 생산자가 소비자보다 빠를 때 버퍼·큐·스트림에서 속도를 줄이는 신호를 어디에 둘지 정의합니다.

프로덕션 운영 패턴

영역	운영 관점 질문
관측성	요청 단위 상관 ID, 에러율·지연 p95/p99, 의존성 타임아웃·재시도가 대시보드에 보이는가
안전성	입력 검증·권한·비밀·감사 로그가 코드 경로마다 일관적인가
신뢰성	재시도는 멱등 연산에만 적용되는가, 서킷 브레이커·백오프·DLQ가 있는가
성능	캐시·배치 크기·커넥션 풀·인덱스·백프레셔가 데이터 규모에 맞는가
배포	롤백 룬북, 카나리/블루그린, 마이그레이션·피처 플래그가 문서화되어 있는가
용량	피크 트래픽·디스크·FD·스레드 풀 상한을 주기적으로 검증하는가

스테이징은 데이터 양·네트워크 RTT·동시성을 프로덕션에 가깝게 맞출수록 재현율이 올라갑니다.

확장 예시: 엔드투엔드 미니 시나리오

앞선 본문 주제(「C++ const 완벽 가이드 | ‘const 정확성’ 실전 활용」)를 배포·운영 흐름에 맞춰 옮긴 체크리스트입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.

1. 입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드를 경계에 둔다.
2. 핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 로그·메트릭·트레이스에서 한 흐름으로 본다.
3. 실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
4. 호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지 확인한다.
5. 부하 후 검증: 피크 대비 p95/p99, 에러율, 리소스 상한, 알림 임계값을 점검한다.

handle(request):
  ctx = newCorrelationId()
  validated = validateSchema(request)
  authorize(validated, ctx)
  result = domainCore(validated)
  persistOrEmit(result, idempotentKey)
  recordMetrics(ctx, latency, outcome)
  return result

문제 해결(Troubleshooting)

증상	가능 원인	조치
간헐적 실패	레이스, 타임아웃, 외부 의존성, DNS	최소 재현 스크립트, 분산 트레이스·로그 상관관계, 재시도·서킷 설정 점검
성능 저하	N+1, 동기 I/O, 락 경합, 과도한 직렬화, 캐시 미스	프로파일러·APM으로 핫스팟 확인 후 한 가지씩 제거
메모리 증가	캐시 무제한, 구독/리스너 누수, 대용량 버퍼, 커넥션 미반납	상한·TTL·힙/FD 스냅샷 비교
빌드·배포만 실패	환경 변수, 권한, 플랫폼 차이, lockfile	CI 로그와 로컬 diff, 런타임·이미지 버전 핀
설정 불일치	프로필·시크릿·기본값, 리전	스키마 검증된 설정 단일 소스와 배포 매트릭스 표준화
데이터 불일치	비멱등 재시도, 부분 쓰기, 캐시 무효화 누락	멱등 키·아웃박스·트랜잭션 경계 재검토

권장 순서: (1) 최소 재현 (2) 최근 변경 범위 축소 (3) 환경·의존성 차이 (4) 관측으로 가설 검증 (5) 수정 후 회귀·부하 테스트.

배포 전에는 git add → git commit → git push 후 npm run deploy 순서를 권장합니다.

---

이 글에서 다루는 키워드 (관련 검색어)

C++, const, const-correctness, 상수, 코드품질 등으로 검색하시면 이 글이 도움이 됩니다.