もう怖くない！C++ std::out_of_rangeの解決策と安全なプログラミング
2025-05-27
具体的には、以下のような状況でstd::out_of_range例外がスローされることがあります。
-
文字列操作
std::stringのsubstr()（部分文字列の取得）やinsert()（挿入）など、文字列操作を行う関数で、指定した位置や長さが文字列の有効な範囲を超えていた場合。
-
std::vector、std::string、std::dequeなどのコンテナで、at()メンバ関数を使って要素にアクセスしようとした際に、指定したインデックスがコンテナの有効な範囲外であった場合。- 例: サイズが5の
std::vectorに対してvec.at(5)のようにインデックス5（6番目の要素）にアクセスしようとした場合。[]演算子とは異なり、at()は範囲チェックを行い、範囲外アクセスの場合にstd::out_of_rangeをスローします。
- 例: サイズが5の
std::mapやstd::unordered_mapなどの連想コンテナで、at()メンバ関数を使って存在しないキーに対応する要素にアクセスしようとした場合。
なぜstd::out_of_rangeが重要なのか？
std::out_of_rangeは、プログラムの堅牢性を高める上で非常に重要です。この例外を適切に処理することで、以下のようなメリットがあります。
- エラー処理の明確化
try-catchブロックを使用してstd::out_of_rangeを捕捉することで、エラー発生時の適切な処理（例: エラーメッセージの表示、デフォルト値の設定、再試行など）を記述できます。 - 安全性の向上
意図しないメモリの書き換えや読み取りを防ぎ、プログラムのクラッシュや予期せぬ動作を防ぐことができます。 - 早期発見とデバッグの容易さ
プログラムが不正なメモリ領域にアクセスしようとしたときに、すぐにエラーとして報告されるため、問題の原因を特定しやすくなります。[]演算子を使った範囲外アクセスは未定義動作となり、デバッグが非常に困難になる可能性があります。
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept> // std::out_of_range を使用するために必要
int main() {
// std::vector の例
std::vector<int> numbers = {10, 20, 30};
try {
// 有効なインデックス
std::cout << "numbers.at(1): " << numbers.at(1) << std::endl;
// 範囲外のインデックス
std::cout << "numbers.at(3): " << numbers.at(3) << std::endl; // ここで out_of_range がスローされる
} catch (const std::out_of_range& e) {
std::cerr << "std::out_of_range caught: " << e.what() << std::endl;
}
std::cout << std::endl;
// std::string の例
std::string text = "Hello";
try {
// 有効なインデックス
std::cout << "text.at(0): " << text.at(0) << std::endl;
// 範囲外のインデックス
std::cout << "text.at(10): " << text.at(10) << std::endl; // ここで out_of_range がスローされる
} catch (const std::out_of_range& e) {
std::cerr << "std::out_of_range caught: " << e.what() << std::endl;
}
// std::map の例
std::map<std::string, int> ages = {{"Alice", 30}, {"Bob", 25}};
try {
// 存在するキー
std::cout << "Alice's age: " << ages.at("Alice") << std::endl;
// 存在しないキー
std::cout << "Charlie's age: " << ages.at("Charlie") << std::endl; // ここで out_of_range がスローされる
} catch (const std::out_of_range& e) {
std::cerr << "std::out_of_range caught: " << e.what() << std::endl;
}
return 0;
}
std::out_of_rangeの一般的なエラーと原因
std::out_of_rangeが発生する最も一般的な原因は、コンテナ（std::vector, std::string, std::mapなど）の要素に不正なインデックスやキーでアクセスしようとすることです。
-
- 原因
配列や文字列のインデックスは0から始まるため、要素数がNの場合、有効なインデックスは0からN-1までです。しかし、誤ってN以上のインデックスや負のインデックスを使用すると発生します。特に、at()メソッドは範囲チェックを行うため、この例外をスローします。[]演算子を使用した場合は未定義動作となり、クラッシュしたり予期せぬ結果を引き起こす可能性があります。 - 例
std::vector<int> v = {1, 2, 3}; // v.at(3); // 有効なインデックスは 0, 1, 2。3は範囲外。 // v.at(-1); // 負のインデックスも範囲外。
- 原因
-
ループ条件の誤り（「オフ・バイ・ワン・エラー」）
- 原因
forループなどでインデックスを扱う際、ループ条件が適切でないために、最後の要素の次（または最初の要素の前）にアクセスしてしまうことがあります。 - 例
std::string s = "abc"; // for (size_t i = 0; i <= s.length(); ++i) { // s.length() (3) もアクセスしようとする // std::cout << s.at(i); // }s.at(s.length())でstd::out_of_rangeが発生します。正しいループ条件は通常i < s.length()です。
- 原因
-
std::mapやstd::unordered_mapでの存在しないキーへのアクセス
- 原因
std::mapやstd::unordered_mapのat()メソッドは、存在しないキーで要素にアクセスしようとするとstd::out_of_rangeをスローします。[]演算子を使った場合は、キーが存在しないときに新しい要素が挿入されるため、例外は発生しませんが、意図しない挙動になることがあります。 - 例
std::map<std::string, int> ages = {{"Alice", 30}}; // ages.at("Bob"); // "Bob"というキーは存在しない。
- 原因
-
std::stringの操作関数（substr, find, eraseなど）の引数ミス
- 原因
std::string::substr()やstd::string::erase()などの関数は、開始位置や長さが文字列の有効な範囲を超えている場合にstd::out_of_rangeをスローします。また、std::string::find()系関数が目的の文字列を見つけられなかった場合、std::string::nposを返しますが、これを誤ってインデックスとして使用すると問題が発生します。 - 例
std::string s = "example"; // s.substr(10); // 開始位置が文字列の長さ (7) を超えている。 // size_t pos = s.find("z"); // "z"は含まれないため std::string::npos が返る // s.at(pos); // std::string::npos は非常に大きな値なので、範囲外アクセスになる。
- 原因
-
数値変換関数のオーバーフロー/アンダーフロー
- 原因
std::stoi(),std::stoul(),std::stod()などの文字列から数値への変換関数は、変換結果がターゲットの数値型で表現できる範囲を超えた場合にstd::out_of_rangeをスローすることがあります。 - 例
// std::stoi("999999999999999999999999999"); // int の最大値を超える
- 原因
std::out_of_rangeが発生した際のトラブルシューティングは、問題の原因を特定し、適切な修正を行うことが中心になります。
-
スタックトレースの確認
- 例外がスローされたときに、デバッガを使用している場合はスタックトレースを確認します。これにより、どの関数のどの行で例外が発生したかを正確に特定できます。これはデバッグの第一歩であり、最も重要な情報源です。
-
インデックス/キーの範囲チェック
std::vectorやstd::stringのat()を使う前に、常にインデックスが有効な範囲内にあるかを確認します。if (index >= 0 && index < myVector.size()) { // 安全に myVector.at(index) にアクセス } else { // エラー処理、ログ出力など }std::mapやstd::unordered_mapの場合、count()やfind()を使ってキーが存在するかを確認してからat()を使用します。C++20以降ではcontains()も利用できます。if (myMap.count(key) > 0) { // または myMap.find(key) != myMap.end() // 安全に myMap.at(key) にアクセス } else { // キーが存在しない場合のエラー処理 } // C++20以降 if (myMap.contains(key)) { // 安全に myMap.at(key) にアクセス }
-
ループ条件の確認
forループの条件（i < Nやi <= N-1など）が正しいか、特に「オフ・バイ・ワン・エラー」がないかを確認します。- 可能であれば、C++11で導入された範囲ベースforループ（range-based for loop）を使用すると、インデックスの管理ミスを減らすことができます。
for (const auto& element : myVector) { // 各要素を安全に処理 }
-
std::string::nposのチェック
std::string::find()などの関数がstd::string::nposを返す可能性がある場合、その値をチェックしてから操作に進みます。size_t pos = s.find("pattern"); if (pos != std::string::npos) { // 見つかった場合の処理 } else { // 見つからなかった場合の処理 }
-
try-catchブロックによる例外処理
- 予期せぬ状況で
std::out_of_rangeが発生する可能性がある場合、あるいはプログラムが継続できるようなエラーであれば、try-catchブロックで例外を捕捉し、適切なエラー処理を行うことを検討します。 - ただし、安易に全ての
std::out_of_rangeを捕捉して無視すると、プログラムの根本的なバグが見逃される可能性があるため、慎重に適用する必要があります。 - 理想的には、例外が発生する前に問題を回避する（上記の範囲チェックなど）方が望ましいです。
- 予期せぬ状況で
-
入力値の検証
- 外部からの入力（ユーザー入力、ファイルからの読み込み、ネットワークデータなど）に基づいてインデックスやキーを生成している場合、それらの入力値が有効な範囲内にあることを厳密に検証します。
-
デバッガの活用
- デバッガ（Visual Studio, GDB, LLDBなど）を使ってステップ実行し、問題が発生する直前の変数の値（特にインデックス、コンテナのサイズ、キーなど）を確認します。これにより、論理的な誤りを見つけやすくなります。
-
コンテナのサイズ変更に関する注意
- ループ内でコンテナのサイズを変更する操作（
push_back,eraseなど）を行う場合、インデックスやイテレータの有効性が失われる（無効化される）可能性があります。これにより、見かけ上は正しいインデックスでもout_of_rangeが発生することがあります。コンテナのサイズ変更を伴うループは特に注意が必要です。
- ループ内でコンテナのサイズを変更する操作（
例1: std::vector::at()による範囲外アクセス
std::vectorの要素にアクセスする際、[]演算子とat()メソッドの2つの主な方法があります。at()メソッドは範囲チェックを行い、範囲外のインデックスが指定された場合にstd::out_of_range例外をスローします。
#include <iostream>
#include <vector>
#include <stdexcept> // std::out_of_range を使うために必要
int main() {
std::vector<int> numbers = {10, 20, 30};
// --- 正常なアクセス ---
try {
int value = numbers.at(1); // インデックス1 (20) にアクセス
std::cout << "numbers.at(1): " << value << std::endl;
} catch (const std::out_of_range& e) {
std::cerr << "例外捕捉 (正常なアクセス): " << e.what() << std::endl;
}
// --- 範囲外アクセスによる std::out_of_range ---
try {
// numbers のサイズは 3 なので、有効なインデックスは 0, 1, 2 です。
// インデックス 3 は範囲外です。
int value = numbers.at(3); // ここで std::out_of_range がスローされる
std::cout << "numbers.at(3): " << value << std::endl; // ここは実行されない
} catch (const std::out_of_range& e) {
std::cerr << "例外捕捉 (範囲外アクセス): " << e.what() << std::endl;
// エラーログの記録、ユーザーへの通知、またはプログラムの安全な終了など
}
// --- [] 演算子による範囲外アクセス (未定義動作) ---
// [] 演算子は範囲チェックを行わないため、out_of_range はスローされません。
// その代わり、未定義動作 (Undefined Behavior) となり、
// プログラムのクラッシュ、不正な値の読み込み、セキュリティホールなど、
// 予測不能な結果を引き起こす可能性があります。
// std::cout << "numbers[3]: " << numbers[3] << std::endl; // 非常に危険なコード
return 0;
}
解説
numbers[3]のような[]演算子による範囲外アクセスは、コンパイルエラーにはなりませんが、実行時に未定義動作を引き起こします。これはat()を使うべき理由の一つです。numbers.at(3)は範囲外のインデックスなので、std::out_of_range例外がスローされ、catchブロックが実行されます。エラーメッセージ（e.what()）が表示されます。numbers.at(1)は有効なインデックスなので、正常に値（20）が出力されます。
例2: std::string::at()とstd::string::substr()による範囲外アクセス
std::stringもstd::vectorと同様にat()メソッドを持ちます。また、部分文字列を取得するsubstr()も引数が不正な場合にstd::out_of_rangeをスローすることがあります。
#include <iostream>
#include <string>
#include <stdexcept>
int main() {
std::string s = "Hello C++"; // 長さ 9
// --- std::string::at() による範囲外アクセス ---
try {
char c = s.at(8); // インデックス 8 (最後の文字 '+')
std::cout << "s.at(8): " << c << std::endl;
// s の長さは 9 なので、有効なインデックスは 0-8 です。
// インデックス 9 は範囲外です。
char c_invalid = s.at(9); // ここで std::out_of_range がスローされる
std::cout << "s.at(9): " << c_invalid << std::endl;
} catch (const std::out_of_range& e) {
std::cerr << "例外捕捉 (string::at): " << e.what() << std::endl;
}
std::cout << std::endl;
// --- std::string::substr() による範囲外アクセス ---
try {
// substr(pos, len)
// pos: 開始位置, len: 長さ
// 正常な部分文字列の取得
std::string sub1 = s.substr(0, 5); // "Hello"
std::cout << "s.substr(0, 5): " << sub1 << std::endl;
// 開始位置が範囲外
// s.length() (9) を超える開始位置
std::string sub2 = s.substr(10, 5); // ここで std::out_of_range がスローされる
std::cout << "s.substr(10, 5): " << sub2 << std::endl;
} catch (const std::out_of_range& e) {
std::cerr << "例外捕捉 (string::substr - 開始位置): " << e.what() << std::endl;
}
std::cout << std::endl;
// --- substr() の長さが文字列の終わりを超える場合 ---
// この場合は out_of_range はスローされず、文字列の終わりまでが返されます。
// 例外がスローされるのは 'pos' (開始位置) が無効な場合です。
try {
std::string sub3 = s.substr(6, 100); // "C++" (長さ 3) が返る
std::cout << "s.substr(6, 100): " << sub3 << std::endl; // 正常
} catch (const std::out_of_range& e) {
std::cerr << "例外捕捉 (string::substr - 長さ): " << e.what() << std::endl;
}
return 0;
}
解説
s.substr(6, 100)のように、開始位置は正しいが長さが文字列の終わりを超える場合、std::out_of_rangeはスローされません。代わりに、利用可能な残りの文字すべてが返されます。s.substr(10, 5)は開始位置10が文字列の長さ9を超えているため、std::out_of_rangeがスローされます。s.at(9)はstd::stringの範囲外なので、std::out_of_rangeがスローされます。
例3: std::map::at()による存在しないキーへのアクセス
std::mapやstd::unordered_mapもat()メソッドを持ち、存在しないキーでアクセスしようとした場合にstd::out_of_rangeをスローします。
#include <iostream>
#include <map>
#include <string>
#include <stdexcept>
int main() {
std::map<std::string, int> ages;
ages["Alice"] = 30;
ages["Bob"] = 25;
// --- 存在するキーへのアクセス ---
try {
int alice_age = ages.at("Alice");
std::cout << "Alice's age: " << alice_age << std::endl;
} catch (const std::out_of_range& e) {
std::cerr << "例外捕捉 (map::at - 既存キー): " << e.what() << std::endl;
}
// --- 存在しないキーへのアクセス ---
try {
// "Charlie" は map に存在しないキーです
int charlie_age = ages.at("Charlie"); // ここで std::out_of_range がスローされる
std::cout << "Charlie's age: " << charlie_age << std::endl;
} catch (const std::out_of_range& e) {
std::cerr << "例外捕捉 (map::at - 不明キー): " << e.what() << std::endl;
std::cerr << "エラー: キー 'Charlie' が見つかりません。" << std::endl;
}
// --- [] 演算子と存在しないキー ---
// [] 演算子を使用すると、キーが存在しない場合にそのキーで新しい要素が挿入されます。
// 例外はスローされません。
int david_age = ages["David"]; // "David" というキーで新しい要素が挿入され、値はデフォルト初期化 (0) される
std::cout << "David's age (after []): " << david_age << std::endl;
std::cout << "Map size after 'David': " << ages.size() << std::endl; // サイズが増えている
std::cout << "ages[\"David\"]: " << ages["David"] << std::endl;
return 0;
}
解説
ages["David"]のように[]演算子を使うと、"David"というキーが存在しない場合に自動的にそのキーとデフォルト値（int型の場合は0）で新しい要素がマップに挿入されます。これは便利な挙動ですが、キーの存在を確認したいだけで挿入したくない場合には意図しない動作になる可能性があります。ages.at("Charlie")は存在しないキーなので、std::out_of_rangeがスローされ、catchブロックが実行されます。ages.at("Alice")は存在するキーなので、正常に値（30）が出力されます。
std::stoi (string to int) などの数値変換関数は、変換しようとする文字列が数値として解析できない場合や、結果が対象の数値型の範囲を超える（オーバーフロー/アンダーフロー）場合にstd::out_of_rangeをスローすることがあります。
#include <iostream>
#include <string>
#include <stdexcept> // std::out_of_range や std::invalid_argument を使うために必要
int main() {
std::string input;
// --- 正常な数値変換 ---
std::cout << "整数を入力してください (例: 123): ";
std::cin >> input;
try {
int number = std::stoi(input);
std::cout << "変換された数値: " << number << std::endl;
} catch (const std::invalid_argument& e) {
std::cerr << "例外捕捉 (無効な引数): " << e.what() << std::endl;
std::cerr << "エラー: 数値として解析できませんでした。" << std::endl;
} catch (const std::out_of_range& e) {
std::cerr << "例外捕捉 (範囲外): " << e.what() << std::endl;
std::cerr << "エラー: 変換された数値が int の範囲を超えています。" << std::endl;
}
std::cout << std::endl;
// --- 数値の範囲外 (オーバーフロー) ---
// int の最大値より大きな数値を文字列で指定
std::string large_number_str = "2147483647000"; // int の最大値は 2147483647
std::cout << "大きな数値を変換: " << large_number_str << std::endl;
try {
long long_number = std::stoll(large_number_str); // long long なら変換できる可能性
std::cout << "変換された数値 (long): " << long_number << std::endl;
int int_number = std::stoi(large_number_str); // ここで out_of_range がスローされる
std::cout << "変換された数値 (int): " << int_number << std::endl;
} catch (const std::invalid_argument& e) {
std::cerr << "例外捕捉 (無効な引数): " << e.what() << std::endl;
std::cerr << "エラー: 数値として解析できませんでした。" << std::endl;
} catch (const std::out_of_range& e) {
std::cerr << "例外捕捉 (範囲外): " << e.what() << std::endl;
std::cerr << "エラー: 変換された数値が型の範囲を超えています。" << std::endl;
}
return 0;
}
try-catchブロックで両方の可能性に対応するのが一般的です。- 文字列が数値として有効だが、その値が
int型で表現できる範囲（通常 -2,147,483,648 から 2,147,483,647）を超えている場合（例:"2147483647000"）、std::out_of_rangeがスローされます。 std::stoi()は、文字列が数値として有効でない場合（例:"abc"）にはstd::invalid_argumentをスローします。
事前条件チェックとエラーコード/早期リターン
例外は「例外的な状況」のために予約されるべきであり、頻繁に発生しうるエラー（例: ユーザーが不正なインデックスを入力するなど）に対しては、例外を使わないアプローチが推奨されることがあります。
-
例（std::vectorのインデックスアクセス）
#include <iostream> #include <vector> #include <optional> // C++17 から利用可能 // 1. エラーコードを返す例 bool get_vector_element_by_index_error_code(const std::vector<int>& vec, size_t index, int& out_value) { if (index < vec.size()) { out_value = vec[index]; // [] 演算子は範囲チェックしないが、ここでは上位でチェックしている return true; // 成功 } return false; // 失敗 } // 2. std::optional を返す例 (C++17以降) // 値が存在しない可能性を明示的に示す std::optional<int> get_vector_element_by_index_optional(const std::vector<int>& vec, size_t index) { if (index < vec.size()) { return vec[index]; } return std::nullopt; // 値が存在しないことを示す } int main() { std::vector<int> numbers = {10, 20, 30}; // エラーコードの例 int value_ec; if (get_vector_element_by_index_error_code(numbers, 1, value_ec)) { std::cout << "エラーコード: numbers[1] = " << value_ec << std::endl; } else { std::cout << "エラーコード: 範囲外アクセスが発生しました。" << std::endl; } if (get_vector_element_by_index_error_code(numbers, 3, value_ec)) { // 範囲外 std::cout << "エラーコード: numbers[3] = " << value_ec << std::endl; } else { std::cout << "エラーコード: 範囲外アクセスが発生しました。" << std::endl; } std::cout << std::endl; // std::optional の例 std::optional<int> opt_value = get_vector_element_by_index_optional(numbers, 1); if (opt_value) { // 値が存在するかチェック std::cout << "optional: numbers[1] = " << *opt_value << std::endl; } else { std::cout << "optional: 範囲外アクセスが発生しました。" << std::endl; } opt_value = get_vector_element_by_index_optional(numbers, 3); // 範囲外 if (opt_value) { std::cout << "optional: numbers[3] = " << *opt_value << std::endl; } else { std::cout << "optional: 範囲外アクセスが発生しました。" << std::endl; } return 0; } -
欠点
- 関数が返す値がエラーを示す特別な値と衝突する可能性があります（例: 0が有効な値でもあり、エラーコードでもある場合）。
- エラーコードを適切にチェックしないと、静かにバグが潜在する可能性があります。
-
- 例外処理のオーバーヘッドを避けることができるため、パフォーマンスが重要な場面で有利です。
- コードのフローが予測しやすくなります。
- 呼び出し元がエラー処理を強制されるため、見過ごしにくいです（ただし、エラーコードのチェックを怠ると問題になります）。
std::map::find()またはstd::map::count()によるキーの存在チェック
std::mapやstd::unordered_mapでat()メソッドの代わりに[]演算子を使用する場合、存在しないキーでは新しい要素が挿入されてしまい、意図しない動作になることがあります。キーの存在を確認したいだけであれば、find()またはcount()を使用します。
-
例
#include <iostream> #include <map> #include <string> int main() { std::map<std::string, int> ages = {{"Alice", 30}, {"Bob", 25}}; // find() を使用してキーを検索 auto it = ages.find("Alice"); if (it != ages.end()) { std::cout << "find: Alice's age = " << it->second << std::endl; } else { std::cout << "find: Alice は見つかりませんでした。" << std::endl; } it = ages.find("Charlie"); // 存在しないキー if (it != ages.end()) { std::cout << "find: Charlie's age = " << it->second << std::endl; } else { std::cout << "find: Charlie は見つかりませんでした。" << std::endl; } std::cout << std::endl; // count() を使用してキーの存在をチェック (bool のように使える) if (ages.count("Bob")) { std::cout << "count: Bob's age = " << ages["Bob"] << std::endl; // countで存在確認後、[]でアクセス } else { std::cout << "count: Bob は見つかりませんでした。" << std::endl; } if (ages.count("David")) { // 存在しないキー std::cout << "count: David's age = " << ages["David"] << std::endl; } else { std::cout << "count: David は見つかりませんでした。" << std::endl; } // C++20 以降では contains() が便利 // if (ages.contains("Alice")) { /* ... */ } return 0; } -
欠点
- キーが存在しない場合の処理を明示的に記述する必要があります。
-
利点
at()のように例外をスローしないため、通常の制御フロー内で処理できます。[]演算子のように意図しない要素の挿入を防ぎます。
範囲ベースforループとイテレータ
コンテナの全要素を処理する場合、インデックスベースのループは「オフ・バイ・ワン」エラーなど、std::out_of_rangeの原因となるミスを引き起こしやすいです。範囲ベースforループやイテレータを使用すると、この種のエラーを根本的に排除できます。
-
例
#include <iostream> #include <vector> #include <string> int main() { std::vector<int> numbers = {10, 20, 30}; std::string s = "Hello"; // 範囲ベース for ループ (C++11以降) std::cout << "範囲ベース for ループ (vector): "; for (int n : numbers) { std::cout << n << " "; } std::cout << std::endl; std::cout << "範囲ベース for ループ (string): "; for (char c : s) { std::cout << c << " "; } std::cout << std::endl; std::cout << std::endl; // イテレータを使用 std::cout << "イテレータ (vector): "; for (auto it = numbers.begin(); it != numbers.end(); ++it) { std::cout << *it << " "; } std::cout << std::endl; return 0; } -
欠点
- 特定のインデックスの要素にアクセスしたい場合には使えません。
-
利点
- コードが簡潔で読みやすくなります。
- インデックスに関連する範囲外エラーのリスクを排除できます。
- コンテナの内部実装に依存しないジェネリックなコードになります。
ガード句とアサート
開発段階でのみ発生するはずの論理的なエラー（例: プログラマのミスによる不正なインデックス）に対しては、assert()を使用することがあります。これはリリースビルドでは削除されるため、実行時のオーバーヘッドがありません。
-
例
#include <iostream> #include <vector> #include <cassert> // assert を使うために必要 int main() { std::vector<int> numbers = {10, 20, 30}; size_t valid_index = 1; size_t invalid_index = 3; // プログラマのロジックエラーをチェックするためのアサート // リリースビルドでは削除される assert(valid_index < numbers.size() && "Valid index should be within bounds!"); std::cout << "numbers[" << valid_index << "]: " << numbers[valid_index] << std::endl; // このアサートは失敗し、プログラムが終了する (デバッグビルドの場合) // assert(invalid_index < numbers.size() && "Invalid index detected!"); // std::cout << "numbers[" << invalid_index << "]: " << numbers[invalid_index] << std::endl; return 0; } -
欠点
- リリースビルドではチェックが行われないため、エンドユーザー環境でのクラッシュを防ぐことはできません。
- プログラムの継続的な実行を保証しません。
-
利点
- 開発中に早期にバグを発見できます。
- リリースビルドではパフォーマンスへの影響がありません。
「例外は例外的な状況に」という原則
std::out_of_rangeはstd::logic_errorから派生しており、これは「プログラムの内部的な論理エラー」を示すものです。つまり、std::out_of_rangeがスローされる状況は、本来プログラマのバグによって引き起こされるべきものであり、実行時にユーザー入力などによって頻繁に起こることを想定しているものではない、と考えることができます。
- 原則
ほとんどのstd::out_of_rangeは、コードのロジックに問題があることを示唆しています。そのため、try-catchで捕捉して続行するよりも、そのようなエラーが発生しないようにコードを修正する方が良いとされています。