RustvsC+++Go

01최신 버전 스냅샷

02한눈에 보는 스코어카드 (10점 만점, 2026 기준)

상대 점수. 절대값보다 격차의 방향을 보라.

03문법·언어 모델 차이

같은 일을 하는 코드

파일 줄 수 세서 표준 출력으로 보내는 가장 단순한 시스템 프로그램.

#include <fstream>
#include <iostream>
#include <string>

int main(int argc, char** argv) {
    if (argc < 2) return 1;
    std::ifstream f(argv[1]);
    if (!f) { std::cerr << "open\n"; return 2; }
    int n = 0; std::string line;
    while (std::getline(f, line)) ++n;
    std::cout << n << "\n";
}

use std::{env, fs, io::{BufRead, BufReader}};

fn main() -> std::io::Result<()> {
    let path = env::args().nth(1).expect("path");
    let n = BufReader::new(fs::File::open(path)?)
        .lines().count();
    println!("{n}");
    Ok(())
}

동일 기능이지만 Rust 는 에러 전파를 ? 한 글자로, C++ 는 명시 점검·예외/리턴코드 혼용. 줄 수: C++ 14 / Rust 9.

04성능 — 실제 벤치 분포

05빌드 시간 비교 — Go 포함 / 대규모 분석

대규모 시스템(1M+ LOC)에서는 Go >> Rust ≈ C++. 컴파일러 아키텍처가 본질적으로 다르기 때문.

스케일별 cold / incremental (8 코어, release 빌드 기준)

수치는 보통 사양(8c/32GB)·기본 옵션 기준. 모든 언어가 LTO/-O3 끄면 더 빠름. Rust dev 빌드(opt-level=0) 만 하면 cold 시간 30–50% 절감.

실측 — 실제 OSS 프로젝트 cold release 빌드

왜 이만큼 차이가 나는가 — 컴파일러 아키텍처

대규모(1M+ LOC) 빌드 완화 기법

트레이드오프 — 왜 Go 가 항상 답이 아닌가

06Go 깊게 보기 — 철학·언어 설계·동시성 모델

Go 는 "더 빠른 시스템 언어" 가 아니라 "Google 규모의 분산 서비스를 짜는 데 필요한 최소 도구" 로 출발했다. C++/Rust 와는 다른 차원의 트레이드오프.

탄생 배경 — 왜 만들어졌나

핵심 철학 — 문서화된 가치관

언어 기능 매트릭스 (3-way)

동시성 모델 — Go 의 핵심 차별점

// 백만 개 동시 실행 가능
for i := 0; i < 1_000_000; i++ {
    go func(id int) {
        // ~2KB 스택, 필요 시 자동 grow
        process(id)
    }(i)
}

jobs := make(chan int, 100)
results := make(chan int, 100)

for w := 0; w < 5; w++ {
    go worker(w, jobs, results)
}
for j := 0; j < 50; j++ {
    jobs <- j
}
close(jobs)

버전 진화 타임라인 (주요만)

Go 의 의도적 결핍 (없는 것이 곧 디자인)

적합 분야 (구체 사례)

Go 의 약점 — 정직한 비판

3-way 위치 정리

07안정성 (메모리·동시성·정의된 동작)

08코드 생성 속도 (개발자 + LLM 관점)

09컴퓨터공학적 지원 기능 (현대 PL 기능 매트릭스)

10툴링·생태계

11적합 분야

122026 산업 트렌드 (선별)

13코드 구조 · 빌드 산출물 구조

같은 라이브러리 + 바이너리 프로젝트(greet)를 양 언어로 만들 때의 디렉토리·중간/최종 산출물 차이.

프로젝트 디렉토리 (소스 트리)

greet/
├── CMakeLists.txt        # 빌드 정의 (필수)
├── conanfile.txt         # 외부 의존 (선택)
├── include/
│   └── greet/greet.hpp   # 공개 헤더 (선언)
├── src/
│   ├── greet.cpp         # 라이브러리 구현
│   └── main.cpp          # 바이너리 진입점
├── tests/
│   ├── CMakeLists.txt
│   └── test_greet.cpp    # gtest/Catch2
├── third_party/          # vendored 의존성 (관습)
└── docs/                 # Doxygen

greet/
├── Cargo.toml            # 패키지 + 의존 + 빌드 통합
├── Cargo.lock            # 잠금 파일 (바이너리는 커밋)
├── src/
│   ├── lib.rs            # 라이브러리 root (자동 인식)
│   ├── main.rs           # 바이너리 root (자동 인식)
│   └── greet.rs          # mod greet
├── tests/
│   └── integration.rs    # 통합 테스트 (자동 발견)
├── benches/              # cargo bench
├── examples/             # cargo run --example
└── build.rs              # 선택, 빌드 스크립트

빌드 산출물 디렉토리

build/                        # out-of-source (관습)
├── CMakeCache.txt
├── CMakeFiles/               # 중간 메타
├── compile_commands.json     # clangd/IDE
├── build.ninja
├── _deps/                    # FetchContent 의존
├── CMakeFiles/greet.dir/
│   ├── src/greet.cpp.o       # 오브젝트 파일
│   └── src/main.cpp.o
├── libgreet.a   또는 .so/.dll # 라이브러리
├── greet                     # 실행 바이너리
├── greet.dSYM/               # macOS 디버그
├── greet.pdb                 # Windows 디버그
└── tests/test_greet

target/
├── debug/                    # cargo build (기본)
│   ├── greet                 # 바이너리
│   ├── libgreet.rlib         # Rust 정적 라이브러리
│   ├── libgreet.so/.dylib    # cdylib 시
│   ├── deps/                 # 모든 의존 .rlib
│   ├── build/                # build.rs 산출
│   ├── incremental/          # 증분 캐시
│   └── greet.d               # 의존 그래프
├── release/                  # cargo build --release
│   └── ... (LTO, opt-level=3)
├── doc/                      # cargo doc 산출
└── .rustc_info.json

링크 모델 · ABI

빌드 파이프라인 (단계 비교)

14선택 가이드 — 결정 트리