C++ 시간 변환 | chrono duration_cast와 시계 변환

2026년 3월 12일 · 12분 읽기 · 수정 2026년 3월 12일 중급 튜토리얼

이 글의 핵심

C++ 시간 변환에 대한 실전 가이드입니다. chrono duration_cast와 시계 변환 등을 예제와 함께 상세히 설명합니다.

C++에서 시간 변환

std::chrono에서 단위가 다른 duration, 시계가 다른 time_point를 다룰 때 duration_cast와 time_point_cast를 사용합니다. 실무에서는 타임아웃 설정, 로그 타임스탬프, 스톱워치·벤치마크에서 경과 시간 출력, 파일 수정 시간 비교 등에 자주 쓰입니다.

duration 단위 변환

같은 시계의 duration이라도 rep(표현 타입) 이나 period(단위) 가 다르면 암시적 변환이 안 될 수 있어, duration_cast로 명시적으로 바꿉니다.

#include <chrono>
#include <iostream>

using namespace std::chrono;

auto sec = 90s;

// 큰 단위 -> 작은 단위 (암시적 변환)
auto millis = duration_cast<milliseconds>(sec);  // 90000ms
std::cout << millis.count() << "ms\n";  // 90000ms

// 작은 단위 -> 큰 단위 (명시적 변환, 나머지 버려짐)
auto min = duration_cast<minutes>(sec);   // 1분 (30초 손실)
std::cout << min.count() << "min\n";  // 1min

// 부동소수 초로 정밀도 유지
duration<double> sec_d = sec;  // 90.0, 암시적 변환 가능
std::cout << sec_d.count() << "s\n";  // 90.0s

동작 원리: duration_cast는 period 비율을 계산하여 변환합니다. 예를 들어 초를 밀리초로 바꿀 때는 1000을 곱하고, 밀리초를 초로 바꿀 때는 1000으로 나눕니다 (정수 나눗셈이므로 나머지는 버려짐).

정밀도 손실 예시:

milliseconds ms(1234);
auto sec = duration_cast<seconds>(ms);  // 1s (234ms 손실)

// 정밀도 유지하려면 부동소수 사용
duration<double> sec_precise = ms;  // 1.234s
std::cout << sec_precise.count() << "s\n";  // 1.234

변환 규칙 정리:

변환 방향	변환 방법	정보 손실	예시
큰 → 작은	암시적 OK	없음	`seconds` → `milliseconds`
작은 → 큰	`duration_cast` 필요	나머지 버려짐	`milliseconds` → `seconds`
정수 → 실수	암시적 OK	없음	`duration<int>` → `duration<double>`
실수 → 정수	`duration_cast` 필요	소수점 버려짐	`duration<double>` → `duration<int>`

실무 팁: 나누어떨어지지 않을 때는 duration_cast가 절삭(truncate) 합니다. 반올림이 필요하면 C++17의 floor, ceil, round를 사용하세요.

milliseconds ms(1500);

auto s_cast  = duration_cast<seconds>(ms);  // 1s (절삭)
auto s_floor = floor<seconds>(ms);          // 1s (내림)
auto s_round = round<seconds>(ms);          // 2s (반올림)
auto s_ceil  = ceil<seconds>(ms);           // 2s (올림)

std::cout << "cast: " << s_cast.count() << "s\n";    // 1s
std::cout << "round: " << s_round.count() << "s\n";  // 2s

실무 활용 예시:

// API가 밀리초 정수를 요구할 때
auto timeout = 3s + 500ms;
int timeout_ms = duration_cast<milliseconds>(timeout).count();  // 3500
// socket.set_timeout(timeout_ms);

// 로그에 초 단위로 출력 (정밀도 유지)
auto elapsed = 1234ms;
duration<double, std::milli> elapsed_d = elapsed;
double seconds = elapsed_d.count() / 1000.0;
std::cout << "Elapsed: " << seconds << "s\n";  // 1.234s

time_point 변환 (같은 시계)

time_point_cast는 같은 시계 내에서만 사용합니다. 해상도를 낮춰 초 단위로 맞추거나, 나노초를 밀리초로 줄일 때 씁니다.

#include <chrono>
#include <iostream>

using namespace std::chrono;

system_clock::time_point tp = system_clock::now();

// 나노초 -> 초 단위로 변환 (해상도 낮춤)
auto as_sec = time_point_cast<seconds>(tp);
std::cout << "Seconds: " << as_sec.time_since_epoch().count() << "\n";

// 나노초 -> 밀리초 단위로 변환
auto as_ms = time_point_cast<milliseconds>(tp);
std::cout << "Milliseconds: " << as_ms.time_since_epoch().count() << "\n";

왜 필요한가?:

로그 타임스탬프: 초 단위만 필요할 때 나노초 정밀도는 불필요
캐시 키: 초 단위로 만들어 같은 초 내 요청은 동일 키 사용
데이터베이스 저장: DB가 밀리초까지만 지원할 때

실무 예시:

// 로그에 초 단위 타임스탬프 출력
auto now = system_clock::now();
auto now_sec = time_point_cast<seconds>(now);
auto time_t = system_clock::to_time_t(now_sec);
std::cout << "Log at: " << std::ctime(&time_t);

// 캐시 키를 초 단위로 생성 (같은 초 내 요청은 동일 키)
auto cache_key = time_point_cast<seconds>(now).time_since_epoch().count();
std::cout << "Cache key: " << cache_key << "\n";

시계가 다른 time_point 변환

system_clock과 steady_clock은 서로 다른 시계이므로, time_point를 직접 대입할 수 없습니다. 둘 다 “현재 시점”을 표현할 뿐, system_clock은 wall-clock(실제 시간), steady_clock은 monotonic(재부팅 후 경과 시간)입니다. 실무에서는 보통 duration으로 바꾼 뒤 목적 시계의 epoch부터의 duration을 더해 새 time_point를 만드는 방식을 씁니다.

// system_clock time_point -> epoch부터의 duration
auto since_epoch = tp.time_since_epoch();
// 다른 시계로 변환하려면 설계가 필요 (일반적으로 system ↔ steady 직접 변환은 권장하지 않음)

파일 시간 (C++20)

std::filesystem::file_time_type은 구현에 따라 보통 system_clock 기반입니다. 파일 수정 시간을 system_clock::time_point와 비교하거나, duration을 구할 때 변환이 필요할 수 있습니다.

#include <filesystem>
#include <chrono>
#include <iostream>

namespace fs = std::filesystem;
using namespace std::chrono;

// 파일 수정 시간 비교
auto t1 = fs::last_write_time("file1.txt");
auto t2 = fs::last_write_time("file2.txt");

// 두 파일 수정 시간 차이 계산
auto diff = t1 - t2;  // duration
auto diff_sec = duration_cast<seconds>(diff);
std::cout << "Time difference: " << diff_sec.count() << "s\n";

// 파일이 최근 1시간 내 수정되었는지 확인
auto now = fs::file_time_type::clock::now();
auto file_time = fs::last_write_time("file.txt");
auto age = now - file_time;
if (age < 1h) {
    std::cout << "File modified recently\n";
}

실무 활용 - 캐시 무효화:

// 파일이 마지막 빌드 이후 변경되었는지 확인
fs::file_time_type last_build_time = get_last_build_time();
fs::file_time_type source_time = fs::last_write_time("source.cpp");

if (source_time > last_build_time) {
    std::cout << "Source file changed, rebuilding...\n";
    rebuild();
}

실무 활용 - 파일 나이 확인:

// 임시 파일이 24시간 이상 오래되었으면 삭제
auto file_time = fs::last_write_time("temp.dat");
auto now = fs::file_time_type::clock::now();
auto age = now - file_time;

if (age > 24h) {
    std::cout << "Deleting old temp file\n";
    fs::remove("temp.dat");
}

주의사항: C++20 이전에는 file_time_type이 system_clock과 직접 호환되지 않을 수 있습니다. C++20부터는 file_clock::to_sys(), file_clock::from_sys()로 변환 가능합니다.

// C++20: file_time_type <-> system_clock 변환
auto file_time = fs::last_write_time("file.txt");
auto sys_time = file_clock::to_sys(file_time);  // system_clock::time_point
auto time_t = system_clock::to_time_t(sys_time);
std::cout << "File modified at: " << std::ctime(&time_t);

// 반대 방향: system_clock -> file_time_type
auto now_sys = system_clock::now();
auto now_file = file_clock::from_sys(now_sys);
fs::last_write_time("file.txt", now_file);  // 파일 시간 설정

실전 예시: 타임아웃을 밀리초로 전달

API가 밀리초 정수를 받을 때, chrono duration을 변환해 넘기는 패턴입니다.

using namespace std::chrono;

auto timeout = 3s;
int timeout_ms = duration_cast<milliseconds>(timeout).count();  // 3000
// socket.set_timeout(timeout_ms);

실전 예시: 경과 시간을 초 단위로 출력

스톱워치·벤치마크나 로그에서 “몇 초 걸렸다”를 보여줄 때, duration을 초(또는 밀리초)로 바꿔 출력합니다.

auto start = steady_clock::now();
// ... 작업 ...
auto elapsed = steady_clock::now() - start;
double sec = duration<double>(elapsed).count();
std::cout << "elapsed: " << sec << " s\n";

실무 패턴

패턴 1: 타임아웃 설정

// 네트워크 타임아웃을 chrono로 관리
class NetworkClient {
    milliseconds timeout_ = 30s;  // 기본 30초
public:
    void set_timeout(milliseconds t) { timeout_ = t; }
    
    void connect() {
        // API가 밀리초 정수를 요구
        int timeout_ms = duration_cast<milliseconds>(timeout_).count();
        // socket.set_timeout(timeout_ms);
    }
    
    bool wait_for_response() {
        auto start = steady_clock::now();
        while (true) {
            // ... 응답 확인 ...
            auto elapsed = steady_clock::now() - start;
            if (elapsed > timeout_) {
                return false;  // 타임아웃
            }
        }
    }
};

패턴 2: 로그 타임스탬프

// 로그에 밀리초 정밀도 타임스탬프 추가
void log(const std::string& msg) {
    auto now = system_clock::now();
    auto ms = time_point_cast<milliseconds>(now);
    auto time_t = system_clock::to_time_t(now);
    
    // "2026-03-12 14:23:45.123 Message"
    char buf[64];
    std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", std::localtime(&time_t));
    std::cout << buf << "." 
              << (ms.time_since_epoch().count() % 1000) << " "
              << msg << "\n";
}

패턴 3: 경과 시간 측정

// 벤치마크 결과를 다양한 단위로 출력
template<typename Func>
void benchmark(Func f) {
    auto start = steady_clock::now();
    f();
    auto elapsed = steady_clock::now() - start;
    
    auto ns = duration_cast<nanoseconds>(elapsed);
    auto us = duration_cast<microseconds>(elapsed);
    auto ms = duration_cast<milliseconds>(elapsed);
    
    std::cout << "Elapsed: " << ns.count() << "ns ("
              << us.count() << "us, "
              << ms.count() << "ms)\n";
}

패턴 4: 파일 캐시 무효화

// 소스 파일이 변경되었으면 재빌드
class BuildSystem {
    std::map<std::string, fs::file_time_type> last_build_times_;
    
public:
    bool needs_rebuild(const std::string& source_file) {
        auto current_time = fs::last_write_time(source_file);
        
        if (last_build_times_.count(source_file) == 0) {
            return true;  // 처음 빌드
        }
        
        return current_time > last_build_times_[source_file];
    }
    
    void mark_built(const std::string& source_file) {
        last_build_times_[source_file] = fs::last_write_time(source_file);
    }
};

자주 발생하는 문제

duration_cast는 절삭: 1500ms를 초로 cast하면 1초입니다. 반올림이 필요하면 round, floor, ceil 사용.
시계 혼동: system_clock과 steady_clock을 섞어 쓰지 말고, “실제 시간”은 system, “경과 시간·타임아웃”은 steady로 통일하는 것이 좋습니다.
정수 오버플로우: 매우 긴 duration을 작은 단위로 cast할 때 count()가 정수 범위를 넘지 않는지 확인하세요.

정리

항목	설명
duration	duration_cast로 다른 단위로 변환, floor/ceil/round로 반올림 제어
time_point	time_point_cast로 같은 시계 내에서 해상도만 변경
파일 시간	file_time_type은 보통 system_clock과 호환, 구현 문서 확인

관련 글: duration 시간 간격, time_point 시점 표현, chrono 개요, 스톱워치와 벤치마크.

한 줄 요약: chrono에서 duration_cast·time_point_cast로 단위와 해상도를 바꾸고, 파일 시간은 system_clock과 호환되는지 구현을 확인해 사용하면 됩니다.

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

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

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

이 글에서 다루는 키워드 (관련 검색어)

C++, chrono, duration, time_point, duration_cast, time conversion 등으로 검색하시면 이 글이 도움이 됩니다.

자주 묻는 질문 (FAQ)

Q. 이 내용을 실무에서 언제 쓰나요?

A. C++ chrono 시간 변환. duration_cast, system_clock·steady_clock, time_point와 duration 간 변환, 파일 시간 타입. 실무에서는 위 본문의 예제와 선택 가이드를 참고해 적용하면 됩니다.

Q. 선행으로 읽으면 좋은 글은?

A. 각 글 하단의 이전 글 또는 관련 글 링크를 따라가면 순서대로 배울 수 있습니다. C++ 시리즈 목차에서 전체 흐름을 확인할 수 있습니다.

Q. 더 깊이 공부하려면?

A. cppreference와 해당 라이브러리 공식 문서를 참고하세요. 글 말미의 참고 자료 링크도 활용하면 좋습니다.

C++ std::chrono 완벽 가이드 | duration·time_point·클럭·시간 측정 실전 활용
C++ Chrono 상세 가이드 |
C++ duration |
C++ time_point |
C++ Calendar & Timezone |