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 |

심화 부록: 구현·운영 관점

이 부록은 앞선 본문에서 다룬 주제(「C++ 시간 변환 | chrono duration_cast와 시계 변환」)를 구현·런타임·운영 관점에서 다시 압축합니다. 도메인별 세부 구현은 글마다 다르지만, 입력 검증 → 핵심 연산 → 부작용(I/O·네트워크·동시성) → 관측의 흐름으로 장애를 나누면 원인 추적이 빨라집니다.

내부 동작과 핵심 메커니즘

flowchart TD
  A[입력·요청·이벤트] --> B[파싱·검증·디코딩]
  B --> C[핵심 연산·상태 전이]
  C --> D[부작용: I/O·네트워크·동시성]
  D --> E[결과·관측·저장]

sequenceDiagram
  participant C as 클라이언트/호출자
  participant B as 경계(런타임·게이트웨이·프로세스)
  participant D as 의존성(API·DB·큐·파일)
  C->>B: 요청/이벤트
  B->>D: 조회·쓰기·RPC
  D-->>B: 지연·부분 실패·재시도 가능
  B-->>C: 응답 또는 오류(코드·상관 ID)

• 불변 조건(Invariant): 버퍼 경계, 프로토콜 상태, 트랜잭션 격리, FD 상한 등 단계별로 문장으로 적어 두면 디버깅 비용이 줄어듭니다.
• 결정성: 순수 층과 시간·네트워크·스케줄에 의존하는 층을 분리해야 테스트와 장애 분석이 쉬워집니다.
• 경계 비용: 직렬화, 인코딩, syscall 횟수, 락 경합, 할당·GC, 캐시 미스를 의심 목록에 둡니다.
• 백프레셔: 생산자가 소비자보다 빠를 때 버퍼·큐·스트림에서 속도를 줄이는 신호를 어디에 둘지 정의합니다.

프로덕션 운영 패턴

영역	운영 관점 질문
관측성	요청 단위 상관 ID, 에러율·지연 p95/p99, 의존성 타임아웃·재시도가 대시보드에 보이는가
안전성	입력 검증·권한·비밀·감사 로그가 코드 경로마다 일관적인가
신뢰성	재시도는 멱등 연산에만 적용되는가, 서킷 브레이커·백오프·DLQ가 있는가
성능	캐시·배치 크기·커넥션 풀·인덱스·백프레셔가 데이터 규모에 맞는가
배포	롤백 룬북, 카나리/블루그린, 마이그레이션·피처 플래그가 문서화되어 있는가
용량	피크 트래픽·디스크·FD·스레드 풀 상한을 주기적으로 검증하는가

스테이징은 데이터 양·네트워크 RTT·동시성을 프로덕션에 가깝게 맞출수록 재현율이 올라갑니다.

확장 예시: 엔드투엔드 미니 시나리오

앞선 본문 주제(「C++ 시간 변환 | chrono duration_cast와 시계 변환」)를 배포·운영 흐름에 맞춰 옮긴 체크리스트입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.

1. 입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드를 경계에 둔다.
2. 핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 로그·메트릭·트레이스에서 한 흐름으로 본다.
3. 실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
4. 호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지 확인한다.
5. 부하 후 검증: 피크 대비 p95/p99, 에러율, 리소스 상한, 알림 임계값을 점검한다.

handle(request):
  ctx = newCorrelationId()
  validated = validateSchema(request)
  authorize(validated, ctx)
  result = domainCore(validated)
  persistOrEmit(result, idempotentKey)
  recordMetrics(ctx, latency, outcome)
  return result

문제 해결(Troubleshooting)

증상	가능 원인	조치
간헐적 실패	레이스, 타임아웃, 외부 의존성, DNS	최소 재현 스크립트, 분산 트레이스·로그 상관관계, 재시도·서킷 설정 점검
성능 저하	N+1, 동기 I/O, 락 경합, 과도한 직렬화, 캐시 미스	프로파일러·APM으로 핫스팟 확인 후 한 가지씩 제거
메모리 증가	캐시 무제한, 구독/리스너 누수, 대용량 버퍼, 커넥션 미반납	상한·TTL·힙/FD 스냅샷 비교
빌드·배포만 실패	환경 변수, 권한, 플랫폼 차이, lockfile	CI 로그와 로컬 diff, 런타임·이미지 버전 핀
설정 불일치	프로필·시크릿·기본값, 리전	스키마 검증된 설정 단일 소스와 배포 매트릭스 표준화
데이터 불일치	비멱등 재시도, 부분 쓰기, 캐시 무효화 누락	멱등 키·아웃박스·트랜잭션 경계 재검토

권장 순서: (1) 최소 재현 (2) 최근 변경 범위 축소 (3) 환경·의존성 차이 (4) 관측으로 가설 검증 (5) 수정 후 회귀·부하 테스트.

배포 전에는 git add → git commit → git push 후 npm run deploy 순서를 권장합니다.