C++ time_point: 시계별 시점, 해상도 변환(floor·round), 파일 시간 변환

time_point란?

std::chrono::time_point는 특정 시계 위의 한 시점을 나타냅니다. duration과 함께 사용되며, 시간 변환에서 time_point_cast로 해상도를 바꿀 수 있으며, 스톱워치·벤치마크에서 경과 시간을 잴 때 now()로 기준점을 잡습니다.

#include <chrono>

auto now = std::chrono::system_clock::now();
auto epoch = std::chrono::system_clock::time_point{};

기본 사용

using namespace std::chrono;

// 현재 시간
auto now = system_clock::now();

// epoch 이후 시간
auto duration = now.time_since_epoch();
auto ms = duration_cast<milliseconds>(duration);

std::cout << ms.count() << "ms" << std::endl;

동작 원리: time_point는 epoch(기준 시점) 으로부터의 duration을 저장합니다. system_clock의 epoch는 1970-01-01 00:00:00 UTC이며, C++20부터는 표준이 이를 명시합니다(윤초는 세지 않는 Unix 시간 기준).

ms.count()로 꺼낸 정수는 어디까지나 “epoch 이후 밀리초”라는 약속이 붙은 숫자입니다. time_point를 타입으로 들고 다니는 동안에는 컴파일러가 시계와 단위를 추적해 주지만, count()로 정수를 꺼내는 순간 그 정보가 사라집니다. 그래서 count()는 로그 출력이나 직렬화처럼 경계에서만 쓰고, 계산은 가능한 한 time_point와 duration 타입 그대로 하는 것이 단위 실수를 막는 가장 확실한 방법입니다.

// time_point 구조 (개념적)
template<typename Clock, typename Duration>
class time_point {
    Duration d_;  // epoch로부터의 duration
public:
    Duration time_since_epoch() const { return d_; }
};

실전 예시

예시 1: 시간 측정

auto start = std::chrono::steady_clock::now();

// 작업
std::this_thread::sleep_for(std::chrono::seconds(1));

auto end = std::chrono::steady_clock::now();
auto elapsed = end - start;

auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(elapsed);
std::cout << "경과: " << ms.count() << "ms" << std::endl;

end - start의 결과 타입은 steady_clock::duration으로, 대부분의 구현에서 나노초 단위입니다. 이 값을 그대로 count()하면 1초가 1000000000으로 찍히므로 출력 전에 duration_cast로 단위를 맞춥니다. sleep_for(1s)는 “최소 1초”를 보장할 뿐이라 실제로는 1001ms, 1002ms처럼 조금 더 긴 값이 나옵니다. 스케줄러가 스레드를 깨우는 데 걸리는 시간이 더해지기 때문이며, 이 차이를 버그로 오해해 테스트에서 == 1000을 기대하면 간헐적으로 실패합니다.

예시 2: 타임스탬프

auto now = std::chrono::system_clock::now();
auto timestamp = std::chrono::system_clock::to_time_t(now);

std::cout << "타임스탬프: " << timestamp << std::endl;
std::cout << "시간: " << std::ctime(&timestamp);

예시 3: 미래 시간

using namespace std::chrono;

auto now = system_clock::now();
auto future = now + hours(24);  // 24시간 후

auto futureTime = system_clock::to_time_t(future);
std::cout << "24시간 후: " << std::ctime(&futureTime);

std::ctime과 std::localtime은 내부 정적 버퍼를 돌려주므로 스레드 안전하지 않고, 두 번 연달아 호출하면 앞의 결과가 덮어써집니다. 멀티스레드 서버의 로그 코드에서는 POSIX의 localtime_r이나 Windows의 localtime_s를 쓰거나, C++20 std::format("{:%F %T}", tp)를 쓰는 편이 안전합니다. 또 “24시간 후”와 “내일 같은 시각”은 같지 않다는 점도 기억해야 합니다. system_clock은 UTC 기반이라 + hours(24)는 정확히 86400초 뒤이고, 서머타임이 바뀌는 날에는 로컬 벽시계 기준으로 23시간이나 25시간 뒤의 시각이 됩니다. 달력 기준 “하루 뒤”가 필요하면 C++20의 year_month_day와 zoned_time으로 계산해야 합니다.

예시 4: 시간 비교

auto t1 = std::chrono::system_clock::now();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
auto t2 = std::chrono::system_clock::now();

if (t2 > t1) {
    std::cout << "t2가 나중" << std::endl;
}

auto diff = t2 - t1;

시계 종류

// system_clock: 시스템 시간
auto sys = std::chrono::system_clock::now();

// steady_clock: 단조 증가
auto steady = std::chrono::steady_clock::now();

// high_resolution_clock: 고정밀
auto high = std::chrono::high_resolution_clock::now();

시계별 특성:

시계	특성	epoch	사용 시나리오
system_clock	실제 시각, 시스템 시간 변경 영향	1970-01-01 UTC	타임스탬프, 파일 시간
steady_clock	단조 증가, 시스템 시간 변경 무관	구현 의존	경과 시간, 타임아웃
high_resolution_clock	최고 해상도	구현 의존	짧은 구간 측정

실무 권장:

• 실제 시각 필요: system_clock (로그, 파일 수정 시간)
• 경과 시간 측정: steady_clock (타임아웃, 벤치마크)

high_resolution_clock은 이름 때문에 벤치마크에 쓰고 싶어지지만, 표준은 이것이 독립된 시계일 것을 요구하지 않습니다. libstdc++(GCC)에서는 system_clock의 별칭이고, libc++와 MSVC에서는 steady_clock의 별칭입니다. 즉 GCC 환경에서 high_resolution_clock으로 경과 시간을 재면 사실상 system_clock으로 재는 것이라 NTP 조정의 영향을 받습니다. 게다가 요즘 플랫폼에서는 steady_clock도 나노초 단위라 해상도 이점이 없으므로, 경과 시간 측정에는 처음부터 steady_clock을 쓰는 것이 이식성 있는 선택입니다. static_assert(std::chrono::steady_clock::is_steady);로 가정을 코드에 남겨 둘 수도 있습니다.

// ✅ 로그 타임스탬프: system_clock
auto now = system_clock::now();
auto time_t = system_clock::to_time_t(now);
std::cout << "Log at: " << std::ctime(&time_t);

// ✅ 경과 시간 측정: steady_clock
auto start = steady_clock::now();
// ... 작업 ...
auto elapsed = steady_clock::now() - start;

자주 발생하는 문제

문제 1: 시계 변경

// ❌ system_clock (시스템 시간 변경 영향)
auto start = std::chrono::system_clock::now();
// 시스템 시간 변경
auto end = std::chrono::system_clock::now();
// 음수 duration 가능

// ✅ steady_clock
auto start = std::chrono::steady_clock::now();
auto end = std::chrono::steady_clock::now();
// 음수가 되지 않음 (연속 호출이면 0일 수는 있음)

system_clock이 뒤로 가는 상황은 생각보다 흔합니다. 가상 머신이 일시 정지됐다가 재개되면서 호스트 시각에 맞춰 한 번에 보정되거나, 부팅 직후 NTP가 처음 동기화하면서 수 초에서 수 분이 튀는 경우가 대표적입니다. 이때 system_clock으로 계산한 타임아웃은 음수가 되어 즉시 만료되거나, 반대로 시계가 앞으로 튀면 한참 뒤에나 만료됩니다. steady_clock은 이런 보정의 영향을 받지 않는 대신 epoch가 “부팅 시점” 같은 구현 의존 값이라 다른 프로세스나 재부팅 이후와는 비교할 수 없습니다. Linux에서 steady_clock은 보통 CLOCK_MONOTONIC이라 시스템이 절전 상태였던 시간은 포함하지 않는다는 점도 알아 두면 좋습니다.

문제 2: 시계 호환

auto sys = std::chrono::system_clock::now();
auto steady = std::chrono::steady_clock::now();

// ❌ 다른 시계 비교
// auto diff = sys - steady;  // 에러

// 같은 시계 사용

문제 3: 정밀도

auto now = std::chrono::system_clock::now();
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
    now.time_since_epoch()
);

// 밀리초 이하 정보 손실

문제 4: 타임존

// system_clock은 UTC
auto now = std::chrono::system_clock::now();
auto tt = std::chrono::system_clock::to_time_t(now);

// 로컬 시간 변환
std::cout << std::ctime(&tt);  // 로컬 시간

C++20 타임존 지원:

#include <chrono>
#include <iostream>

using namespace std::chrono;

// UTC 시간
auto now = system_clock::now();

// 로컬 타임존
auto local = zoned_time{current_zone(), now};
std::cout << "Local: " << local << '\n';

// 특정 타임존
auto ny = zoned_time{"America/New_York", now};
auto tokyo = zoned_time{"Asia/Tokyo", now};

std::cout << "New York: " << ny << '\n';
std::cout << "Tokyo: " << tokyo << '\n';

이 코드는 표준에는 C++20부터 들어 있지만 표준 라이브러리 구현이 늦게 따라왔습니다. MSVC는 비교적 일찍 지원했고, GCC의 libstdc++는 GCC 14부터 타임존 데이터베이스(current_zone, zoned_time)를 제대로 지원합니다. 그보다 오래된 컴파일러에서 'zoned_time' is not a member of 'std::chrono' 같은 에러가 나면 코드가 아니라 라이브러리 버전 문제이며, 이 경우 C++20 chrono의 기반이 된 Howard Hinnant의 date 라이브러리(date/tz.h)를 쓰는 것이 일반적인 우회책입니다. 컨테이너 이미지에서 실행할 때는 /usr/share/zoneinfo(tzdata 패키지)가 없어서 current_zone()이 예외를 던지는 경우도 있습니다.

시간 연산

using namespace std::chrono;

auto now = system_clock::now();

// 더하기
auto future = now + hours(1);

// 빼기
auto past = now - minutes(30);

// 차이
auto diff = future - past;

연산 규칙:

연산	결과 타입	예시
time_point + duration	time_point	now + 1h
time_point - duration	time_point	now - 30min
time_point - time_point	duration	end - start
time_point == time_point	bool	t1 == t2
time_point < time_point	bool	t1 < t2

실무 예시:

// 타임아웃 체크
auto deadline = steady_clock::now() + 5s;
while (steady_clock::now() < deadline) {
    if (try_operation()) break;
    std::this_thread::sleep_for(100ms);
}

// 파일 나이 확인
auto file_time = fs::last_write_time("file.txt");
auto now = fs::file_time_type::clock::now();
auto age = now - file_time;
if (age > 24h) {
    std::cout << "파일이 24시간 이상 오래됨\n";
}

실무 패턴

패턴 1: 타임아웃 체크

class TimeoutChecker {
    steady_clock::time_point deadline_;
    
public:
    TimeoutChecker(milliseconds timeout) 
        : deadline_(steady_clock::now() + timeout) {}
    
    bool expired() const {
        return steady_clock::now() >= deadline_;
    }
    
    milliseconds remaining() const {
        auto now = steady_clock::now();
        if (now >= deadline_) return milliseconds::zero();
        return duration_cast<milliseconds>(deadline_ - now);
    }
};

// 사용
TimeoutChecker checker(5s);
while (!checker.expired()) {
    std::cout << "남은 시간: " << checker.remaining().count() << "ms\n";
    std::this_thread::sleep_for(1s);
}

패턴 2: 주기적 작업

class PeriodicTask {
    steady_clock::time_point next_run_;
    milliseconds interval_;
    
public:
    PeriodicTask(milliseconds interval) 
        : next_run_(steady_clock::now()), interval_(interval) {}
    
    bool should_run() {
        auto now = steady_clock::now();
        if (now >= next_run_) {
            next_run_ = now + interval_;
            return true;
        }
        return false;
    }
};

// 사용
PeriodicTask task(1s);  // 1초마다
while (true) {
    if (task.should_run()) {
        std::cout << "작업 실행\n";
    }
    std::this_thread::sleep_for(100ms);
}

next_run_ = now + interval_은 “실행한 시점부터 다시 1초”라서, 폴링 간격(100ms)만큼의 지연이 매번 누적되어 실제 주기가 1.0~1.1초 사이로 흔들리고 장기적으로 밀립니다. 정각 기준 주기를 유지하려면 next_run_ += interval_;로 예정 시각 기준으로 다음 시각을 잡아야 합니다. 다만 그렇게 하면 작업이 오래 걸려 여러 주기를 놓쳤을 때 밀린 횟수만큼 연달아 실행되므로, while (next_run_ <= now) next_run_ += interval_;처럼 놓친 주기를 건너뛰는 처리를 함께 두는 것이 보통입니다. 폴링 대신 std::this_thread::sleep_until(next_run_)을 쓰면 CPU를 깨우는 횟수도 줄일 수 있습니다.

패턴 3: 로그 타임스탬프

std::string format_timestamp(system_clock::time_point tp) {
    auto secs = floor<seconds>(tp);                        // 초 경계로 내림
    auto ms_part = duration_cast<milliseconds>(tp - secs).count();  // 항상 0~999
    auto time_t = system_clock::to_time_t(secs);

    std::tm tm{};
    localtime_r(&time_t, &tm);                             // Windows: localtime_s(&tm, &time_t)
    char buf[64];
    std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tm);

    char out[80];
    std::snprintf(out, sizeof(out), "%s.%03lld", buf, static_cast<long long>(ms_part));
    return out;
}

// 사용
void log(const std::string& msg) {
    auto now = system_clock::now();
    std::cout << format_timestamp(now) << " " << msg << '\n';
}

밀리초 부분을 count() % 1000 후 std::to_string으로 붙이는 코드를 흔히 보는데, 두 가지 버그가 숨어 있습니다. 첫째, 5ms가 .005가 아니라 .5로 찍혀 사람이 읽을 때 500ms로 착각하고, 문자열 정렬 순서도 깨집니다. 위처럼 %03lld로 세 자리를 채워야 합니다. 둘째, epoch 이전 시각에서는 % 결과가 음수가 됩니다. floor<seconds>로 초 경계를 먼저 구하고 그 차이로 밀리초를 계산하면 항상 0~999 범위가 보장됩니다. std::localtime 대신 localtime_r을 쓴 것은 앞에서 말한 스레드 안전성 때문입니다. C++20 std::format을 쓸 수 있다면 std::format("{:%F %T}", floor<milliseconds>(tp))가 이 모든 처리를 한 줄로 대신합니다(이 경우 UTC 기준으로 출력됩니다).

time_point 구조 (템플릿과 의미)

std::chrono::time_point<Clock, Duration>는 해당 Clock의 epoch를 기준으로 한 시점을 Duration으로 저장합니다.

• Clock: now(), time_point, duration 등의 중첩 타입을 제공합니다. 서로 다른 Clock의 time_point는 직접 빼거나 비교할 수 없습니다.
• Duration: 보통 Clock::duration이나 그에 맞춘 std::chrono::duration<Rep, Period>입니다. 같은 시계라도 time_point<steady_clock, milliseconds>와 time_point<steady_clock, nanoseconds>는 다른 타입이므로, 필요하면 time_point_cast로 맞춥니다.

using namespace std::chrono;

steady_clock::time_point t1 = steady_clock::now();
auto t2 = time_point_cast<milliseconds>(t1);  // 해상도만 바뀜, 시계 동일

기본값 time_point{}는 epoch를 가리키는 경우가 많아, “값이 없음”을 표현할 때는 std::optional 또는 별도 플래그를 쓰는 편이 API에서 안전합니다.

duration과의 관계 (심화)

• time_point는 “시점”, duration은 “간격”입니다.
• 같은 시계에서: time_point - time_point → duration, time_point ± duration → time_point.
• epoch: tp.time_since_epoch()는 Clock의 epoch부터의 duration입니다. system_clock이면 보통 1970-01-01 UTC 기준의 틱입니다.

캘린더 날짜(년·월·일)를 다루려면 C++20의 std::chrono::year_month_day 등 캘린더 타입으로 변환하는 흐름이 필요하며, time_point만으로 윤초·타임존 규칙을 모두 표현하지는 않습니다. Calendar & Timezone 주제와 함께 보는 것이 좋습니다.

시간 연산: 함정과 권장 사항

• 시계 혼합 금지: system_clock::now() - steady_clock::now()는 컴파일되지 않으며 의미도 없습니다.
• sleep_until과 시계: 깨울 시각은 steady_clock::time_point를 쓰면 시스템 시간 변경에 흔들리지 않습니다. system_clock::now() + 5s만 쓰면 사용자가 시각을 바꿀 때 의도와 다르게 동작할 수 있습니다.
• 오버플로: 극단적으로 큰 duration을 더하면 구현·도메인 한계를 넘을 수 있으므로, “최대 유효 기간”을 규칙으로 두는 것이 안전합니다.

해상도 낮추기: duration_cast·floor·ceil·round의 차이

로그를 초 단위로 묶거나 DB가 밀리초까지만 저장할 때 time_point_cast<seconds>(tp)로 해상도를 낮춥니다. 이때 쓰는 함수마다 나머지를 처리하는 방향이 다르고, 음수와 정확히 절반인 경우에 차이가 드러납니다(GCC 10에서 확인한 값).

입력	duration_cast<seconds>	floor<seconds>	round<seconds>
1500ms	1s	1s	2s
2500ms	2s	2s	2s
-1500ms	-1s	-2s	-2s
-2500ms	-2s	-3s	-2s

• duration_cast/time_point_cast는 0 방향으로 절삭합니다. 1970년 이전 시점처럼 epoch 기준 음수 값이면 결과가 실제 시각보다 나중으로 반올림되어, “이 초에 속하는 이벤트”를 모으는 코드가 경계에서 한 칸 어긋납니다. 버킷팅에는 항상 floor가 맞습니다.
• round는 짝수 쪽으로 반올림(banker’s rounding)합니다. 2.5초가 3초가 아니라 2초가 되므로, 사람이 기대하는 사사오입과 다릅니다. 통계 편향을 줄이려는 의도된 규칙이지만, 테스트에서 round(2500ms) == 3s를 기대하면 실패합니다.
• time_point에도 std::chrono::floor<seconds>(tp), ceil, round가 C++17부터 있습니다.

파일 시간과 system_clock 변환

std::filesystem::last_write_time()이 돌려주는 file_time_type은 system_clock의 시점이 아닙니다. libstdc++에서는 별도 시계 __file_clock이고(GCC 10에서 std::is_same_v<file_time_type::clock, system_clock>이 false), MSVC는 epoch가 1601년입니다. 그래서 system_clock::time_point s = fs::last_write_time(p);는 conversion from 'time_point<std::filesystem::__file_clock,...>' ... requested 에러가 납니다.

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

auto ft  = fs::last_write_time("config.json");
auto sys = file_clock::to_sys(ft);                    // C++20: system_clock 시점으로
auto age = system_clock::now() - sys;                 // "몇 초 전에 수정됐나"
if (age > 24h) { /* 오래된 파일 */ }

auto now_ft = file_clock::now();                      // 같은 시계끼리 비교하는 것도 방법
bool recent = (now_ft - ft) < 1h;

같은 시계끼리(file_clock::now() - ft) 비교하면 C++17에서도 이식성 있게 동작합니다. 사람이 읽는 시각으로 출력하거나 다른 시스템의 타임스탬프와 비교해야 할 때만 C++20의 file_clock::to_sys/from_sys(또는 clock_cast)로 변환합니다. C++17에서 ft.time_since_epoch()를 그대로 Unix 시간으로 해석하는 코드가 인터넷에 많은데, epoch가 다른 플랫폼에서는 수백 년 어긋난 값이 되므로 쓰지 않는 것이 좋습니다.

실전: 타임스탬프와 만료 시간

타임스탬프(로그·API): 보통 system_clock::now()를 취해 time_since_epoch()를 밀리초 등으로 바꾸어 JSON·Protobuf에 넣습니다. UTC로 통일하고 표시할 때만 로컬 타임존을 적용하는 것이 혼란을 줄입니다.

// 변수 선언 및 초기화
auto now = std::chrono::system_clock::now();
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
    now.time_since_epoch()).count();
// wire: int64_t ms since Unix epoch (UTC)

만료 시간(토큰·캐시): “실제 시각”이 중요하면 system_clock::time_point로 expires_at을 저장합니다. “등록 후 5분”처럼 기기 절전·시간 변경과 무관하게 지속 시간만 쓰려면 steady_clock으로 기준을 잡거나, 도메인이 허용하면 모두 UTC epoch 기준으로만 저장합니다.

직렬화 (Wire 형식)

다른 프로세스·언어와 호환하려면 다음을 권장합니다.

1. Unix epoch 이후 정수: 나노/마이크로/밀리초 중 하나로 단위를 문서화합니다. 예: int64_t milliseconds_since_epoch.
2. ISO 8601 문자열: 사람이 읽거나 로그에 넣기 좋습니다. system_clock → time_t/tm 또는 C++20 포맷터로 직렬화합니다.
3. 시계 종류 명시: steady_clock의 time_point는 직렬화해도 다른 기기에서 의미가 없습니다. 재시작·다른 머신과 공유할 “만료”에는 쓰지 마세요.
4. 역직렬화: 정수 → duration → system_clock::time_point로 복원할 때 오버플로와 단위 혼동(µs vs ms)을 주의합니다.

std::chrono::system_clock::time_point tp{
    std::chrono::milliseconds{millis_from_wire}
};

바이너리 프로토콜에서는 엔디안과 부호 있는 64비트 범위가 충분한지 함께 검토합니다.

FAQ

Q1: steady_clock 값을 파일에 저장했다가 재시작 후 비교해도 되나요?

A: 안 됩니다. steady_clock의 epoch는 구현 의존이고 보통 부팅 시점 근처라서, 프로세스를 재시작하거나 서버를 재부팅하면 기준점이 달라집니다. 저장했다 나중에 비교해야 하는 만료 시각은 system_clock 기준 Unix 시간으로 저장하고, 한 프로세스 안에서만 쓰는 타임아웃에만 steady_clock을 씁니다.

Q2: 어떤 시계를 사용해야 하나요?

A:

• system_clock: 실제 시각 필요 시 (로그, 파일 시간)
• steady_clock: 경과 시간 측정 시 (타임아웃, 벤치마크)

Q3: 타임스탬프로 변환하려면?

A: system_clock::to_time_t()를 사용하세요.

auto now = system_clock::now();
auto time_t = system_clock::to_time_t(now);
std::cout << std::ctime(&time_t);

Q4: 시간 연산은 어떻게 하나요?

A: +, -, 비교 연산자를 사용할 수 있습니다. time_point + duration = time_point, time_point - time_point = duration.

Q5: 성능 측정에는 어떤 시계를 사용하나요?

A: steady_clock을 권장합니다. 시스템 시간 변경에 영향받지 않고 단조 증가가 보장됩니다.

Q6: C++20 타임존 지원은?

A: zoned_time과 time_zone을 사용하여 타임존 변환이 가능합니다.

auto now = system_clock::now();
auto ny = zoned_time{"America/New_York", now};

Q7: time_point와 duration의 차이는?

A:

• time_point: 특정 시점 (예: “2026-03-12 14:30:00”)
• duration: 시간 간격 (예: “5초”)

Q8: epoch는 무엇인가요?

A: 시계의 기준 시점입니다. system_clock의 epoch는 보통 1970-01-01 00:00:00 UTC입니다.

Q9: condition_variable::wait_until에 system_clock 시점을 넘기면 어떻게 되나요?

A: 표준상 동작은 하지만, 대기 중에 시스템 시각이 바뀌면 예상보다 일찍 깨거나 늦게 깰 수 있습니다. 구현도 시계별로 다르게 처리해서, 과거 libstdc++는 steady_clock 시점을 받아도 내부적으로 system_clock으로 변환해 기다렸다가 시각 변경에 영향을 받는 문제가 있었습니다(최신 glibc·GCC 조합에서는 pthread_cond_clockwait로 개선됨). 타임아웃 목적이라면 wait_for나 steady_clock 기준 wait_until을 쓰는 것이 원칙입니다.

관련 글: duration, 시간 변환, chrono, 스톱워치·벤치마크.

time_point는 특정 시계의 시간 지점을 나타내며, duration과 함께 사용하여 시간 연산을 수행할 수 있습니다.

---

같이 보면 좋은 글

• C++ chrono::duration: 단위 변환, duration_cast·round, 시간 리터럴과 정밀도 손실
• C++ 스톱워치와 벤치마크 | chrono으로 실행 시간 측정하기
• time() 대신 std::chrono: duration·time_point, 클럭 선택, duration_cast, C++20 달력
• C++ ratio
• C++ steady_clock

---