C++ std::chrono::duration_cast入門：基本から応用までを網羅

std::chrono::duration_cast は、C++ の <chrono> ライブラリで提供されるテンプレート関数で、ある時間間隔 (std::chrono::duration) の型を別の時間間隔の型に安全に変換するために使用されます。

std::chrono::duration は、時間量（例：5秒、2時間、100ミリ秒など）を表す型です。この型は、時間量を表現する「ティックの数（count）」と、1ティックがどのくらいの時間を示すかを表す「期間（period）」という2つの情報を持っています。

duration_cast は、異なる期間を持つ duration 型間で、または同じ期間だが異なるデータ型でティックの数を保持する duration 型間で変換を行う際に非常に役立ちます。

なぜ duration_cast が必要なのか？

例えば、ある操作の所要時間をナノ秒で計測したとします。しかし、それを後でミリ秒単位で表示したい場合があるかもしれません。単純な割り算では、浮動小数点数の丸め誤差や、整数型の場合の切り捨てによって不正確な結果になる可能性があります。

duration_cast は、このような型変換を明示的かつ意図的に行い、変換先の型の分解能に合わせて値を調整します。

使用例

基本的な使い方は以下の通りです。

#include <iostream>
#include <chrono>

int main() {
    // 5秒を表すduration
    std::chrono::seconds s(5);

    // 秒をミリ秒に変換
    // duration_cast<変換したいdurationの型>(変換元のduration)
    std::chrono::milliseconds ms = std::chrono::duration_cast<std::chrono::milliseconds>(s);

    std::cout << "5秒は " << ms.count() << " ミリ秒です。" << std::endl; // 出力: 5秒は 5000 ミリ秒です。

    // 2500ミリ秒を表すduration
    std::chrono::milliseconds ms2(2500);

    // ミリ秒を秒に変換（切り捨てが発生する）
    std::chrono::seconds s2 = std::chrono::duration_cast<std::chrono::seconds>(ms2);

    std::cout << "2500ミリ秒は " << s2.count() << " 秒です。" << std::endl; // 出力: 2500ミリ秒は 2 秒です。

    // より細かい単位から粗い単位への変換では、小数点以下が切り捨てられます。
    // 例: 2900ミリ秒を秒に変換すると、2秒になります。
    std::chrono::milliseconds ms3(2900);
    std::chrono::seconds s3 = std::chrono::duration_cast<std::chrono::seconds>(ms3);
    std::cout << "2900ミリ秒は " << s3.count() << " 秒です。" << std::endl; // 出力: 2900ミリ秒は 2 秒です。

    // float/double など、tickのデータ型を変更する場合も使用できます。
    std::chrono::duration<double, std::ratio<1, 1000>> double_ms = s; // 5秒をdoubleのミリ秒に変換
    std::cout << "5秒は " << double_ms.count() << " (double)ミリ秒です。" << std::endl; // 出力: 5秒は 5000 (double)ミリ秒です。

    return 0;
}

ポイント

1. テンプレート引数:

   • duration_cast のテンプレート引数には、変換したい duration の型を指定します。例えば、std::chrono::milliseconds や std::chrono::seconds などです。
   • std::chrono::duration 型は、std::chrono::duration<Rep, Period> のように定義されます。Rep はティックの数を保持するデータ型（int, long long, double など）、Period は1ティックの時間単位（std::ratio<1, 1> で1秒、std::ratio<1, 1000> で1ミリ秒など）です。

2. 変換元の型:

   • 関数の引数には、変換元の duration オブジェクトを渡します。

3. 丸めと切り捨て:

   • duration_cast は、変換先の単位に正確に収まらない場合、切り捨て (truncation) を行います。つまり、小数部分が切り捨てられます。
   • より細かい単位（例：ナノ秒）からより粗い単位（例：秒）に変換する場合、情報が失われる可能性があります。
   • もし、最も近い値への丸め（rounding）が必要な場合は、duration_cast だけでなく、std::chrono::round や std::chrono::ceil, std::chrono::floor などの関数を組み合わせる必要があります。

4. 暗黙的な変換との違い:

   • std::chrono::duration は、より細かい単位からより粗い単位への暗黙的な変換は許可しません。これは、情報が失われる可能性があるため、プログラマが意図的に変換を行う必要があるためです。
   • しかし、より粗い単位からより細かい単位への暗黙的な変換は許可されます（情報が失われないため）。
   • duration_cast は、この暗黙的な変換の制限を乗り越え、明示的に変換を行うためのものです。

---

std::chrono::duration_cast は非常に便利ですが、その性質上、誤解や誤用によっていくつかの一般的なエラーが発生することがあります。

エラー: 意図しない切り捨て（情報の損失）

これはエラーメッセージが出るわけではありませんが、duration_cast を使用する際によくある論理的な問題です。

問題の状況
より細かい時間単位（例：ミリ秒）から、より粗い時間単位（例：秒）へ変換する際に、duration_cast は小数部分を切り捨てます。これは数学的な丸めではなく、常にゼロ方向への切り捨てです。

#include <iostream>
#include <chrono>

int main() {
    std::chrono::milliseconds ms(2900); // 2900ミリ秒

    // 秒にキャスト
    std::chrono::seconds s = std::chrono::duration_cast<std::chrono::seconds>(ms);
    std::cout << "2900ミリ秒は " << s.count() << " 秒です。" << std::endl; // 意図せず "2" が出力される（期待は "2.9" に近い）

    std::chrono::milliseconds ms2(999); // 999ミリ秒
    std::chrono::seconds s2 = std::chrono::duration_cast<std::chrono::seconds>(ms2);
    std::cout << "999ミリ秒は " << s2.count() << " 秒です。" << std::endl; // "0" が出力される
    return 0;
}

トラブルシューティング

• 浮動小数点数で精度を保ちたい場合
  結果を浮動小数点数型 (double や float) の duration に変換することで、小数部分を保持できます。

  #include <iostream>
  #include <chrono>
  
  int main() {
      std::chrono::milliseconds ms(2900);
  
      // double型の秒に変換
      std::chrono::duration<double, std::ratio<1>> s_double = ms; // 暗黙的に変換される
      // または、明示的にキャスト
      // std::chrono::duration<double, std::ratio<1>> s_double = std::chrono::duration_cast<std::chrono::duration<double, std::ratio<1>>>(ms);
      std::cout << "2900ミリ秒は " << s_double.count() << " 秒です。" << std::endl; // 2.9が出力される
  
      return 0;
  }
  

  注意: 浮動小数点数型 (double や float) の duration は、ティックの型が浮動小数点数になるだけで、期間 (Period) はそのままです。上の例では、1ティックが1秒の double 型の duration に変換しています。
• 丸めが必要な場合
  C++20 からは、std::chrono::round、std::chrono::ceil、std::chrono::floor などの関数が追加されており、これらを使用することで意図した丸めを行うことができます。

  #include <iostream>
  #include <chrono>
  
  int main() {
      std::chrono::milliseconds ms(2900);
  
      // 最も近い整数に丸める
      std::chrono::seconds s_round = std::chrono::round<std::chrono::seconds>(ms);
      std::cout << "2900ミリ秒は (round) " << s_round.count() << " 秒です。" << std::endl; // 3秒
  
      // 切り上げ
      std::chrono::seconds s_ceil = std::chrono::ceil<std::chrono::seconds>(ms);
      std::cout << "2900ミリ秒は (ceil) " << s_ceil.count() << " 秒です。" << std::endl; // 3秒
  
      // 切り捨て（duration_castと同じ）
      std::chrono::seconds s_floor = std::chrono::floor<std::chrono::seconds>(ms);
      std::cout << "2900ミリ秒は (floor) " << s_floor.count() << " 秒です。" << std::endl; // 2秒
  
      return 0;
  }
  

エラー: duration_cast テンプレート引数の指定ミス

問題の状況
duration_cast はテンプレート関数なので、変換したい duration の型をテンプレート引数として正確に指定する必要があります。型を間違えたり、count() の結果の型を指定したりすると、コンパイルエラーになるか、意図しない挙動になります。

#include <iostream>
#include <chrono>

int main() {
    std::chrono::seconds s(10);

    // 誤り: テンプレート引数に duration ではない型を指定
    // std::chrono::minutes m = std::chrono::duration_cast<int>(s); // コンパイルエラー！
    // 誤り: テンプレート引数に期間だけを指定
    // std::chrono::minutes m = std::chrono::duration_cast<std::ratio<60>>(s); // コンパイルエラー！

    // 正しい使い方
    std::chrono::minutes m = std::chrono::duration_cast<std::chrono::minutes>(s);
    std::cout << "10秒は " << m.count() << " 分です。" << std::endl;

    return 0;
}

トラブルシューティング

• 目標の duration 型は、std::chrono::seconds、std::chrono::milliseconds、std::chrono::duration<Rep, Period> のように、完全な duration 型である必要があります。
• duration_cast<目標のduration型> の形式を常に守る。

エラー: 暗黙的な変換の利用と duration_cast の混同

問題の状況
std::chrono::duration は、より粗い単位からより細かい単位への暗黙的な変換は許可しますが、逆は許可しません。この規則を忘れて、duration_cast が不要な場合に使ったり、必要な場合に使わなかったりすることがあります。

#include <iostream>
#include <chrono>

int main() {
    std::chrono::seconds s(1);

    // OK: より粗い単位からより細かい単位への暗黙的な変換は可能
    std::chrono::milliseconds ms = s;
    std::cout << "1秒は " << ms.count() << " ミリ秒です。" << std::endl; // 1000

    // OK: duration_castを使ってもよい（冗長だが間違いではない）
    std::chrono::milliseconds ms2 = std::chrono::duration_cast<std::chrono::milliseconds>(s);
    std::cout << "1秒は " << ms2.count() << " ミリ秒です。" << std::endl; // 1000

    std::chrono::milliseconds ms3(1500);

    // エラー: より細かい単位からより粗い単位への暗黙的な変換は不可
    // std::chrono::seconds s3 = ms3; // コンパイルエラー！

    // OK: duration_cast を使うことで明示的に変換できる
    std::chrono::seconds s4 = std::chrono::duration_cast<std::chrono::seconds>(ms3);
    std::cout << "1500ミリ秒は " << s4.count() << " 秒です。" << std::endl; // 1
    return 0;
}

トラブルシューティング

• コンパイルエラーが出た場合は、暗黙的な変換の規則に違反していないか確認し、必要に応じて duration_cast を追加する。
• 原則
  情報の損失が発生しない変換（粗い単位から細かい単位）は暗黙的に行える。情報の損失が発生する可能性のある変換（細かい単位から粗い単位）には、必ず duration_cast を明示的に使用する。

エラー: 変換後の count() メソッドの呼び出し忘れ

問題の状況
duration_cast は新しい duration オブジェクトを返します。そのオブジェクトから実際の数値（ティックの数）を取得するためには、.count() メソッドを呼び出す必要があります。これを忘れると、duration オブジェクト自体を扱おうとして、意図しないコンパイルエラーや実行時エラーにつながることがあります。

#include <iostream>
#include <chrono>

int main() {
    std::chrono::seconds s(60);

    // 誤り: count() を呼び忘れている
    // int minutes = std::chrono::duration_cast<std::chrono::minutes>(s); // コンパイルエラー！
    // duration オブジェクトを直接 cout しようとすると、オペレータが定義されていない場合もエラー

    // 正しい使い方
    int minutes = std::chrono::duration_cast<std::chrono::minutes>(s).count();
    std::cout << "60秒は " << minutes << " 分です。" << std::endl;

    return 0;
}

トラブルシューティング

• duration_cast の結果が duration オブジェクトであることを理解し、その数値表現が必要な場合は必ず .count() を呼び出す。

エラー: オーバーフロー/アンダーフロー（ティックの型の限界）

問題の状況
duration のティックの数を保持する型 (Rep) が、変換後の時間量を表現するのに十分な大きさでない場合、オーバーフロー（またはアンダーフロー）が発生する可能性があります。特に、非常に長い時間を非常に細かい単位に変換する際に起こりえます。

#include <iostream>
#include <chrono>

int main() {
    // 非常に長い時間 (例: 100年)
    std::chrono::duration<long long, std::ratio<31557600>> long_years(100); // 100年を秒で表現

    // これをナノ秒に変換しようとする (long long の範囲を超える可能性がある)
    // std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(long_years);
    // 100年 * 31557600秒/年 * 1,000,000,000ナノ秒/秒 = 3,155,760,000,000,000,000,000 ナノ秒
    // これは long long の最大値 (約 9 x 10^18) をはるかに超える

    // このキャストはコンパイルエラーにはなりにくいですが、実行時に未定義動作または誤った値になります。
    // MSVCなどの一部のコンパイラは、コンパイル時にオーバーフローの警告を出すことがあります。

    // より現実的な例: int 型の duration で大きな値を扱う
    std::chrono::seconds big_s(2'000'000'000); // 20億秒 (約63年)

    // int 型のミリ秒に変換しようとするとオーバーフロー
    // std::chrono::milliseconds overflow_ms = std::chrono::duration_cast<std::chrono::milliseconds>(big_s);
    // 2,000,000,000秒 * 1000ミリ秒/秒 = 2,000,000,000,000ミリ秒 (int の最大値 2 x 10^9 を超える)
    // この場合も未定義動作や誤った値になります。
    return 0;
}

• 事前に範囲チェックを行う
  可能であれば、変換前に目的の型で表現できる範囲に収まるかを確認します。
• 浮動小数点数を使用する
  非常に大きな時間量を扱う場合や、極端に細かい精度が必要ない場合は、double や long double を Rep 型として使用することも有効です。 std::chrono::duration<double, ...>
• long long を使用する
  時間量を保持する Rep 型は、デフォルトで long long または適切な整数型が選択されますが、必要に応じて明示的に long long を使用することを検討してください。 std::chrono::duration<long long, ...>

---

std::chrono::duration_cast は、C++ の時間ライブラリにおいて、異なる時間単位を持つ duration 型間で値を安全に変換するために不可欠なツールです。いくつかの一般的なシナリオでその使い方を見ていきましょう。

例1: 秒からミリ秒、マイクロ秒、ナノ秒への変換 (より細かい単位へ)

粗い時間単位から細かい時間単位への変換は、通常、情報の損失がなく安全です。duration_cast を使っても、暗黙的な変換を使っても構いませんが、明示的なキャストは意図を明確にします。

#include <iostream>
#include <chrono> // std::chrono を使うために必要

int main() {
    // 1. std::chrono::seconds オブジェクトを作成
    std::chrono::seconds one_second(1); // 1秒

    std::cout << "元の時間: " << one_second.count() << " 秒" << std::endl;

    // 2. 秒をミリ秒に変換
    //    duration_cast のテンプレート引数には「変換したいdurationの型」を指定します。
    std::chrono::milliseconds ms = std::chrono::duration_cast<std::chrono::milliseconds>(one_second);
    std::cout << "ミリ秒に変換: " << ms.count() << " ms" << std::endl; // 出力: 1000 ms

    // 3. 秒をマイクロ秒に変換
    std::chrono::microseconds us = std::chrono::duration_cast<std::chrono::microseconds>(one_second);
    std::cout << "マイクロ秒に変換: " << us.count() << " us" << std::endl; // 出力: 1000000 us

    // 4. 秒をナノ秒に変換
    std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(one_second);
    std::cout << "ナノ秒に変換: " << ns.count() << " ns" << std::endl;   // 出力: 1000000000 ns

    // 補足: この方向の変換は暗黙的にも行えます (情報損失がないため)
    std::chrono::milliseconds ms_implicit = one_second;
    std::cout << "暗黙的にミリ秒に変換: " << ms_implicit.count() << " ms" << std::endl;

    return 0;
}

例2: ミリ秒から秒、分、時への変換 (より粗い単位へ - 切り捨てに注意)

細かい時間単位から粗い時間単位への変換では、duration_cast は切り捨てを行います。この挙動を理解することが非常に重要です。

#include <iostream>
#include <chrono>

int main() {
    // 1. 2500ミリ秒と2900ミリ秒のdurationオブジェクトを作成
    std::chrono::milliseconds duration_ms_1(2500);
    std::chrono::milliseconds duration_ms_2(2900);
    std::chrono::milliseconds duration_ms_3(59999); // 59.999秒

    std::cout << "元の時間 (1): " << duration_ms_1.count() << " ms" << std::endl;
    std::cout << "元の時間 (2): " << duration_ms_2.count() << " ms" << std::endl;
    std::cout << "元の時間 (3): " << duration_ms_3.count() << " ms" << std::endl;

    // 2. ミリ秒を秒に変換 (duration_castは切り捨てを行う)
    std::chrono::seconds s_1 = std::chrono::duration_cast<std::chrono::seconds>(duration_ms_1);
    std::cout << "秒に変換 (2500ms): " << s_1.count() << " s" << std::endl; // 出力: 2 s (0.5秒は切り捨て)

    std::chrono::seconds s_2 = std::chrono::duration_cast<std::chrono::seconds>(duration_ms_2);
    std::cout << "秒に変換 (2900ms): " << s_2.count() << " s" << std::endl; // 出力: 2 s (0.9秒は切り捨て)

    // 3. ミリ秒を分に変換 (ここでも切り捨て)
    std::chrono::minutes m_3 = std::chrono::duration_cast<std::chrono::minutes>(duration_ms_3);
    std::cout << "分に変換 (59999ms): " << m_3.count() << " min" << std::endl; // 出力: 0 min (59.999秒は1分未満なので切り捨て)

    // 補足: この方向の変換は暗黙的にも行えません (情報損失の可能性があるため)
    // std::chrono::seconds s_err = duration_ms_1; // コンパイルエラー！

    return 0;
}

例3: 丸め処理と浮動小数点数を使ったより正確な表現 (C++20以降推奨)

duration_cast の切り捨て挙動が望ましくない場合、C++20からは便利な丸め関数が提供されています。また、浮動小数点数型の duration を使うことで、小数部分を保持できます。

#include <iostream>
#include <chrono>
#include <cmath> // std::round などに必要 (C++20 chrono::round を使う場合は不要だが、以前のバージョンとの比較のために)

int main() {
    std::chrono::milliseconds ms_value(2900); // 2.9秒

    std::cout << "元の時間: " << ms_value.count() << " ms" << std::endl;

    // 1. duration_cast による切り捨て (復習)
    std::chrono::seconds s_truncated = std::chrono::duration_cast<std::chrono::seconds>(ms_value);
    std::cout << "duration_cast (切り捨て): " << s_truncated.count() << " s" << std::endl; // 2 s

#if __cplusplus >= 202002L // C++20 以降
    // 2. C++20 の丸め関数
    // std::chrono::round: 最も近い整数に丸める
    std::chrono::seconds s_rounded = std::chrono::round<std::chrono::seconds>(ms_value);
    std::cout << "std::chrono::round (四捨五入): " << s_rounded.count() << " s" << std::endl; // 3 s (2.9 は 3 に近い)

    // std::chrono::ceil: 切り上げ
    std::chrono::seconds s_ceil = std::chrono::ceil<std::chrono::seconds>(ms_value);
    std::cout << "std::chrono::ceil (切り上げ): " << s_ceil.count() << " s" << std::endl;   // 3 s

    // std::chrono::floor: 切り捨て (duration_cast と同じ)
    std::chrono::seconds s_floor = std::chrono::floor<std::chrono::seconds>(ms_value);
    std::cout << "std::chrono::floor (切り捨て): " << s_floor.count() << " s" << std::endl; // 2 s
#else
    std::cout << "C++20の丸め関数は利用できません。" << std::endl;
    // C++17以前で同様の丸めが必要な場合は、一旦浮動小数点数に変換し、std::roundなどを使う
    // double seconds_double = static_cast<double>(ms_value.count()) / 1000.0;
    // long long rounded_seconds = static_cast<long long>(std::round(seconds_double));
    // std::cout << "手動で丸め (C++17以前): " << rounded_seconds << " s" << std::endl;
#endif

    // 3. 浮動小数点数型の duration を使用して精度を保つ
    //    これにより、ティックの数が浮動小数点数として保持される
    std::chrono::duration<double, std::ratio<1>> double_seconds = ms_value; // 1ティックが1秒のdouble型 duration
    std::cout << "double型 duration で精度保持: " << double_seconds.count() << " s" << std::endl; // 2.9 s

    std::chrono::duration<float, std::ratio<1, 1000000>> float_microseconds = ms_value; // 1ティックが1マイクロ秒のfloat型 duration
    std::cout << "float型 duration (マイクロ秒): " << float_microseconds.count() << " us" << std::endl; // 2900000.0 us

    return 0;
}

例4: システムの時間計測と duration_cast の組み合わせ

std::chrono::high_resolution_clock や std::chrono::steady_clock などと組み合わせて、処理時間の計測結果を任意の単位で表示する例です。

#include <iostream>
#include <chrono> // 時間計測とdurationに必要
#include <thread> // std::this_thread::sleep_for に必要

void some_task() {
    // 適当な処理をシミュレート
    std::this_thread::sleep_for(std::chrono::milliseconds(1234));
}

int main() {
    // 1. 処理開始前の時刻を記録
    auto start = std::chrono::high_resolution_clock::now();

    // 2. 測定したい処理を実行
    some_task();

    // 3. 処理終了後の時刻を記録
    auto end = std::chrono::high_resolution_clock::now();

    // 4. 経過時間を計算 (duration 型で結果が得られる)
    std::chrono::duration<double> duration_seconds = end - start; // デフォルトで秒単位のdouble durationになることが多い

    // 5. 経過時間を様々な単位にキャストして表示
    //    元のduration_secondsはdouble型なので、duration_castで整数型に変換すると切り捨てが発生します。

    // 秒 (double)
    std::cout << "経過時間 (秒): " << duration_seconds.count() << " s" << std::endl;

    // ミリ秒 (整数)
    std::chrono::milliseconds duration_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "経過時間 (ミリ秒): " << duration_ms.count() << " ms" << std::endl;

    // マイクロ秒 (整数)
    std::chrono::microseconds duration_us = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    std::cout << "経過時間 (マイクロ秒): " << duration_us.count() << " us" << std::endl;

    // ナノ秒 (整数)
    std::chrono::nanoseconds duration_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start);
    std::cout << "経過時間 (ナノ秒): " << duration_ns.count() << " ns" << std::endl;

    // 別の例: 5分を秒とミリ秒で表示
    std::chrono::minutes five_minutes(5);
    std::chrono::seconds s_from_min = std::chrono::duration_cast<std::chrono::seconds>(five_minutes);
    std::chrono::milliseconds ms_from_min = std::chrono::duration_cast<std::chrono::milliseconds>(five_minutes);
    std::cout << "5分は " << s_from_min.count() << " 秒" << std::endl;
    std::cout << "5分は " << ms_from_min.count() << " ミリ秒" << std::endl;

    return 0;
}

---

std::chrono::duration_cast は、std::chrono::duration 型間で時間単位を変換するための主要かつ推奨される方法ですが、特定の状況やC++のバージョンによっては、他の方法や考慮すべき点があります。

暗黙的な変換 (Implicit Conversion)

説明
std::chrono::duration は、情報が失われる可能性がない場合に限り、自動的に（暗黙的に）変換されます。具体的には、より粗い単位からより細かい単位への変換です。例えば、秒からミリ秒への変換は暗黙的に行われます。

コード例

#include <iostream>
#include <chrono>

int main() {
    std::chrono::seconds s(1); // 1秒

    // 暗黙的な変換: 秒(粗い) -> ミリ秒(細かい) はOK
    std::chrono::milliseconds ms = s;
    std::cout << "1秒は " << ms.count() << " ミリ秒です。" << std::endl; // 出力: 1000

    // duration_cast を使うと明示的になるだけで、結果は同じ
    std::chrono::milliseconds ms_explicit = std::chrono::duration_cast<std::chrono::milliseconds>(s);
    std::cout << "1秒は (duration_cast) " << ms_explicit.count() << " ミリ秒です。" << std::endl; // 出力: 1000

    return 0;
}

利点

• 情報の損失がないため、安全です。
• コードが簡潔になります。

欠点

• 明示的なキャストよりも意図が伝わりにくいと感じる人もいるかもしれません。
• より細かい単位からより粗い単位への変換はコンパイルエラーになります。 (例: ミリ秒から秒)

  // std::chrono::milliseconds ms_value(1500);
  // std::chrono::seconds s_value = ms_value; // コンパイルエラー！
  

C++20 の std::chrono::round, ceil, floor (丸めが必要な場合)

説明
duration_cast は常に切り捨てを行います。もし、最も近い値への丸め（四捨五入に似たもの）や、常に切り上げ/切り下げが必要な場合は、C++20で導入されたこれらの関数が直接的な代替手段となります。

コード例

#include <iostream>
#include <chrono>

int main() {
    std::chrono::milliseconds ms_val(2900); // 2.9秒

    std::cout << "元の時間: " << ms_val.count() << " ms" << std::endl;

    // duration_cast (切り捨て)
    std::chrono::seconds s_trunc = std::chrono::duration_cast<std::chrono::seconds>(ms_val);
    std::cout << "duration_cast (切り捨て): " << s_trunc.count() << " s" << std::endl; // 2

    // std::chrono::round (最も近い整数に丸める)
    std::chrono::seconds s_round = std::chrono::round<std::chrono::seconds>(ms_val);
    std::cout << "std::chrono::round (四捨五入): " << s_round.count() << " s" << std::endl; // 3

    // std::chrono::ceil (切り上げ)
    std::chrono::seconds s_ceil = std::chrono::ceil<std::chrono::seconds>(ms_val);
    std::cout << "std::chrono::ceil (切り上げ): " << s_ceil.count() << " s" << std::endl;   // 3

    // std::chrono::floor (切り捨て - duration_cast と同じ結果)
    std::chrono::seconds s_floor = std::chrono::floor<std::chrono::seconds>(ms_val);
    std::cout << "std::chrono::floor (切り捨て): " << s_floor.count() << " s" << std::endl; // 2

    return 0;
}

利点

• duration_cast と同様に、テンプレート引数で変換後の duration 型を指定します。
• 丸め、切り上げ、切り下げのセマンティクスが明確になります。

欠点

• duration_cast が提供するデフォルトの切り捨て動作が望ましい場合は、冗長になります。
• C++20 以降の標準が必要です。 それ以前のバージョンでは使用できません。

ティックの型を浮動小数点数にする (std::chrono::duration<double, ...>)

説明
std::chrono::duration は、そのティックの数を保持する型 (Rep) をテンプレート引数で指定できます。この Rep に double や float などの浮動小数点数型を使用することで、時間量の小数部分を保持し、丸め誤差を最小限に抑えることができます。

コード例

#include <iostream>
#include <chrono>

int main() {
    std::chrono::milliseconds ms_value(2900); // 2.9秒

    std::cout << "元の時間: " << ms_value.count() << " ms" << std::endl;

    // 1ティックが1秒のdouble型 duration に変換
    // 暗黙的な変換が利用されます（ミリ秒から秒への変換ですが、double型にすることで情報損失が回避されるため）
    std::chrono::duration<double, std::ratio<1>> double_seconds = ms_value;
    std::cout << "double型の秒: " << double_seconds.count() << " s" << std::endl; // 2.9

    // 明示的にduration_castを使うことも可能
    std::chrono::duration<double, std::ratio<1>> double_seconds_explicit =
        std::chrono::duration_cast<std::chrono::duration<double, std::ratio<1>>>(ms_value);
    std::cout << "double型の秒 (duration_cast): " << double_seconds_explicit.count() << " s" << std::endl; // 2.9

    // 1ティックが1ミリ秒のdouble型 duration に変換
    std::chrono::duration<double, std::ratio<1, 1000>> double_milliseconds = ms_value;
    std::cout << "double型のミリ秒: " << double_milliseconds.count() << " ms" << std::endl; // 2900.0

    return 0;
}

利点

• ほとんどの duration 間の変換で情報の損失を回避できます。
• 小数点以下の精度を保持できます。

欠点

• ティックが浮動小数点数になるため、整数ティックを期待するAPIとの連携で不都合が生じる可能性があります。
• 浮動小数点数の丸め誤差や精度限界の問題が導入されます。厳密な整数ティックの正確性が必要な場合には不向きです。

手動計算 (Manual Calculation)

説明
最終手段として、期間の比率 (std::ratio) を使って手動で計算することも可能ですが、これは一般的に推奨されません。型安全性が失われ、コードが読みにくく、バグを導入しやすいためです。

コード例

#include <iostream>
#include <chrono>

int main() {
    std::chrono::milliseconds ms(2500);

    // ミリ秒を秒に手動で変換
    // 1秒 = 1000ミリ秒なので、ミリ秒を1000で割る
    long long seconds_manual = ms.count() / 1000;
    std::cout << "手動計算で秒に変換: " << seconds_manual << " s" << std::endl; // 2

    // 注意: 浮動小数点数で精度を保ちたい場合はキャストが必要
    double seconds_double_manual = static_cast<double>(ms.count()) / 1000.0;
    std::cout << "手動計算でdouble型の秒に変換: " << seconds_double_manual << " s" << std::endl; // 2.5

    return 0;
}

利点

• std::chrono ライブラリの知識が少ない場合でも、基本的な算術演算で対応できます。

• std::chrono の設計思想に反します。
• std::ratio の複雑な計算（例：秒からナノ秒）を手動で行うのは非常にエラーが発生しやすいです。
• 型安全性がなく、コンパイル時に単位の不整合をチェックできません。
• 非推奨です。

代替手段	説明	利点	欠点
暗黙的な変換	より粗い単位から細かい単位への自動変換	簡潔、安全（情報損失なし）	逆方向は不可、意図が不明瞭になる可能性あり
std::chrono::round/ceil/floor (C++20)	明示的な丸め、切り上げ、切り捨てが必要な場合	意図が明確、豊富な丸めオプション	C++20以降のみ、duration_cast のデフォルト動作が望ましい場合は冗長
浮動小数点数 Rep	ティックの型を double などにして小数部分を保持	精度を保持、柔軟性	浮動小数点数特有の誤差、整数ティックを期待するAPIとの不整合
手動計算	算術演算による直接計算	基本的な算術演算のみ	非推奨、型安全性がなくエラーを起こしやすい、可読性低い