C++ time_point | "시간 지점" 가이드

· 16분 읽기 · 수정 중급 튜토리얼
C++ time_point | "시간 지점" 가이드

이 글의 핵심

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

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입니다.

// 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;

예시 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);

예시 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 (타임아웃, 벤치마크)
// ✅ 로그 타임스탬프: 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();
// 항상 양수

문제 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';

시간 연산

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 + durationtime_pointnow + 1h
time_point - durationtime_pointnow - 30min
time_point - time_pointdurationend - start
time_point == time_pointboolt1 == t2
time_point < time_pointboolt1 < 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);
}

패턴 3: 로그 타임스탬프

std::string format_timestamp(system_clock::time_point tp) {
    auto time_t = system_clock::to_time_t(tp);
    auto ms = time_point_cast<milliseconds>(tp);
    auto ms_part = ms.time_since_epoch().count() % 1000;
    
    char buf[64];
    std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", std::localtime(&time_t));
    
    return std::string(buf) + "." + std::to_string(ms_part);
}

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

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을 더하면 구현·도메인 한계를 넘을 수 있으므로, “최대 유효 기간”을 규칙으로 두는 것이 안전합니다.

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

타임스탬프(로그·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: time_point는 무엇인가요?

A: 특정 시계의 epoch로부터의 경과 시간을 나타내는 타입입니다. 특정 시간 지점을 표현합니다.

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: time_point 학습 리소스는?

A:

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

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

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

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

  • C++ duration | “시간 간격” 가이드
  • C++ 시간 변환 | chrono duration_cast와 시계 변환
  • C++ Chrono | “시간 라이브러리” 가이드
  • C++ 스톱워치와 벤치마크 | chrono으로 실행 시간 측정하기

관련 글

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