헤더 파일과 모듈화

C++에서 헤더 파일은 코드 모듈화를 위한 중요한 구성 요소입니다. 전통적인 C 언어에서는 .h 확장자를 사용하여 헤더 파일을 구분했지만, C++는 이러한 관행에 변화를 주었습니다. C++ 표준 라이브러리 헤더는 대부분 확장자 없이 제공되며, C 언어 라이브러리를 C++에서 사용할 수 있도록 <math.h>를 <cmath>와 같이 c 접두사를 붙여 재정의된 헤더 파일들을 제공합니다. 확장자가 없는 C++ 스타일 헤더 파일은 종종 네임스페이스를 활용하여 이름 충돌을 방지합니다.

헤더 파일을 포함하는 방식에도 차이가 있습니다. #include <filename>은 주로 시스템 라이브러리나 표준 라이브러리 헤더를 찾을 때 사용되며, 컴파일러가 미리 지정된 시스템 경로에서 파일을 검색합니다. 반면, #include "filename"은 현재 디렉터리에서 파일을 먼저 검색한 후, 찾지 못하면 시스템 경로를 검색합니다. 이는 사용자 정의 헤더 파일을 포함할 때 유용합니다.

C++의 핵심 키워드 심층 분석

const: 불변성 선언

const 키워드는 변수나 객체가 변경될 수 없음을 나타냅니다. 포인터와 함께 사용될 때 const의 위치에 따라 의미가 달라지며, 이는 매우 중요합니다:

• const int* ptr;: 포인터가 가리키는 값은 변경할 수 없지만, 포인터 자체는 다른 주소를 가리키도록 변경할 수 있습니다.
• int* const ptr;: 포인터가 가리키는 주소는 변경할 수 없지만, 해당 주소의 값은 변경할 수 있습니다.
• const int* const ptr;: 포인터가 가리키는 값과 주소 모두 변경할 수 없습니다.

함수 오버로딩 시에도 const의 적용 방식에 유의해야 합니다. void func(int val)과 void func(const int val)은 오버로딩되지 않습니다. 이는 val이 값으로 전달될 때 복사본이 생성되므로, const 유무가 실제 함수 시그니처에 영향을 미치지 않기 때문입니다. 하지만 참조를 사용하는 void func(int& val)과 void func(const int& val)은 다른 시그니처로 인식되어 오버로딩이 가능합니다.

constexpr: 컴파일 타임 상수 표현식

C++11부터 도입된 constexpr 키워드는 컴파일러에게 함수나 객체 생성자가 컴파일 시간에 상수 표현식으로 평가될 수 있음을 명시적으로 알려줍니다. 이는 런타임 성능 향상 및 컴파일 타임 연산의 활용을 가능하게 합니다.

constexpr 함수는 재귀적으로 정의될 수 있습니다. 다음은 팩토리얼을 계산하는 constexpr 함수의 예시입니다:

constexpr long long calculateFactorial(int num) {
    return (num <= 1) ? 1 : num * calculateFactorial(num - 1);
}

// 컴파일 타임에 배열 크기 결정:
// std::array<int, calculateFactorial(4)> my_compile_time_array; 

constexpr 키워드는 컴파일 타임 상수 표현식으로 평가될 수 있음을 의미하며, 모든 상황에서 컴파일 타임에 평가된다는 것을 보장하지는 않습니다. 컴파일 타임 상수가 요구되는 컨텍스트(예: 배열 크기, 템플릿 인자)에서만 컴파일 타임 평가가 강제됩니다. 그 외의 경우에는 런타임에 평가될 수 있습니다.

C++17에서는 if constexpr 문이 도입되어 컴파일 시간에 조건에 따라 코드 분기를 수행할 수 있게 되었습니다. 이는 템플릿 메타 프로그래밍에서 유연성을 크게 향상시킵니다.

#include <iostream>
#include <type_traits> // std::is_floating_point를 위해

template<typename T>
auto processValue(const T& val) {
    if constexpr (std::is_floating_point<T>::value) {
        // T가 부동 소수점 타입이면 이 블록이 컴파일됨
        return val * 2.0;
    } else {
        // T가 정수 타입이면 이 블록이 컴파일됨
        return val + 10;
    }
}

int main() {
    std::cout << "Processed int: " << processValue(5) << std::endl;      // 결과: 15
    std::cout << "Processed double: " << processValue(3.14) << std::endl; // 결과: 6.28
    return 0;
}

위 코드에서 if constexpr은 컴파일 시간에 T의 타입에 따라 다른 코드 경로를 선택하여 불필요한 코드가 컴파일되지 않도록 합니다.

C++의 새로운 제어 흐름 구조

if/switch 문 내 변수 정의 (C++17)

C++17부터는 if 및 switch 문 내에서 변수를 정의하고 초기화할 수 있게 되어, 조건부 로직에 필요한 임시 변수의 스코프를 효율적으로 관리할 수 있습니다.

#include <iostream>
#include <vector>
#include <string>
#include <algorithm> // std::find를 위해

int main() {
    std::vector<std::string> item_list = {"apple", "banana", "orange"};

    // if 문 내에서 변수 'search_result' 정의
    if (const auto search_result = std::find(item_list.begin(), item_list.end(), "banana");
        search_result != item_list.end()) {
        *search_result = "grape"; // 찾은 항목 수정
        std::cout << "Banana replaced with grape." << std::endl;
    } else {
        std::cout << "Banana not found." << std::endl;
    }

    // 결과 출력
    for (const std::string& item : item_list) {
        std::cout << item << " ";
    }
    std::cout << std::endl;

    return 0;
}

범위 기반 for 루프 (C++11)

C++11에서 도입된 범위 기반(range-based) for 루프는 배열이나 컨테이너의 모든 요소에 대해 간결하게 반복 작업을 수행할 수 있도록 합니다.

#include <iostream>
#include <vector>
#include <array>

int main() {
    std::array<double, 4> temperatures = {25.5, 28.1, 22.0, 20.7};

    // 요소 읽기 전용 반복
    for (double temp_val : temperatures) {
        std::cout << temp_val << " ";
    }
    std::cout << std::endl; // 출력: 25.5 28.1 22 20.7

    // 요소를 수정해야 할 경우 참조 사용
    for (double& temp_ref : temperatures) {
        temp_ref += 1.0; // 온도를 1도 증가
    }

    // 수정된 요소 출력
    for (double temp_val : temperatures) {
        std::cout << temp_val << " ";
    }
    std::cout << std::endl; // 출력: 26.5 29.1 23 21.7

    // 초기화 리스트를 직접 사용하여 반복
    for (int num_val : {100, 200, 300}) {
        std::cout << num_val << " ";
    }
    std::cout << std::endl; // 출력: 100 200 300

    return 0;
}

스코프, 저장 기간, 그리고 연결

개별 컴파일 및 코드 구성

대규모 C++ 프로젝트는 여러 소스 파일로 구성됩니다. 이 파일들 간에 구조체 선언, 함수 프로토타입 등을 공유하기 위해 헤더 파일이 사용됩니다. 핵심 원칙은 헤더 파일에는 선언(declarations)만 포함하고, 소스 파일(.cpp)에는 정의(definitions)를 포함하는 것입니다.

• 헤더 파일 (.h 또는 .hpp)에는 다음을 포함합니다:
  • 함수 프로토타입
  • #define 또는 const로 정의된 상수
  • 구조체(struct) 및 클래스(class) 선언
  • 템플릿(template) 선언 및 정의
  • 인라인(inline) 함수 정의
• 소스 파일 (.cpp)에는 다음을 포함합니다:
  • 헤더 파일에 선언된 함수의 실제 구현 (함수 몸체)
  • 전역 변수 정의

구조체 선언은 단순히 타입을 정의하는 것이므로 여러 헤더 파일에 포함되어도 문제가 되지 않습니다. 하지만 일반 함수 정의나 전역 변수 정의를 헤더 파일에 넣고, 이 헤더 파일을 여러 소스 파일이 포함하게 되면 링크 시점에 '다중 정의(Multiple Definition)' 오류가 발생할 수 있습니다 (One Definition Rule 위반).

헤더 가드(Header Guards): 한 파일 내에서 동일한 헤더 파일이 여러 번 포함되는 것을 방지하기 위해 헤더 가드를 사용합니다. 이는 컴파일 속도를 향상시키고 다중 정의 오류를 막는 표준적인 방법입니다.

#ifndef MY_HEADER_FILE_H // MY_HEADER_FILE_H가 아직 정의되지 않았다면
#define MY_HEADER_FILE_H // MY_HEADER_FILE_H를 정의하고
// 헤더 파일 내용 (선언들)
#endif // 여기까지 처리

또는 비표준이지만 많은 컴파일러가 지원하는 #pragma once 지시어를 사용할 수도 있습니다.

C++ 함수 검색 원리

어떤 파일에서 함수를 호출했을 때, C++ 컴파일러와 링커는 다음 순서로 함수 정의를 찾습니다:

1. 현재 소스 파일 내에서 정의를 찾습니다. 만약 함수가 static으로 선언되었다면 이 파일 내에서만 찾습니다.
2. 현재 파일에서 찾지 못했고 static이 아니라면, 프로그램에 포함된 다른 모든 소스 파일에서 정의를 찾습니다.
3. 그래도 찾지 못하면, 링크 시에 지정된 라이브러리(표준 라이브러리 등)에서 함수 정의를 찾습니다.

만약 프로그램 내에서 라이브러리 함수와 동일한 이름의 함수를 정의했다면, 컴파일러는 프로그래머가 정의한 버전을 우선적으로 사용합니다.

저장 기간(Storage Duration)

변수가 메모리에 존재하는 기간을 저장 기간이라고 합니다. C++에는 네 가지 주요 저장 기간이 있습니다.

• 자동 저장 기간 (Automatic Storage Duration): 함수 내에서 선언된 지역 변수와 함수 매개변수가 해당됩니다. 이들은 함수나 블록이 실행될 때 생성되고, 해당 블록을 벗어나면 메모리에서 해제됩니다. 주로 스택(stack)에 할당됩니다.
• 정적 저장 기간 (Static Storage Duration): 함수 외부에서 정의된 전역 변수, 또는 static 키워드로 선언된 지역 변수들이 해당됩니다. 이들은 프로그램의 전체 실행 기간 동안 존재하며, 주로 데이터(data) 또는 BSS(Block Started by Symbol) 세그먼트에 할당됩니다.
• 스레드 저장 기간 (Thread Storage Duration, C++11): thread_local 키워드로 선언된 변수입니다. 멀티스레드 환경에서 각 스레드마다 독립적인 사본을 가지며, 스레드의 생명주기와 함께 합니다.
• 동적 저장 기간 (Dynamic Storage Duration): new 연산자를 사용하여 동적으로 할당된 메모리를 말합니다. 이 메모리는 delete 연산자를 통해 명시적으로 해제될 때까지 또는 프로그램이 종료될 때까지 존재합니다. 주로 힙(heap)에 할당됩니다.

자동 저장 기간 변수

함수 내부에서 선언된 변수들은 기본적으로 자동 저장 기간을 가집니다. 이 변수들은 선언된 블록 내에서만 유효하며, 블록을 벗어나면 소멸됩니다. 예를 들어, main() 함수와 다른 other_func() 함수에 동일한 이름의 지역 변수가 있더라도 이들은 완전히 별개의 메모리 공간을 사용합니다. register 키워드는 과거에 변수를 CPU 레지스터에 저장하도록 컴파일러에게 힌트를 주는 용도로 사용되었으나, 현대 C++에서는 더 이상 직접적인 영향을 미치지 않으며 auto와 동일하게 자동 저장 기간을 선언하는 역할을 합니다.

지역 변수가 아닌 전역 변수에 접근하려면 스코프 결정 연산자(::)를 사용할 수 있습니다:

#include <iostream>

int global_value = 50; // 전역 변수

int main() {
    int global_value = 100; // 지역 변수 (전역 변수와 이름이 같음)
    std::cout << "Local value: " << global_value << std::endl;       // 출력: Local value: 100
    std::cout << "Global value: " << ::global_value << std::endl;    // 출력: Global value: 50
    return 0;
}

정적 저장 기간 변수

정적 저장 기간을 가진 변수들은 프로그램이 시작될 때 생성되어 종료될 때까지 메모리에 유지됩니다. 이들의 접근성은 연결(Linkage) 속성에 따라 달라집니다.

• 내부 연결(Internal Linkage): static 키워드로 선언된 전역 변수나 함수는 해당 변수/함수가 정의된 파일 내에서만 접근 가능합니다.
• 외부 연결(External Linkage): static이 아닌 전역 변수나 함수는 프로그램의 모든 파일에서 접근 가능합니다.
• 연결 없음(No Linkage): static 키워드로 선언된 지역 변수는 해당 함수/블록 내에서만 접근 가능하지만, 값은 함수 호출이 끝나도 유지됩니다.

정적 변수는 초기화되지 않으면 자동으로 0(또는 해당 타입의 0에 해당하는 값)으로 초기화됩니다. 명시적으로 초기화하는 경우, 상수 표현식으로 초기화할 수 있습니다.

#include <cmath> // std::atan을 위해

int global_uninitialized; // 0으로 자동 초기화
static int file_scope_static = 10; // 해당 파일 내에서만 접근 가능

const double PI = 4.0 * std::atan(1.0); // const 전역 변수 (내부 연결, 컴파일 시 초기화)

void func_with_static_local() {
    static int call_count = 0; // 지역 스코프지만 정적 저장 기간 (값 유지)
    call_count++;
    std::cout << "Function called " << call_count << " times." << std::endl;
}

외부 연결성을 가진 전역 변수를 다른 파일에서 사용하려면, 해당 파일에서는 extern 키워드를 사용하여 변수가 외부에 정의되었음을 선언해야 합니다. extern은 저장 공간을 할당하지 않고 단지 변수가 존재한다는 사실을 컴파일러에게 알립니다.

설명자 (Specifiers)

const 키워드의 특별한 동작

C++에서는 전역 const 변수가 기본적으로 내부 연결(Internal Linkage)을 가집니다. 이는 C 언어와는 다른 점입니다. 이러한 설계 덕분에 여러 소스 파일이 동일한 const 변수가 정의된 헤더 파일을 포함하더라도 각 파일마다 독립적인 상수를 가지게 되어 다중 정의 오류를 피할 수 있습니다.

만약 전역 const 변수에 외부 연결(External Linkage)을 부여하고 싶다면 extern 키워드를 명시해야 합니다:

extern const int MAX_RETRIES = 5; // 외부 연결을 가진 const 변수 정의 (한 파일에서만 초기화 가능)

이 경우, 이 변수를 사용하는 다른 모든 파일에서는 extern const int MAX_RETRIES;와 같이 선언해야 합니다. 함수나 블록 내에서 선언된 const 변수는 해당 블록 스코프 내에서만 유효하며 연결성은 없습니다.

volatile: 컴파일러 최적화 방지

volatile 키워드는 변수의 값이 프로그램 코드 외부에 의해 언제든지 변경될 수 있음을 컴파일러에게 알려줍니다. 이는 주로 하드웨어 레지스터, 운영체제 또는 다른 스레드에 의해 값이 변경될 수 있는 메모리 위치에 사용됩니다. volatile이 선언된 변수에 대해서는 컴파일러가 최적화를 위해 레지스터 캐싱 등을 수행하지 않고, 항상 메모리에서 직접 값을 읽고 씁니다. 이는 예상치 못한 값 변경으로 인한 버그를 방지하는 데 중요합니다.

mutable: const 객체의 특정 멤버 변경 허용

mutable 키워드는 클래스/구조체의 멤버 변수에 적용됩니다. 이 키워드가 붙은 멤버는 설령 해당 객체가 const로 선언되었다 하더라도 변경될 수 있습니다. 이는 주로 객체의 논리적 상태를 변경하지 않으면서도 내부적인 캐시나 접근 횟수 카운터와 같은 물리적 상태를 업데이트해야 할 때 유용합니다.

#include <iostream>
#include <string>

struct UserActivity {
    std::string user_name;
    mutable int login_count; // UserActivity 객체가 const여도 변경 가능
    int last_session_id;
};

int main() {
    const UserActivity user_profile = {"John Doe", 0, 12345};

    // user_profile.user_name = "Jane Doe"; // 오류: user_profile이 const이므로 변경 불가
    // user_profile.last_session_id = 67890; // 오류: user_profile이 const이므로 변경 불가

    user_profile.login_count++; // 허용됨: login_count는 mutable 멤버
    std::cout << "User: " << user_profile.user_name
              << ", Login count: " << user_profile.login_count << std::endl;
    return 0;
}

메모리 정렬 제어 (C++11)

C++11에서는 메모리 정렬(memory alignment)을 제어하기 위한 두 가지 키워드가 도입되었습니다: alignof와 alignas.

• alignof: 특정 타입의 기본 정렬 요구 사항을 쿼리하는 연산자입니다. 예를 들어, alignof(int)는 int 타입의 정렬 요구 사항을 바이트 단위로 반환합니다.
• alignas: 변수 또는 타입에 대한 최소 정렬 요구 사항을 명시적으로 지정하는 키워드입니다. 이를 통해 개발자는 특정 메모리 경계에 데이터를 정렬하여 성능을 최적화하거나 특정 하드웨어 인터페이스 요구 사항을 충족시킬 수 있습니다. 예를 들어 alignas(16) MyStruct s;는 s 객체를 16바이트 경계에 정렬하도록 합니다.