C++ ratio | "컴파일 타임 분수" 가이드

ratio란?

std::ratio 는 C++11에서 도입된 컴파일 타임 분수 타입입니다. 분자와 분모를 템플릿 인자로 받아 컴파일 타임에 분수 연산을 수행하며, 자동으로 약분됩니다. 주로 std::chrono와 함께 사용됩니다.

#include <ratio>
using namespace std;

int main() {
    using OneHalf = ratio<1, 2>;
    
    cout << OneHalf::num << "/" << OneHalf::den << endl;  // 1/2
    
    // 자동 약분
    using TwoFourths = ratio<2, 4>;
    cout << TwoFourths::num << "/" << TwoFourths::den << endl;  // 1/2
}

왜 필요한가?:

• 타입 안전: 컴파일 타임에 단위 검증
• 정확성: 정수 분수로 부동소수점 오차 없음
• 성능: 런타임 비용 없음
• 표준 라이브러리: chrono::duration의 기반

// ❌ 런타임 분수: 부동소수점 오차
double oneThird = 1.0 / 3.0;  // 0.333333...

// ✅ 컴파일 타임 분수: 정확
using OneThird = std::ratio<1, 3>;
// num=1, den=3 (정확한 1/3 표현)

자동 약분:

using R1 = std::ratio<2, 4>;   // 1/2로 약분
using R2 = std::ratio<6, 9>;   // 2/3으로 약분
using R3 = std::ratio<100, 25>; // 4/1로 약분

std::cout << R1::num << "/" << R1::den << '\n';  // 1/2
std::cout << R2::num << "/" << R2::den << '\n';  // 2/3
std::cout << R3::num << "/" << R3::den << '\n';  // 4/1

컴파일 타임 분수 연산의 의미

std::ratio 계열 타입은 값이 아니라 타입입니다. ratio_add, ratio_multiply 등은 별칭 템플릿으로, 결과 역시 std::ratio<num, den>의 한 형태입니다. 즉 “런타임에 분수를 계산”하는 것이 아니라, 단위가 맞는지·스케일이 무엇인지를 컴파일 타임에 확정합니다.

• 정확성: 부동소수점으로 0.1초를 누적하는 대신, milli vs micro를 타입으로 구분.
• 최적화: duration의 operator+ 등은 같은 Rep로 정규화할 때 비율만 템플릿 인스턴스화로 처리.

분수 연산

using Half = ratio<1, 2>;
using Third = ratio<1, 3>;

// 덧셈
using Sum = ratio_add<Half, Third>;
cout << Sum::num << "/" << Sum::den << endl;  // 5/6

// 뺄셈
using Diff = ratio_subtract<Half, Third>;
cout << Diff::num << "/" << Diff::den << endl;  // 1/6

// 곱셈
using Prod = ratio_multiply<Half, Third>;
cout << Prod::num << "/" << Prod::den << endl;  // 1/6

// 나눗셈
using Quot = ratio_divide<Half, Third>;
cout << Quot::num << "/" << Quot::den << endl;  // 3/2

비교

using Half = ratio<1, 2>;
using Third = ratio<1, 3>;

cout << ratio_equal<Half, ratio<2, 4>>::value << endl;     // 1
cout << ratio_less<Third, Half>::value << endl;            // 1
cout << ratio_greater<Half, Third>::value << endl;         // 1

chrono와 함께

#include <chrono>

int main() {
    // duration<int, ratio<1, 1000>> = milliseconds
    using MyMilliseconds = chrono::duration<int, milli>;
    
    MyMilliseconds ms(1000);
    
    // 초로 변환
    auto sec = chrono::duration_cast<chrono::seconds>(ms);
    cout << sec.count() << "초" << endl;  // 1
}

chrono::duration과 ratio:

std::chrono::duration은 내부적으로 std::ratio를 사용하여 시간 단위를 표현합니다.

// duration 정의
template<typename Rep, typename Period = std::ratio<1>>
class duration;

// 표준 duration 타입
using nanoseconds  = duration<int64_t, std::nano>;   // ratio<1, 1000000000>
using microseconds = duration<int64_t, std::micro>;  // ratio<1, 1000000>
using milliseconds = duration<int64_t, std::milli>;  // ratio<1, 1000>
using seconds      = duration<int64_t>;              // ratio<1>
using minutes      = duration<int, std::ratio<60>>;
using hours        = duration<int, std::ratio<3600>>;

duration과의 관계(정규화)

std::chrono::duration<Rep, Period>에서 Period는 std::ratio를 나타내는 타입입니다. 서로 다른 duration을 더하거나 빼면, 구현은 보통 공통 분모로 맞춘 하나의 duration 타입으로 결과를 만듭니다. 사용자 입장에서는 “나노초 + 마이크로초”를 직접 고민하지 않고 duration_cast로 원하는 단위만 고르면 됩니다.

using ns = std::chrono::duration<int64_t, std::nano>;
using us = std::chrono::duration<int64_t, std::micro>;
ns a{500};
us b{1};
auto sum = a + b;  // Rep/Period는 구현에 따라 정규화된 타입

타입 안전성 측면: duration<double, std::milli>와 duration<int, std::milli>를 섞으면 Rep 타입 때문에 주의가 필요합니다. 시간 단위는 ratio로, 누적값의 성격(정수 틱 vs 실수 초)은 Rep로 나누어 생각하면 실수가 줄어듭니다.

커스텀 duration 만들기:

// 1/60초 (프레임 단위)
using Frames = std::chrono::duration<int, std::ratio<1, 60>>;

// 1일
using Days = std::chrono::duration<int, std::ratio<86400>>;

// 1주
using Weeks = std::chrono::duration<int, std::ratio<604800>>;

int main() {
    Frames frames(120);  // 120프레임
    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(frames);
    std::cout << seconds.count() << "초\n";  // 2초
    
    Days days(7);
    Weeks weeks = std::chrono::duration_cast<Weeks>(days);
    std::cout << weeks.count() << "주\n";  // 1주
}

실무 활용:

// 게임 프레임 타이밍
using Frames60 = std::chrono::duration<double, std::ratio<1, 60>>;

Frames60 frameTime(1.0);  // 1프레임 (1/60초)
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(frameTime);
std::cout << ms.count() << "ms\n";  // 16ms

실전 활용과 타입 안전성

• 물리 단위 라이브러리: 길이·질량 등을 ratio로 스케일만 다르게 두면, ratio_divide로 단위 차원을 맞춘 변환 계수를 컴파일 타임에 얻을 수 있습니다.
• 샘플 레이트: 오디오에서 44.1kHz vs 48kHz처럼 서로 다른 Period를 가진 duration으로 표현하면, 리샘플링 코드에서 “틱 단위” 혼동을 줄입니다.
• 주의: std::ratio의 num/den은 std::intmax_t 범위입니다. 극단적으로 큰 분모/분자 조합은 오버플로를 일으킬 수 있으므로, SI 접두사 조합은 표준 typedef(std::milli, std::kilo 등)를 우선 사용하세요.

실전 예시

예시 1: 단위 변환

template<typename Ratio>
class Distance {
private:
    double value;
    
public:
    Distance(double v) : value(v) {}
    
    double getValue() const { return value; }
    
    template<typename OtherRatio>
    Distance<OtherRatio> to() const {
        using ConversionRatio = ratio_divide<Ratio, OtherRatio>;
        double converted = value * ConversionRatio::num / ConversionRatio::den;
        return Distance<OtherRatio>(converted);
    }
};

using Meters = Distance<ratio<1, 1>>;
using Kilometers = Distance<ratio<1000, 1>>;
using Centimeters = Distance<ratio<1, 100>>;

int main() {
    Meters m(1000);
    
    auto km = m.to<ratio<1000, 1>>();
    cout << km.getValue() << " km" << endl;  // 1
    
    auto cm = m.to<ratio<1, 100>>();
    cout << cm.getValue() << " cm" << endl;  // 100000
}

예시 2: 속도 계산

template<typename DistanceRatio, typename TimeRatio>
class Speed {
public:
    double value;
    
    Speed(double v) : value(v) {}
};

using MetersPerSecond = Speed<ratio<1>, ratio<1>>;
using KilometersPerHour = Speed<ratio<1000>, ratio<3600>>;

int main() {
    MetersPerSecond mps(10);
    
    // m/s → km/h
    double kmh = mps.value * 3600 / 1000;
    cout << kmh << " km/h" << endl;  // 36
}

예시 3: 주파수

using Hertz = ratio<1, 1>;
using Kilohertz = ratio<1000, 1>;
using Megahertz = ratio<1000000, 1>;

template<typename Ratio>
class Frequency {
private:
    double value;
    
public:
    Frequency(double v) : value(v) {}
    
    double toHertz() const {
        return value * Ratio::num / Ratio::den;
    }
};

int main() {
    Frequency<Megahertz> cpu(3.5);  // 3.5 GHz
    
    cout << cpu.toHertz() << " Hz" << endl;  // 3500000000
}

표준 ratio

// SI 접두사
using atto  = ratio<1, 1000000000000000000>;
using femto = ratio<1, 1000000000000000>;
using pico  = ratio<1, 1000000000000>;
using nano  = ratio<1, 1000000000>;
using micro = ratio<1, 1000000>;
using milli = ratio<1, 1000>;
using centi = ratio<1, 100>;
using deci  = ratio<1, 10>;
using deca  = ratio<10, 1>;
using hecto = ratio<100, 1>;
using kilo  = ratio<1000, 1>;
using mega  = ratio<1000000, 1>;
using giga  = ratio<1000000000, 1>;
using tera  = ratio<1000000000000, 1>;

자주 발생하는 문제

문제 1: 오버플로우

// ❌ 오버플로우
using Big = ratio<INT_MAX, 1>;
using Bigger = ratio_multiply<Big, ratio<2, 1>>;  // 오버플로우

// ✅ 적절한 범위
using Safe = ratio<1000, 1>;

문제 2: 런타임 계산

// ❌ 런타임 계산 불가
int n = 5;
// using MyRatio = ratio<n, 10>;  // 에러

// ✅ 컴파일 타임 상수
constexpr int N = 5;
using MyRatio = ratio<N, 10>;

실무 패턴

패턴 1: 타입 안전 단위 시스템

template<typename Ratio>
class Length {
    double value_;
    
public:
    explicit Length(double v) : value_(v) {}
    
    double value() const { return value_; }
    
    template<typename OtherRatio>
    Length<OtherRatio> to() const {
        using Conv = std::ratio_divide<Ratio, OtherRatio>;
        double converted = value_ * static_cast<double>(Conv::num) / Conv::den;
        return Length<OtherRatio>(converted);
    }
};

using Meters = Length<std::ratio<1>>;
using Kilometers = Length<std::kilo>;
using Centimeters = Length<std::centi>;

// 사용
Meters m(1500);
auto km = m.to<std::kilo>();
std::cout << km.value() << " km\n";  // 1.5 km

패턴 2: 프레임 레이트 계산

template<int FPS>
class FrameTimer {
    using FrameDuration = std::chrono::duration<double, std::ratio<1, FPS>>;
    
    std::chrono::steady_clock::time_point lastFrame_;
    
public:
    FrameTimer() : lastFrame_(std::chrono::steady_clock::now()) {}
    
    bool shouldUpdate() {
        auto now = std::chrono::steady_clock::now();
        auto elapsed = now - lastFrame_;
        
        if (elapsed >= FrameDuration(1)) {
            lastFrame_ = now;
            return true;
        }
        return false;
    }
};

// 60 FPS 타이머
FrameTimer<60> timer;

while (running) {
    if (timer.shouldUpdate()) {
        update();
        render();
    }
}

패턴 3: 비율 계산

// 화면 비율
using AspectRatio16_9 = std::ratio<16, 9>;
using AspectRatio4_3 = std::ratio<4, 3>;

template<typename Ratio>
int calculateHeight(int width) {
    return width * Ratio::den / Ratio::num;
}

int main() {
    int width = 1920;
    
    int height16_9 = calculateHeight<AspectRatio16_9>(width);
    std::cout << "16:9 - " << width << "x" << height16_9 << '\n';  // 1920x1080
    
    int height4_3 = calculateHeight<AspectRatio4_3>(width);
    std::cout << "4:3 - " << width << "x" << height4_3 << '\n';  // 1920x1440
}

FAQ

Q1: ratio는 언제 사용하나요?

A:

• std::chrono::duration의 시간 단위 정의
• 타입 안전 단위 시스템 구현
• 컴파일 타임 분수 연산

Q2: 런타임 분수 계산은 어떻게 하나요?

A: std::ratio는 컴파일 타임 전용입니다. 런타임 분수는 double 또는 별도의 분수 클래스를 사용하세요.

// 컴파일 타임
using Half = std::ratio<1, 2>;

// 런타임
double half = 1.0 / 2.0;

Q3: 성능 영향은?

A: 없습니다. 모든 계산이 컴파일 타임에 수행되므로 런타임 오버헤드가 없습니다.

Q4: 오버플로우는 어떻게 방지하나요?

A: std::ratio는 std::intmax_t를 사용하므로 큰 값도 지원하지만, 매우 큰 값은 오버플로우 가능합니다. 적절한 범위를 사용하세요.

// ✅ 안전
using Safe = std::ratio<1000000, 1>;

// ⚠️ 주의: 매우 큰 값
// using Unsafe = std::ratio<INTMAX_MAX, 1>;

Q5: ratio를 런타임 값으로 변환하려면?

A: num과 den을 사용하여 double로 변환합니다.

using OneThird = std::ratio<1, 3>;
double value = static_cast<double>(OneThird::num) / OneThird::den;
std::cout << value << '\n';  // 0.333333...

Q6: 음수 ratio를 만들 수 있나요?

A: 가능합니다. 분자가 음수이면 전체 ratio가 음수입니다.

using NegativeHalf = std::ratio<-1, 2>;
std::cout << NegativeHalf::num << "/" << NegativeHalf::den << '\n';  // -1/2

Q7: ratio 학습 리소스는?

A:

• cppreference.com - std::ratio
• “The C++ Standard Library” by Nicolai Josuttis
• std::chrono 문서

관련 글: std::chrono::duration, Time Conversion.

한 줄 요약: std::ratio는 컴파일 타임 분수 타입으로, 자동 약분되며 chrono::duration의 시간 단위를 정의합니다.

---

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

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

• C++ duration | “시간 간격” 가이드
• C++ time_point | “시간 지점” 가이드
• C++ Chrono | “시간” 라이브러리 완벽 가이드

관련 글

• C++ Chrono 완벽 가이드 |
• C++ Chrono 상세 가이드 |
• C++ duration |
• C++ steady_clock |
• C++ time_point |