AI 기반 시각화 전문지식 서비스

프로그램개발 · 분야 선택22개 분야

Ver3.5 전체 열람

Ver3.5 🏗️ C++ 빌드 시스템과 CMake · Make를 활용한 프로젝트 빌드 관리 완전 정복

2026.07.14

재능넷

댓글 0 전체 48 페이지

🛠️ C++ 빌드 시스템

🏗️ C++ 빌드 시스템과 CMake · Make를 활용한 프로젝트 빌드 관리 완전 정복

복잡한 빌드 세계, 이제 쉽고 재미있게 마스터해보자! 🚀

🤔 빌드 시스템이 뭔데? 왜 필요해?

💬 "야 C++ 코드 짰는데 그냥 g++ main.cpp 하면 되는 거 아니야? 빌드 시스템이 왜 필요해?"

🤖 "파일이 10개면 몰라도... 파일이 100개, 1000개가 되면? 의존성이 복잡해지면? 그때도 그 말 할 수 있어? ㅋㅋㅋ"

맞아, 처음 C++ 배울 때는 그냥 g++ main.cpp -o myapp 이렇게 하면 끝이잖아.
근데 실제 프로젝트는 그렇게 단순하지 않아. 파일이 수십 개, 수백 개가 되고, 외부 라이브러리도 붙고, 플랫폼도 달라지고... 이걸 일일이 손으로 관리하면 진짜 지옥이 따로 없음 😱

빌드 시스템(Build System)이란 소스 코드를 실행 가능한 프로그램으로 변환하는 전체 과정을 자동화하고 관리하는 도구야.
단순히 컴파일만 하는 게 아니라, 의존성 추적, 증분 빌드(변경된 파일만 재컴파일), 링킹, 설치 등 모든 과정을 체계적으로 처리해줘.

💡 빌드 시스템이 해결하는 핵심 문제들

① 의존성 관리 : A.cpp가 B.h를 include하면, B.h가 바뀔 때 A.cpp도 재컴파일해야 해
② 증분 빌드 : 1000개 파일 중 1개만 바꿨는데 전체 다시 빌드하면 시간 낭비 극심
③ 크로스 플랫폼 : Windows, Linux, macOS에서 동일한 코드를 빌드해야 할 때
④ 빌드 설정 관리 : Debug/Release 모드, 컴파일 옵션, 링크 옵션 등 체계적 관리

C++ 생태계에서 대표적인 빌드 도구들을 간단히 살펴보면:

도구	역할	특징
Make	빌드 자동화	유닉스 전통의 빌드 도구, Makefile 기반
CMake	빌드 시스템 생성기	크로스 플랫폼, Makefile/Ninja 등 생성
Ninja	빌드 자동화	Make보다 빠른 빌드 속도
Bazel	빌드 자동화	Google 개발, 대규모 프로젝트용
Meson	빌드 시스템 생성기	Python 기반, 빠르고 현대적

이 중에서 오늘 우리가 집중적으로 파볼 건 Make와 CMake야.
이 두 개가 C++ 세계에서 가장 널리 쓰이는 조합이거든. 특히 오픈소스 프로젝트의 대부분이 CMake를 사용하고 있어서 이걸 모르면 남의 코드 빌드하는 것도 힘들어 ㅋㅋㅋ

🔧 Make와 Makefile - 빌드 자동화의 원조

Make는 1976년에 Stuart Feldman이 만든 유서 깊은 빌드 도구야. 거의 50년 된 도구인데 아직도 현역이라는 게 레전드 ㄷㄷ
GNU Make는 그 중에서도 가장 널리 쓰이는 버전으로, Linux/macOS 환경에서 기본으로 제공돼.

📄 Makefile 기본 구조

Make는 Makefile이라는 파일을 읽어서 빌드를 수행해.
Makefile의 기본 구조는 타겟(target) : 의존성(dependencies) 형태야.

# Makefile 기본 문법
타겟 : 의존성1 의존성2
	명령어   ← 반드시 탭(Tab)으로 들여쓰기!

# 예시
myapp : main.o utils.o
	g++ -o myapp main.o utils.o

main.o : main.cpp utils.h
	g++ -c main.cpp

utils.o : utils.cpp utils.h
	g++ -c utils.cpp

⚠️ Makefile 최대 주의사항!
명령어 앞의 들여쓰기는 반드시 탭(Tab) 문자여야 해. 스페이스로 하면 에러남. 이거 때문에 초보자들이 진짜 많이 삽질함 ㅋㅋㅋ 에디터 설정 꼭 확인해!

🏗️ 실전 Makefile 작성하기

실제 프로젝트에서 쓸 수 있는 좀 더 완성도 있는 Makefile을 만들어보자.
다음과 같은 프로젝트 구조를 가정할게:

# 프로젝트 구조
myproject/
├── src/
│   ├── main.cpp
│   ├── calculator.cpp
│   └── utils.cpp
├── include/
│   ├── calculator.h
│   └── utils.h
├── build/
└── Makefile

# 실전 Makefile 예시

# 변수 정의
CXX = g++
CXXFLAGS = -std=c++17 -Wall -Wextra -I./include
LDFLAGS = 
TARGET = myapp
BUILD_DIR = build
SRC_DIR = src

# 소스 파일 자동 탐색
SRCS = $(wildcard $(SRC_DIR)/*.cpp)
# SRCS = src/main.cpp src/calculator.cpp src/utils.cpp

# 오브젝트 파일 경로 변환
OBJS = $(patsubst $(SRC_DIR)/%.cpp, $(BUILD_DIR)/%.o, $(SRCS))

# 기본 타겟 (all)
.PHONY: all clean debug release

all: $(BUILD_DIR)/$(TARGET)

# 링킹 단계
$(BUILD_DIR)/$(TARGET): $(OBJS)
	@mkdir -p $(BUILD_DIR)
	$(CXX) $(LDFLAGS) -o $@ $^
	@echo "빌드 완료! → $@"

# 컴파일 단계 (패턴 규칙)
$(BUILD_DIR)/%.o: $(SRC_DIR)/%.cpp
	@mkdir -p $(BUILD_DIR)
	$(CXX) $(CXXFLAGS) -c $< -o $@

# 디버그 빌드
debug: CXXFLAGS += -g -DDEBUG
debug: all

# 릴리즈 빌드
release: CXXFLAGS += -O2 -DNDEBUG
release: all

# 클린
clean:
	rm -rf $(BUILD_DIR)
	@echo "빌드 파일 삭제 완료!"

# 의존성 자동 생성 (헤더 변경 감지)
-include $(OBJS:.o=.d)

$(BUILD_DIR)/%.d: $(SRC_DIR)/%.cpp
	@mkdir -p $(BUILD_DIR)
	$(CXX) $(CXXFLAGS) -MM -MT $(@:.d=.o) $< > $@

🔍 Makefile 핵심 문법 정리

문법	의미	예시
`$@`	현재 타겟 이름	myapp
`$^`	모든 의존성 목록	main.o utils.o
`$<`	첫 번째 의존성	main.cpp
`$(wildcard *.cpp)`	패턴 매칭 파일 목록	모든 .cpp 파일
`$(patsubst ...)`	패턴 치환	.cpp → .o 변환
`.PHONY`	가짜 타겟 선언	clean, all 등
`@` 접두사	명령어 출력 숨기기	@echo "완료"

💡 .PHONY가 왜 필요해?
만약 프로젝트 폴더에 clean이라는 이름의 파일이 실제로 존재하면, Make는 "이미 최신 상태"라고 판단해서 clean 명령을 실행 안 해버려.
.PHONY: clean으로 선언하면 "이건 파일 이름이 아니라 명령어야!"라고 알려주는 거야.

⚡ Make 병렬 빌드

Make의 강력한 기능 중 하나가 병렬 빌드야. -j 옵션으로 동시에 여러 파일을 컴파일할 수 있어:

# CPU 코어 수만큼 병렬 빌드
make -j4        # 4개 병렬
make -j$(nproc) # CPU 코어 수 자동 감지 (Linux)
make -j8        # 8개 병렬

# 빌드 진행 상황 확인
make -j4 VERBOSE=1

파일이 많을수록 병렬 빌드의 효과가 극적으로 나타나. 100개 파일 빌드할 때 -j8 옵션 쓰면 거의 8배 빠르게 빌드되는 거 체감할 수 있어 ㄷㄷ

🚀 CMake - 현대 C++ 빌드의 표준

CMake는 2000년에 Kitware에서 개발한 크로스 플랫폼 빌드 시스템 생성기야.
중요한 포인트는 CMake 자체가 빌드를 하는 게 아니라, 다른 빌드 시스템(Make, Ninja, Visual Studio 등)을 위한 빌드 파일을 생성해준다는 거야.

💬 "그럼 CMake가 Makefile 만들어주면, 그 Makefile로 Make가 실제 빌드하는 거야?"

🤖 "정확해! CMake는 메타 빌드 시스템이라고 불리는 이유가 그거야. 빌드 파일을 생성하는 빌드 시스템 ㅋㅋㅋ"

📦 CMake 설치 및 버전 확인

# Ubuntu/Debian
sudo apt-get install cmake

# macOS (Homebrew)
brew install cmake

# Windows (winget)
winget install Kitware.CMake

# 버전 확인
cmake --version
# cmake version 3.28.1 (예시)

# 최소 버전은 3.15 이상 권장 (Modern CMake)

📝 CMakeLists.txt 기본 구조

CMake 프로젝트의 핵심은 CMakeLists.txt 파일이야.
프로젝트 루트에 반드시 있어야 하고, 서브 디렉토리에도 추가로 만들 수 있어.

# CMakeLists.txt 기본 예시

# CMake 최소 버전 요구사항 (필수!)
cmake_minimum_required(VERSION 3.15)

# 프로젝트 선언
project(MyProject
    VERSION 1.0.0
    DESCRIPTION "나의 첫 CMake 프로젝트"
    LANGUAGES CXX
)

# C++ 표준 설정
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# 실행 파일 타겟 생성
add_executable(myapp
    src/main.cpp
    src/calculator.cpp
    src/utils.cpp
)

# 헤더 파일 경로 추가
target_include_directories(myapp PRIVATE
    ${CMAKE_SOURCE_DIR}/include
)

# 컴파일 옵션 추가
target_compile_options(myapp PRIVATE
    -Wall
    -Wextra
)

🏃 CMake 빌드 실행 과정

빌드 디렉토리 생성 (Out-of-source build)
mkdir build && cd build
소스 디렉토리를 깨끗하게 유지하는 모범 사례야. 빌드 파일들이 src 폴더에 섞이지 않아서 깔끔함 👍

CMake 구성(Configure) 단계
cmake .. 또는 cmake -S . -B build
CMakeLists.txt를 읽어서 Makefile(또는 다른 빌드 파일)을 생성해

빌드 실행
cmake --build . 또는 make
생성된 빌드 파일로 실제 컴파일 및 링킹 수행

설치 (선택사항)
cmake --install . --prefix /usr/local
빌드된 파일을 시스템에 설치

# 실제 빌드 명령어 흐름

# 방법 1: 전통적인 방식
mkdir build
cd build
cmake ..
make -j4

# 방법 2: 현대적인 방식 (CMake 3.13+)
cmake -S . -B build
cmake --build build --parallel 4

# 방법 3: 빌드 타입 지정
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release

# 방법 4: Ninja 사용
cmake -S . -B build -G Ninja
cmake --build build

🎯 Modern CMake - 타겟 기반 접근법

CMake 3.0 이후부터 Modern CMake라는 패러다임이 등장했어.
핵심 개념은 "타겟(Target) 중심으로 생각하라"는 거야.
예전 방식(Old CMake)과 비교해보면 차이가 확 느껴져:

# ❌ Old CMake 방식 (비추천)
include_directories(include)        # 전역으로 영향
add_definitions(-DDEBUG)            # 전역으로 영향
link_libraries(mylib)               # 전역으로 영향

# ✅ Modern CMake 방식 (권장)
target_include_directories(myapp PRIVATE include)
target_compile_definitions(myapp PRIVATE DEBUG)
target_link_libraries(myapp PRIVATE mylib)

🔑 PRIVATE / PUBLIC / INTERFACE 키워드

Modern CMake에서 가장 중요한 개념 중 하나야. 이걸 이해하면 의존성 전파를 제대로 제어할 수 있어:

키워드	현재 타겟	의존하는 타겟	사용 시점
PRIVATE	✅ 적용	❌ 미전파	내부 구현에만 필요할 때
PUBLIC	✅ 적용	✅ 전파	헤더에서도 사용되는 경우
INTERFACE	❌ 미적용	✅ 전파	헤더 전용 라이브러리

# PRIVATE / PUBLIC / INTERFACE 실전 예시

# 라이브러리 생성
add_library(mylib STATIC
    src/mylib.cpp
)

# mylib의 include 디렉토리 설정
target_include_directories(mylib
    PUBLIC  ${CMAKE_SOURCE_DIR}/include   # 외부에도 공개
    PRIVATE ${CMAKE_SOURCE_DIR}/src       # 내부에서만 사용
)

# 실행 파일이 mylib에 링크
add_executable(myapp src/main.cpp)
target_link_libraries(myapp PRIVATE mylib)
# myapp은 mylib의 PUBLIC include 경로를 자동으로 상속받아!

📚 라이브러리 타입 (STATIC / SHARED / INTERFACE)

# 정적 라이브러리 (.a / .lib)
add_library(mystaticlib STATIC
    src/lib1.cpp
    src/lib2.cpp
)

# 동적 라이브러리 (.so / .dll)
add_library(mysharedlib SHARED
    src/lib1.cpp
    src/lib2.cpp
)

# 헤더 전용 라이브러리 (컴파일 없음)
add_library(myheaderlib INTERFACE)
target_include_directories(myheaderlib INTERFACE
    ${CMAKE_SOURCE_DIR}/include
)

# BUILD_SHARED_LIBS 변수로 기본 타입 제어
# cmake -DBUILD_SHARED_LIBS=ON ..
add_library(mylib  # 타입 미지정 시 BUILD_SHARED_LIBS 따름
    src/lib.cpp
)

🔍 CMake 변수와 캐시 시스템

CMake의 변수 시스템은 처음엔 좀 헷갈릴 수 있어. 일반 변수와 캐시 변수가 따로 있거든 ㅋㅋㅋ
제대로 이해하면 엄청 강력한 설정 시스템을 구축할 수 있어.

📌 변수 기본 사용법

# 변수 설정
set(MY_VAR "Hello CMake")
set(MY_LIST item1 item2 item3)

# 변수 참조
message(STATUS "변수값: ${MY_VAR}")
message(STATUS "리스트: ${MY_LIST}")

# 환경 변수 접근
message(STATUS "HOME: $ENV{HOME}")

# 유용한 내장 변수들
message(STATUS "소스 디렉토리: ${CMAKE_SOURCE_DIR}")
message(STATUS "빌드 디렉토리: ${CMAKE_BINARY_DIR}")
message(STATUS "현재 소스: ${CMAKE_CURRENT_SOURCE_DIR}")
message(STATUS "현재 빌드: ${CMAKE_CURRENT_BINARY_DIR}")
message(STATUS "프로젝트명: ${PROJECT_NAME}")
message(STATUS "프로젝트 버전: ${PROJECT_VERSION}")

⚙️ 캐시 변수 (Cache Variables)

캐시 변수는 cmake-gui나 ccmake에서 설정할 수 있고, 커맨드라인에서 -D 옵션으로 전달할 수 있어:

# 캐시 변수 선언
option(ENABLE_TESTS "테스트 빌드 활성화" ON)
option(ENABLE_LOGGING "로깅 활성화" OFF)

set(MY_INSTALL_PREFIX "/usr/local" CACHE PATH "설치 경로")
set(MAX_CONNECTIONS 100 CACHE STRING "최대 연결 수")

# 캐시 변수 타입: BOOL, PATH, FILEPATH, STRING, INTERNAL

# 조건부 빌드
if(ENABLE_TESTS)
    add_subdirectory(tests)
    message(STATUS "테스트 빌드 활성화됨")
endif()

if(ENABLE_LOGGING)
    target_compile_definitions(myapp PRIVATE ENABLE_LOGGING)
endif()

# 커맨드라인에서 설정
# cmake -DENABLE_TESTS=ON -DENABLE_LOGGING=OFF ..

🔄 제너레이터 표현식 (Generator Expressions)

CMake의 고급 기능 중 하나야. 빌드 타입이나 플랫폼에 따라 다른 값을 설정할 때 사용해:

# 제너레이터 표현식 기본 문법: $<조건:값>

# 빌드 타입에 따른 컴파일 옵션
target_compile_options(myapp PRIVATE
    $<$:-g -O0 -DDEBUG>
    $<$:-O3 -DNDEBUG>
)

# 컴파일러에 따른 옵션
target_compile_options(myapp PRIVATE
    $<$:-Wall -Wextra>
    $<$:/W4>
    $<$:-Wall -Wextra>
)

# 플랫폼에 따른 정의
target_compile_definitions(myapp PRIVATE
    $<$:WINDOWS_BUILD>
    $<$:LINUX_BUILD>
)

📦 외부 라이브러리 연동하기

실제 프로젝트에서는 외부 라이브러리를 사용하는 경우가 대부분이야.
CMake에서 외부 라이브러리를 연동하는 방법을 하나씩 살펴보자.

🔍 find_package() - 시스템 라이브러리 탐색

# OpenSSL 연동 예시
find_package(OpenSSL REQUIRED)

if(OpenSSL_FOUND)
    message(STATUS "OpenSSL 버전: ${OPENSSL_VERSION}")
    target_link_libraries(myapp PRIVATE OpenSSL::SSL OpenSSL::Crypto)
endif()

# Boost 연동 예시
find_package(Boost 1.70 REQUIRED COMPONENTS
    filesystem
    system
    thread
)
target_link_libraries(myapp PRIVATE
    Boost::filesystem
    Boost::system
    Boost::thread
)

# Qt6 연동 예시
find_package(Qt6 REQUIRED COMPONENTS Core Widgets)
target_link_libraries(myapp PRIVATE Qt6::Core Qt6::Widgets)

# 커스텀 경로 지정
find_package(MyLib REQUIRED
    PATHS /opt/mylib
    NO_DEFAULT_PATH
)

📥 FetchContent - 자동 다운로드 (Modern CMake 권장)

CMake 3.11부터 내장된 FetchContent는 빌드 시 외부 라이브러리를 자동으로 다운로드하고 빌드해줘.
GitHub 프로젝트를 직접 가져올 수 있어서 진짜 편함 ㅋㅋㅋ

include(FetchContent)

# Google Test 가져오기
FetchContent_Declare(
    googletest
    GIT_REPOSITORY https://github.com/google/googletest.git
    GIT_TAG        v1.14.0
)
FetchContent_MakeAvailable(googletest)

# spdlog (로깅 라이브러리) 가져오기
FetchContent_Declare(
    spdlog
    GIT_REPOSITORY https://github.com/gabime/spdlog.git
    GIT_TAG        v1.12.0
)
FetchContent_MakeAvailable(spdlog)

# nlohmann/json 가져오기
FetchContent_Declare(
    nlohmann_json
    GIT_REPOSITORY https://github.com/nlohmann/json.git
    GIT_TAG        v3.11.3
)
FetchContent_MakeAvailable(nlohmann_json)

# 이제 바로 사용 가능!
target_link_libraries(myapp PRIVATE
    GTest::gtest_main
    spdlog::spdlog
    nlohmann_json::nlohmann_json
)

💡 FetchContent 오프라인 캐싱 팁
FETCHCONTENT_BASE_DIR 변수로 다운로드 캐시 위치를 지정할 수 있어.
cmake -DFETCHCONTENT_BASE_DIR=/path/to/cache ..
한 번 다운로드하면 다음 빌드에서는 캐시를 사용해서 빠르게 처리돼!

🧪 테스트 통합 - CTest와 Google Test

CMake에는 CTest라는 테스트 실행 도구가 내장되어 있어.
Google Test, Catch2 등 다양한 테스트 프레임워크와 쉽게 연동할 수 있어.

🔬 Google Test 연동 예시

# CMakeLists.txt (루트)
cmake_minimum_required(VERSION 3.15)
project(MyProject)

set(CMAKE_CXX_STANDARD 17)

# 테스트 활성화
enable_testing()

# 메인 라이브러리
add_library(mylib STATIC
    src/calculator.cpp
    src/utils.cpp
)
target_include_directories(mylib PUBLIC include)

# 실행 파일
add_executable(myapp src/main.cpp)
target_link_libraries(myapp PRIVATE mylib)

# 테스트 서브디렉토리
add_subdirectory(tests)

# tests/CMakeLists.txt

include(FetchContent)
FetchContent_Declare(
    googletest
    GIT_REPOSITORY https://github.com/google/googletest.git
    GIT_TAG v1.14.0
)
# Windows에서 gtest의 런타임 설정 공유
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(googletest)

# 테스트 실행 파일
add_executable(mylib_tests
    test_calculator.cpp
    test_utils.cpp
)

target_link_libraries(mylib_tests PRIVATE
    mylib
    GTest::gtest_main
)

# CTest에 테스트 등록
include(GoogleTest)
gtest_discover_tests(mylib_tests)

# 테스트 실행 방법

# 빌드 후 테스트 실행
cmake --build build
cd build
ctest                          # 모든 테스트 실행
ctest -V                       # 상세 출력
ctest -R "calculator"          # 특정 테스트만 실행
ctest --parallel 4             # 병렬 테스트
ctest --output-on-failure      # 실패 시 출력 표시

🏢 대규모 프로젝트 구조화

프로젝트가 커지면 CMakeLists.txt도 체계적으로 구조화해야 해.
add_subdirectory()를 활용한 계층적 구조가 핵심이야.

📁 권장 프로젝트 구조

MyProject/
├── CMakeLists.txt          ← 루트 (프로젝트 전체 설정)
├── cmake/
│   ├── FindMyLib.cmake     ← 커스텀 Find 모듈
│   └── CompilerOptions.cmake
├── src/
│   ├── CMakeLists.txt      ← 메인 소스
│   ├── main.cpp
│   └── core/
│       ├── CMakeLists.txt  ← 코어 라이브러리
│       ├── core.cpp
│       └── core.h
├── libs/
│   ├── CMakeLists.txt
│   └── mylib/
│       ├── CMakeLists.txt  ← 서드파티 라이브러리
│       └── ...
├── tests/
│   ├── CMakeLists.txt      ← 테스트
│   └── ...
├── docs/
└── include/
    └── myproject/          ← 공개 헤더

📋 루트 CMakeLists.txt 완성 예시

cmake_minimum_required(VERSION 3.20)

project(MyProject
    VERSION 2.1.0
    DESCRIPTION "대규모 C++ 프로젝트 예시"
    HOMEPAGE_URL "https://example.com"
    LANGUAGES CXX
)

# ===== 전역 설정 =====
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# 빌드 타입 기본값
if(NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "빌드 타입" FORCE)
endif()

# cmake/ 디렉토리를 모듈 경로에 추가
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")

# ===== 옵션 =====
option(BUILD_TESTS "테스트 빌드" ON)
option(BUILD_DOCS "문서 생성" OFF)
option(ENABLE_SANITIZERS "AddressSanitizer 활성화" OFF)

# ===== 컴파일러 옵션 모듈 포함 =====
include(CompilerOptions)

# ===== 서브디렉토리 =====
add_subdirectory(libs)
add_subdirectory(src)

if(BUILD_TESTS)
    enable_testing()
    add_subdirectory(tests)
endif()

# ===== 설치 설정 =====
include(GNUInstallDirs)
install(TARGETS myapp
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
)
install(DIRECTORY include/
    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)

🛡️ cmake/CompilerOptions.cmake 모듈

# cmake/CompilerOptions.cmake

# 인터페이스 라이브러리로 컴파일 옵션 묶기
add_library(project_options INTERFACE)
add_library(project_warnings INTERFACE)

# C++ 표준
target_compile_features(project_options INTERFACE cxx_std_20)

# 경고 옵션
if(MSVC)
    target_compile_options(project_warnings INTERFACE
        /W4 /WX /permissive-
    )
else()
    target_compile_options(project_warnings INTERFACE
        -Wall -Wextra -Wpedantic -Werror
        -Wshadow -Wnon-virtual-dtor
        -Wold-style-cast -Wcast-align
    )
endif()

# Sanitizer 옵션
if(ENABLE_SANITIZERS)
    target_compile_options(project_options INTERFACE
        -fsanitize=address,undefined
        -fno-omit-frame-pointer
    )
    target_link_options(project_options INTERFACE
        -fsanitize=address,undefined
    )
endif()

# 사용법: target_link_libraries(myapp PRIVATE project_options project_warnings)

🔄 CMake 프리셋 (CMakePresets.json)

CMake 3.19부터 도입된 CMakePresets.json은 빌드 설정을 파일로 관리할 수 있게 해줘.
팀 전체가 동일한 빌드 설정을 공유할 수 있어서 "내 컴퓨터에서는 됐는데?" 같은 상황을 방지할 수 있어 ㅋㅋㅋ

// CMakePresets.json
{
    "version": 6,
    "cmakeMinimumRequired": {
        "major": 3,
        "minor": 19,
        "patch": 0
    },
    "configurePresets": [
        {
            "name": "base",
            "hidden": true,
            "generator": "Ninja",
            "binaryDir": "${sourceDir}/build/${presetName}",
            "cacheVariables": {
                "CMAKE_CXX_STANDARD": "20"
            }
        },
        {
            "name": "debug",
            "displayName": "Debug 빌드",
            "inherits": "base",
            "cacheVariables": {
                "CMAKE_BUILD_TYPE": "Debug",
                "ENABLE_SANITIZERS": "ON"
            }
        },
        {
            "name": "release",
            "displayName": "Release 빌드",
            "inherits": "base",
            "cacheVariables": {
                "CMAKE_BUILD_TYPE": "Release",
                "BUILD_TESTS": "OFF"
            }
        },
        {
            "name": "ci",
            "displayName": "CI 빌드",
            "inherits": "base",
            "cacheVariables": {
                "CMAKE_BUILD_TYPE": "RelWithDebInfo",
                "BUILD_TESTS": "ON"
            }
        }
    ],
    "buildPresets": [
        {
            "name": "debug",
            "configurePreset": "debug",
            "jobs": 8
        },
        {
            "name": "release",
            "configurePreset": "release",
            "jobs": 8
        }
    ],
    "testPresets": [
        {
            "name": "debug",
            "configurePreset": "debug",
            "output": {"outputOnFailure": true},
            "execution": {"jobs": 4}
        }
    ]
}

# 프리셋 사용법
cmake --list-presets                    # 사용 가능한 프리셋 목록
cmake --preset debug                    # debug 프리셋으로 구성
cmake --build --preset debug            # debug 프리셋으로 빌드
ctest --preset debug                    # debug 프리셋으로 테스트

⚡ 빌드 최적화 팁

빌드가 느리면 개발 생산성이 확 떨어지잖아. 빌드 속도를 높이는 실용적인 팁들을 알아보자!

🚀 ccache - 컴파일 캐싱

ccache는 컴파일 결과를 캐싱해서 동일한 코드를 다시 컴파일할 때 캐시에서 가져와.
클린 빌드를 자주 해야 하는 상황에서 엄청난 시간 절약이 돼:

# ccache 설치
sudo apt-get install ccache  # Ubuntu
brew install ccache          # macOS

# CMakeLists.txt에서 ccache 활성화
find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
    set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
    set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
    message(STATUS "ccache 활성화: ${CCACHE_PROGRAM}")
endif()

# 또는 커맨드라인에서
cmake -DCMAKE_CXX_COMPILER_LAUNCHER=ccache ..

# ccache 통계 확인
ccache --show-stats

⚡ Unity Build (Jumbo Build)

여러 .cpp 파일을 하나로 합쳐서 컴파일하는 기법이야. 헤더 파싱 오버헤드를 줄여서 빌드가 빨라져:

# CMake 3.16+ Unity Build 지원
set_target_properties(myapp PROPERTIES
    UNITY_BUILD ON
    UNITY_BUILD_BATCH_SIZE 10  # 10개씩 묶어서 컴파일
)

# 전역으로 활성화
set(CMAKE_UNITY_BUILD ON)

# 특정 파일 제외 (ODR 위반 가능성 있는 파일)
set_source_files_properties(problematic.cpp PROPERTIES
    SKIP_UNITY_BUILD_INCLUSION ON
)

🔥 Precompiled Headers (PCH)

# CMake 3.16+ PCH 지원
# pch.h 파일 생성
target_precompile_headers(myapp PRIVATE
    pch.h
)

# 또는 직접 헤더 지정
target_precompile_headers(myapp PRIVATE
    <vector>
    <string>
    <memory>
    <algorithm>
    <iostream>
    "include/common.h"
)

# 여러 타겟 간 PCH 공유
target_precompile_headers(myapp REUSE_FROM mylib)

🏎️ Ninja 빌드 시스템 사용

# Ninja 설치
sudo apt-get install ninja-build  # Ubuntu
brew install ninja                # macOS

# CMake에서 Ninja 사용
cmake -G Ninja -S . -B build
cmake --build build

# Ninja는 Make보다 일반적으로 2~3배 빠른 빌드 속도를 보여줘!

최적화 기법	효과	적용 난이도
병렬 빌드 (-j)	⭐⭐⭐⭐⭐	매우 쉬움
ccache	⭐⭐⭐⭐⭐	쉬움
Ninja 사용	⭐⭐⭐⭐	쉬움
PCH (미리 컴파일된 헤더)	⭐⭐⭐⭐	보통
Unity Build	⭐⭐⭐	보통
분산 빌드 (distcc)	⭐⭐⭐⭐⭐	어려움

🔧 CMake 디버깅과 트러블슈팅

CMake 에러 메시지가 처음엔 진짜 이해하기 어려워 ㅋㅋㅋ
자주 만나는 문제들과 해결법을 정리해봤어.

🔍 CMake 디버깅 명령어

# 상세 출력 모드
cmake -S . -B build --log-level=DEBUG
cmake -S . -B build --trace
cmake -S . -B build --trace-expand

# 변수 값 확인
cmake -S . -B build -L    # 캐시 변수 목록
cmake -S . -B build -LA   # 고급 캐시 변수 포함
cmake -S . -B build -LH   # 도움말 포함

# CMakeLists.txt 안에서 디버깅
message(STATUS "변수 확인: ${MY_VAR}")
message(WARNING "경고 메시지")
message(FATAL_ERROR "에러 발생 - 빌드 중단")

# 타겟 속성 확인
get_target_property(INCLUDES myapp INCLUDE_DIRECTORIES)
message(STATUS "Include 경로: ${INCLUDES}")

# 빌드 상세 출력
cmake --build build --verbose
make VERBOSE=1

🚨 자주 만나는 에러와 해결법

⚠️ 에러: "Could not find package XXX"
→ find_package(XXX)가 라이브러리를 못 찾는 경우
→ 해결: cmake -DCMAKE_PREFIX_PATH=/path/to/lib .. 또는 패키지 설치 확인
→

cmake --find-package -DNAME=XXX -DCOMPILER_ID=GNU -DLANGUAGE=CXX -DMODE=EXIST

⚠️ 에러: "target_link_libraries called with wrong number of arguments"
→ Modern CMake에서 PRIVATE/PUBLIC/INTERFACE 키워드 누락
→ 해결: target_link_libraries(myapp PRIVATE mylib) 형태로 수정

⚠️ 에러: "undefined reference to ..."
→ 링킹 단계에서 심볼을 못 찾는 경우
→ 해결: target_link_libraries()에 필요한 라이브러리 추가
→ 링크 순서 확인 (의존하는 라이브러리가 뒤에 와야 함)

# CMake 캐시 초기화 (설정 꼬였을 때)
rm -rf build/CMakeCache.txt build/CMakeFiles/
# 또는
rm -rf build/
cmake -S . -B build  # 처음부터 다시

# 특정 캐시 변수만 삭제
cmake -U MY_VARIABLE -S . -B build

🔄 CI/CD 파이프라인과 CMake

현대 개발에서 CI/CD는 필수잖아. CMake 프로젝트를 GitHub Actions와 연동하는 예시를 보여줄게:

# .github/workflows/build.yml
name: C++ CMake 빌드 및 테스트

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
        build_type: [Debug, Release]
        
    runs-on: ${{ matrix.os }}
    
    steps:
    - uses: actions/checkout@v4
    
    - name: ccache 설정
      uses: hendrikmuhs/ccache-action@v1.2
      
    - name: CMake 구성
      run: |
        cmake -S . -B build \
          -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} \
          -DBUILD_TESTS=ON \
          -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
          
    - name: 빌드
      run: cmake --build build --parallel 4
      
    - name: 테스트
      working-directory: build
      run: ctest --output-on-failure --parallel 4

💡 재능넷에서 CMake 관련 도움 받기
CMake 설정이 복잡하거나 크로스 플랫폼 빌드 환경 구축이 어려울 때, 재능넷에서 C++ 빌드 시스템 전문가를 찾아볼 수 있어. 다양한 개발 재능을 가진 분들이 프로젝트 빌드 환경 설정부터 최적화까지 도움을 줄 수 있거든!

🎓 실전 완성 예제 - 계산기 프로젝트

지금까지 배운 내용을 종합해서 실제로 동작하는 완성된 CMake 프로젝트를 만들어보자!
간단한 계산기 라이브러리 + 실행 파일 + 테스트 구조야.

📁 프로젝트 파일 구조

calculator_project/
├── CMakeLists.txt
├── CMakePresets.json
├── include/
│   └── calculator/
│       └── calculator.h
├── src/
│   ├── CMakeLists.txt
│   ├── main.cpp
│   └── calculator.cpp
└── tests/
    ├── CMakeLists.txt
    └── test_calculator.cpp

📋 include/calculator/calculator.h

#pragma once
#include <stdexcept>

namespace calc {

class Calculator {
public:
    double add(double a, double b) const;
    double subtract(double a, double b) const;
    double multiply(double a, double b) const;
    double divide(double a, double b) const;
    // 0으로 나누면 std::invalid_argument 던짐
};

} // namespace calc

📋 src/calculator.cpp

#include "calculator/calculator.h"

namespace calc {

double Calculator::add(double a, double b) const {
    return a + b;
}

double Calculator::subtract(double a, double b) const {
    return a - b;
}

double Calculator::multiply(double a, double b) const {
    return a * b;
}

double Calculator::divide(double a, double b) const {
    if (b == 0.0) {
        throw std::invalid_argument("0으로 나눌 수 없어요!");
    }
    return a / b;
}

} // namespace calc

📋 루트 CMakeLists.txt

cmake_minimum_required(VERSION 3.20)

project(CalculatorProject
    VERSION 1.0.0
    DESCRIPTION "CMake 실전 예제 - 계산기"
    LANGUAGES CXX
)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# ccache 자동 감지
find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
    set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
endif()

option(BUILD_TESTS "테스트 빌드" ON)

# 계산기 라이브러리
add_library(calculator STATIC
    src/calculator.cpp
)
target_include_directories(calculator PUBLIC
    ${CMAKE_SOURCE_DIR}/include
)
target_compile_options(calculator PRIVATE
    $<$<CXX_COMPILER_ID:GNU,Clang>:-Wall -Wextra>
    $<$<CXX_COMPILER_ID:MSVC>:/W4>
)

# 실행 파일
add_executable(calc_app src/main.cpp)
target_link_libraries(calc_app PRIVATE calculator)

# 테스트
if(BUILD_TESTS)
    enable_testing()
    add_subdirectory(tests)
endif()

# 설치
include(GNUInstallDirs)
install(TARGETS calc_app RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

📋 tests/CMakeLists.txt

include(FetchContent)

FetchContent_Declare(
    googletest
    GIT_REPOSITORY https://github.com/google/googletest.git
    GIT_TAG v1.14.0
)
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(googletest)

add_executable(calculator_tests
    test_calculator.cpp
)

target_link_libraries(calculator_tests PRIVATE
    calculator
    GTest::gtest_main
)

include(GoogleTest)
gtest_discover_tests(calculator_tests)

📋 tests/test_calculator.cpp

#include <gtest/gtest.h>
#include "calculator/calculator.h"

class CalculatorTest : public ::testing::Test {
protected:
    calc::Calculator calc;
};

TEST_F(CalculatorTest, 덧셈_기본테스트) {
    EXPECT_DOUBLE_EQ(calc.add(2.0, 3.0), 5.0);
    EXPECT_DOUBLE_EQ(calc.add(-1.0, 1.0), 0.0);
}

TEST_F(CalculatorTest, 뺄셈_기본테스트) {
    EXPECT_DOUBLE_EQ(calc.subtract(5.0, 3.0), 2.0);
}

TEST_F(CalculatorTest, 곱셈_기본테스트) {
    EXPECT_DOUBLE_EQ(calc.multiply(4.0, 3.0), 12.0);
}

TEST_F(CalculatorTest, 나눗셈_기본테스트) {
    EXPECT_DOUBLE_EQ(calc.divide(10.0, 2.0), 5.0);
}

TEST_F(CalculatorTest, 나눗셈_0으로나누기_예외발생) {
    EXPECT_THROW(calc.divide(10.0, 0.0), std::invalid_argument);
}

🚀 빌드 및 실행

# 빌드
cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
cmake --build build --parallel 4

# 실행
./build/calc_app

# 테스트
cd build
ctest --output-on-failure

# 또는 직접 실행
./build/tests/calculator_tests

📊 CMake vs Make 직접 비교

"그래서 CMake 쓰는 게 나아? Make 쓰는 게 나아?" 라는 질문에 대한 명확한 답을 드릴게:

비교 항목	Make (Makefile)	CMake
학습 곡선	상대적으로 낮음	초기 진입 장벽 있음
크로스 플랫폼	❌ Unix 중심	✅ 완전 지원
IDE 통합	제한적	✅ VS, CLion, VSCode 등
의존성 관리	수동 관리	✅ 자동화
대규모 프로젝트	복잡해짐	✅ 계층적 구조 지원
생태계	성숙함	✅ 매우 활발
빌드 속도	보통	Ninja 연동 시 빠름
디버깅	직관적	복잡할 수 있음

💬 "결론적으로 뭘 써야 해?"

🤖 "신규 프로젝트라면 무조건 CMake! 기존 Makefile 프로젝트 유지보수라면 Make 계속 써도 돼. 근데 크로스 플랫폼이나 팀 협업이 필요하면 CMake로 마이그레이션 강력 추천이야 ㅋㅋㅋ"

💡 CMake 학습 로드맵

1단계 : cmake_minimum_required, project, add_executable 기본 익히기
2단계 : target_* 함수들, PRIVATE/PUBLIC/INTERFACE 이해
3단계 : find_package, FetchContent로 외부 라이브러리 연동
4단계 : 멀티 서브디렉토리 구조, 커스텀 모듈 작성
5단계 : CMakePresets, CI/CD 통합, 패키지 배포

단계별로 차근차근 익히면 어렵지 않아! 재능넷(jaenung.net)에서 C++ 멘토를 찾아 1:1로 배우는 것도 좋은 방법이야 😊

🌟 마무리 - 핵심 정리

자, 여기까지 C++ 빌드 시스템과 CMake/Make에 대해 엄청 많은 내용을 다뤘어!
핵심 포인트만 다시 정리해볼게:

✓

Make는 Makefile 기반의 전통적인 빌드 도구. 탭 들여쓰기 필수, 패턴 규칙으로 효율적인 빌드 가능

✓

CMake는 메타 빌드 시스템. CMakeLists.txt → Makefile/Ninja 등 생성 → 실제 빌드

✓

Modern CMake는 타겟 중심 접근법. target_* 함수들과 PRIVATE/PUBLIC/INTERFACE 키워드가 핵심

✓

외부 라이브러리는 find_package(), FetchContent, vcpkg/Conan 중 상황에 맞게 선택

✓

빌드 최적화는 ccache + Ninja + 병렬 빌드 조합이 가장 효과적

✓

CMakePresets.json으로 팀 전체의 빌드 설정을 표준화하고 CI/CD와 연동

빌드 시스템은 처음엔 복잡해 보이지만, 한 번 제대로 설정해두면 개발 생산성이 엄청나게 올라가.
특히 팀 프로젝트에서 "내 컴퓨터에서는 됐는데?" 같은 상황을 방지하는 데 CMake가 정말 큰 역할을 해 ㅋㅋㅋ

오늘 배운 내용으로 여러분의 C++ 프로젝트 빌드 환경을 한 단계 업그레이드해봐! 화이팅! 🚀

지식인의 숲 - 지적 재산권 보호 고지

지적 재산권 보호 고지

사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.