C++ Linkage와 Storage | "연결과 저장 기간" 가이드

Linkage 종류

External Linkage

// file1.cpp
int globalVar = 10;  // external linkage

void func() {  // external linkage
    cout << globalVar << endl;
}

// file2.cpp
extern int globalVar;  // 선언
extern void func();    // 선언

int main() {
    cout << globalVar << endl;  // 10
    func();
}

Internal Linkage

// file1.cpp
static int internalVar = 10;  // internal linkage

static void internalFunc() {  // internal linkage
    cout << internalVar << endl;
}

// file2.cpp
// internalVar와 internalFunc는 접근 불가

No Linkage

void func() {
    int localVar = 10;  // no linkage
    // 이 함수 내에서만 존재
}

Storage Duration

Automatic Storage

void func() {
    int x = 10;  // automatic storage
    // 함수 종료 시 자동 파괴
}

Static Storage

// 전역 변수
int global = 10;  // static storage

void func() {
    static int counter = 0;  // static storage
    counter++;
    cout << counter << endl;
}

int main() {
    func();  // 1
    func();  // 2
    func();  // 3
}

Thread Storage

#include <thread>

thread_local int threadVar = 0;  // thread storage

void increment() {
    threadVar++;
    cout << "스레드 " << this_thread::get_id() 
         << ": " << threadVar << endl;
}

int main() {
    thread t1(increment);
    thread t2(increment);
    
    t1.join();
    t2.join();
    
    // 각 스레드마다 독립적인 threadVar
}

Dynamic Storage

int* ptr = new int(10);  // dynamic storage
// 명시적 delete 필요
delete ptr;

실전 예시

예시 1: 싱글톤 (static)

class Singleton {
private:
    Singleton() {
        cout << "싱글톤 생성" << endl;
    }
    
public:
    static Singleton& getInstance() {
        static Singleton instance;  // static storage
        return instance;
    }
    
    void doSomething() {
        cout << "작업 수행" << endl;
    }
};

int main() {
    Singleton::getInstance().doSomething();
    Singleton::getInstance().doSomething();
    // 한 번만 생성됨
}

예시 2: 함수 호출 카운터

void trackedFunction() {
    static int callCount = 0;  // static storage
    callCount++;
    
    cout << "호출 횟수: " << callCount << endl;
}

int main() {
    trackedFunction();  // 1
    trackedFunction();  // 2
    trackedFunction();  // 3
}

예시 3: 스레드별 캐시

#include <thread>
#include <vector>

thread_local vector<int> cache;

void processData(int data) {
    cache.push_back(data);
    
    cout << "스레드 " << this_thread::get_id() 
         << " 캐시 크기: " << cache.size() << endl;
}

int main() {
    thread t1( {
        for (int i = 0; i < 5; i++) {
            processData(i);
        }
    });
    
    thread t2( {
        for (int i = 0; i < 3; i++) {
            processData(i);
        }
    });
    
    t1.join();
    t2.join();
    
    // 각 스레드마다 독립적인 cache
}

예시 4: 익명 네임스페이스

// file1.cpp
namespace {
    int internalVar = 10;  // internal linkage
    
    void internalFunc() {
        cout << internalVar << endl;
    }
}

void publicFunc() {
    internalFunc();  // OK
}

// file2.cpp
// internalVar와 internalFunc 접근 불가

extern 사용법

변수 선언

// globals.cpp
int globalCounter = 0;  // 정의

// main.cpp
extern int globalCounter;  // 선언

int main() {
    globalCounter++;
    cout << globalCounter << endl;
}

const와 extern

// file1.cpp
extern const int value = 10;  // external linkage

// file2.cpp
extern const int value;  // 선언

int main() {
    cout << value << endl;  // 10
}

템플릿 extern

// template.h
template<typename T>
void func(T value);

// template.cpp
template<typename T>
void func(T value) {
    cout << value << endl;
}

// 명시적 인스턴스화
template void func<int>(int);

// main.cpp
extern template void func<int>(int);  // 선언

int main() {
    func(10);
}

static 키워드

함수 내 static

void func() {
    static int x = 0;  // 한 번만 초기화
    x++;
    cout << x << endl;
}

int main() {
    func();  // 1
    func();  // 2
    func();  // 3
}

클래스 static 멤버

class Counter {
private:
    static int count;  // 선언
    
public:
    Counter() { count++; }
    static int getCount() { return count; }
};

int Counter::count = 0;  // 정의

int main() {
    Counter c1, c2, c3;
    cout << Counter::getCount() << endl;  // 3
}

자주 발생하는 문제

문제 1: static 초기화 순서

// file1.cpp
int x = compute();  // 먼저?

// file2.cpp
int y = compute();  // 먼저?

// 순서 미정의!

// ✅ 함수 내 static 사용
int& getX() {
    static int x = compute();
    return x;
}

문제 2: extern 중복 정의

// ❌ 링크 에러
// file1.cpp
int value = 10;

// file2.cpp
int value = 20;  // 중복 정의!

// ✅ 한 곳에서만 정의
// file1.cpp
int value = 10;

// file2.cpp
extern int value;

문제 3: thread_local 초기화

// ❌ 복잡한 초기화
thread_local vector<int> data = expensiveInit();  // 매 스레드마다

// ✅ 지연 초기화
thread_local unique_ptr<vector<int>> data;

void ensureInit() {
    if (!data) {
        data = make_unique<vector<int>>(expensiveInit());
    }
}

초기화 순서

정적 초기화

// 컴파일 타임 또는 프로그램 시작 전
int x = 10;
const int y = 20;

동적 초기화

// 런타임
int x = compute();

// 순서: 같은 파일 내에서는 순서 보장
int a = 10;
int b = a + 5;  // OK

함수 내 static

int& getValue() {
    static int value = compute();  // 첫 호출 시 초기화
    return value;
}

// 스레드 안전 (C++11)

FAQ

Q1: extern과 static의 차이는?

A:

• extern: 다른 파일에서 접근 가능
• static: 현재 파일에서만 접근 가능

Q2: thread_local은 언제 사용하나요?

A:

• 스레드별 캐시
• 스레드별 상태
• 난수 생성기

Q3: static 초기화 순서 문제는?

A: 함수 내 static을 사용하면 해결됩니다.

Q4: extern “C”는 왜 필요한가요?

A: C 코드와 링크하기 위해 name mangling을 방지합니다.

Q5: 전역 변수는 피해야 하나요?

A: 네, 가능하면 피하세요. 대신 싱글톤이나 의존성 주입을 사용하세요.

Q6: Linkage 학습 리소스는?

A:

• “The C++ Programming Language” (Bjarne Stroustrup)
• cppreference.com
• 컴파일러 문서

---

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

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

• C++ Extern Linkage | “외부 연결” 가이드
• C++ static 멤버 | “Static Members” 가이드
• C++ Dynamic Initialization | “동적 초기화” 가이드

관련 글

• C++ Extern Linkage |
• C++ CRTP 완벽 가이드 | 정적 다형성과 컴파일 타임 최적화
• C++ Dynamic Initialization |
• C++ 정적 초기화 순서 |
• C++ Initialization Order 완벽 가이드 | 초기화 순서의 모든 것