C++向けBoost.JSON入門：高速かつ安全なJSON処理

1. はじめに

現代のソフトウェア開発において、JSON (JavaScript Object Notation) はデータ交換のデファクトスタンダードとなっています。Webサービス間のAPI連携、設定ファイルの記述、ログデータの構造化など、その用途は多岐にわたります。C++アプリケーションにおいても、JSONデータの生成、パース、操作は不可欠な機能となっています。

しかし、C++でJSONを効率的かつ安全に扱うことは、時に挑戦的な課題となります。C++は低レベルなメモリ管理を可能にする反面、不適切な実装はパフォーマンスのボトルネックやメモリリーク、クラッシュなどのセキュリティ脆弱性につながる可能性があります。市場には nlohmann/json や RapidJSON、simdjson といった多くのJSONライブラリが存在しますが、それぞれに設計思想、パフォーマンス特性、APIの使いやすさ、そして安全性に関するトレードオフがあります。

本記事では、Boostライブラリ群の一部として提供される Boost.JSON に焦点を当てます。Boost.JSON は、C++の強力な型システムとBoostエコシステムの堅牢性を背景に、高速性と安全性を両立させたJSON処理を提供します。特に、その革新的なメモリ管理戦略（モノトニックアロケータなど）や、堅牢なエラーハンドリング、そして柔軟なAPIデザインは、C++開発者が直面するJSON処理の課題を効果的に解決します。

この記事は、Boost.JSON を利用してC++アプリケーションでJSONを扱うための包括的なガイドとなることを目指します。基本的な使い方から、パフォーマンスを最大化するための高度なテクニック、そして安全なコードを書くためのベストプラクティスまで、幅広くカバーします。C++でJSON処理の品質を向上させたいと考えている開発者、特にパフォーマンスと堅牢性が求められるシステムを構築している方々にとって、必読の内容となるでしょう。

さあ、Boost.JSON の世界に飛び込み、C++でのJSON処理を次のレベルへと引き上げましょう。

2. Boost.JSONとは何か？

Boostライブラリは、C++プログラミングの様々な側面をカバーする高品質なピアレビューされたオープンソースライブラリの集合体です。C++標準ライブラリの拡張とも言える位置付けで、多くのBoostライブラリは後にC++標準に採用されてきました (std::shared_ptr, std::function, std::thread など)。Boost.JSON は、このBoostファミリーの一員として、C++でJSONデータを扱うための包括的かつ高性能なソリューションを提供します。

2.1 Boost.JSONの主要な特徴

Boost.JSON は、以下の特徴により他のJSONライブラリと一線を画しています。

2.1.1 メモリ効率と高速性 (Performance)

Boost.JSON は、特にアロケータ戦略においてそのパフォーマンスへのこだわりを見せます。
* モノトニックアロケータ (boost::json::monotonic_resource): メモリプールの一種で、一度確保したメモリを使い切り、途中で個別の解放を行わないことで、メモリ割り当てのオーバーヘッドを劇的に削減します。これにより、大量のJSONパースや生成において、メモリフラグメンテーションを防ぎ、CPUキャッシュ効率を最大化します。
* ゼロコピーパースの可能性: 特定の条件下では、入力文字列のデータを直接参照し、コピーを最小限に抑えることで、メモリ使用量と実行時間を削減します。
* インプレース処理: 可能な限り既存のバッファ内で処理を行い、余分なメモリ割り当てを避けます。

2.1.2 型安全性と堅牢性 (Safety and Robustness)

C++の強力な型システムを最大限に活用し、実行時エラーを最小限に抑えるための設計がなされています。
* boost::json::value: JSONの異なる型（オブジェクト、配列、文字列、数値、真偽値、null）をポリモーフィックに表現する型です。これにより、任意のJSON構造を柔軟に扱えます。
* 厳格な型チェック: value::as_object() や value::at() のようなメソッドは、不正な型キャストや存在しないキーへのアクセスに対して例外やエラーコードを返すことで、プログラムの堅牢性を高めます。
* エラーハンドリング: boost::system::error_code を利用したC++標準的なエラーレポートメカニズムと、例外の両方に対応し、開発者がエラー処理戦略を選択できるようにしています。

2.1.3 APIの使いやすさ (Ease of Use)

Boostライブラリ共通の高品質なAPIデザイン哲学が適用されています。
* 直感的なAPI: std::map や std::vector に似たインターフェースを提供し、C++開発者にとって馴染みやすい操作性を提供します。
* ユーザー定義型との連携: value_to および value_from 関数テンプレートを通じて、C++のカスタムクラスや構造体とJSONデータとのシームレスな相互変換をサポートします。

2.1.4 C++標準への適合性

C++11以降の標準に準拠しており、現代的なC++の機能 (move semantics, constexpr など) を活用しています。Boostエコシステムとの統合も強みであり、Boost.Beast (HTTP/WebSocket) や Boost.ASIO (非同期I/O) といった他のBoostライブラリと組み合わせて使うことで、強力なネットワークアプリケーションを構築できます。

2.2 他のJSONライブラリとの比較

Boost.JSON の立ち位置をより明確にするため、広く使われている他のC++ JSONライブラリと比較してみましょう。

• nlohmann/json (JSON for Modern C++):

  • 特徴: 単一ヘッダファイルで手軽に利用でき、Pythonのような直感的なAPIが人気です。C++11以降の標準を積極的に活用しています。
  • トレードオフ: 一般的に Boost.JSON や RapidJSON に比べてメモリ使用量が多く、大規模データや高性能が要求されるシナリオではパフォーマンスが劣る傾向があります。動的なメモリ割り当てが頻繁に発生します。
  • Boost.JSONとの比較: Boost.JSON は、アロケータ戦略によりメモリ効率と速度で優位に立ちます。APIの使いやすさでは nlohmann/json も優れていますが、Boost.JSON はよりC++イディオマティックで、厳密な型安全性を提供します。

• RapidJSON:

  • 特徴: 極めて高いパフォーマンスとメモリ効率を誇ります。SAX (Simple API for XML) パーサーのようにイベント駆動型で処理できるため、巨大なJSONファイルを低メモリフットプリントで扱えます。
  • トレードオフ: DOM (Document Object Model) APIも提供しますが、SAXは使いこなすのに学習コストがかかります。また、エラーハンドリングがC++の例外ではなく戻り値ベースで、コードが複雑になることがあります。
  • Boost.JSONとの比較: RapidJSON はRawなパフォーマンスで Boost.JSON を上回ることもありますが、Boost.JSON は RapidJSON のSAXパーサーの複雑さを避けつつ、DOMベースの使いやすさと高いパフォーマンスを両立しています。Boost.JSON のアロケータ戦略は、RapidJSON と同等かそれに近いメモリ効率と速度を実現できる場面もあります。

• simdjson:

  • 特徴: SIMD (Single Instruction, Multiple Data) 命令セットを積極的に利用し、驚異的なパース速度を実現します。非常に大きなJSONファイルを扱うのに最適です。
  • トレードオフ: 基本的にパースに特化しており、JSON生成やDOM操作の機能は限定的です。APIも比較的低レベルです。
  • Boost.JSONとの比較: simdjson はパース速度の絶対値で群を抜きますが、Boost.JSON はより汎用的なJSON処理（生成、操作、型変換）を高速かつ安全に提供します。用途によって使い分けが可能です。

2.3 なぜBoost.JSONを選ぶのか？

Boost.JSON は、これらのライブラリの中間点をうまく突いています。nlohmann/json の使いやすさと、RapidJSON のパフォーマンスを高いレベルで融合しようとしています。特に、以下のシナリオでその真価を発揮します。

1. 高性能が要求されるバックエンドサービス: 低レイテンシで多数のJSONリクエストを処理する必要がある場合。
2. メモリフットプリントが重要な組み込みシステム: 限られたメモリ資源でJSONを効率的に扱いたい場合。
3. 堅牢性と安全性が最優先されるアプリケーション: 予期せぬ入力やランタイムエラーを確実に処理したい場合。
4. Boostエコシステムを既に利用しているプロジェクト: 他のBoostライブラリとのシームレスな統合を望む場合。

次に、Boost.JSON を実際に使い始めるための環境構築と、基本的な操作を見ていきましょう。

3. 環境構築と基本的な使い方

Boost.JSON をC++プロジェクトで利用するには、まずBoostライブラリをシステムにインストールし、プロジェクトのビルド設定に含める必要があります。ここでは、vcpkg を使ったインストール方法と、CMake を使ったプロジェクト設定の例を示します。

3.1 Boostライブラリのインストール

vcpkg は、C++ライブラリの管理を容易にするクロスプラットフォームのパッケージマネージャーです。これを使用するのが最も簡単な方法の一つです。

1. vcpkgのインストール (まだの場合):
   bash
git clone https://github.com/microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh # Linux/macOS
# または .\bootstrap-vcpkg.bat # Windows
./vcpkg integrate install

2. Boost.JSONのインストール:
   bash
vcpkg install boost-json
   これにより、Boost.JSON およびその依存関係が自動的にインストールされます。

その他のインストール方法

• Conan: 別の人気パッケージマネージャーです。conan install boost/1.xx.x@ -o boost:json=True のようにしてインストールできます。
• ソースビルド: Boostの公式サイトからソースコードをダウンロードし、手動でビルドすることも可能です。これは最も柔軟ですが、最も手間がかかる方法です。./bootstrap.sh --with-libraries=json で b2 をビルドし、./b2 install でインストールします。

3.2 CMakeLists.txtでの設定方法

CMake はC++プロジェクトのビルドシステムとして広く使われています。Boost.JSON をプロジェクトに組み込むには、CMakeLists.txt ファイルに以下の設定を追加します。

“`cmake

CMakeLists.txt

cmake_minimum_required(VERSION 3.10)
project(BoostJsonExample LANGUAGES CXX)

vcpkgを使用する場合、Toolchain Fileを指定

CMake呼び出し時に -DCMAKE_TOOLCHAIN_FILE=/path/to/vcpkg/scripts/buildsystems/vcpkg.cmake を指定するか、

環境変数 VCPKG_ROOT を設定する。

あるいは、ここでは直接CMakeでvcpkgのツールチェーンをロードする例。

if(EXISTS “$ENV{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake”)

set(CMAKE_TOOLCHAIN_FILE “$ENV{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake”)

elseif(EXISTS “${CMAKE_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake”)

set(CMAKE_TOOLCHAIN_FILE “${CMAKE_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake”)

endif()

Boostライブラリを検索

COMPONENTSキーワードで必要なサブライブラリを指定

find_package(Boost REQUIRED COMPONENTS json)

実行可能ファイルを定義

add_executable(my_json_app main.cpp)

Boost.JSONライブラリをリンク

Boost::json はBoostが提供するターゲット名

target_link_libraries(my_json_app PRIVATE Boost::json)

もしBoostのヘッダーファイルが見つからない場合は、以下を追加する必要があるかもしれません

include_directories(${Boost_INCLUDE_DIRS})

“`

CMake を使ってビルドディレクトリを作成し、コンパイルします。

“`bash
mkdir build
cd build
cmake ..

または vcpkg を使用する場合:

cmake .. -DCMAKE_TOOLCHAIN_FILE=/path/to/vcpkg/scripts/buildsystems/vcpkg.cmake

cmake –build .
“`

3.3 シンプルなJSONオブジェクトの生成とシリアライズ

それでは、実際に Boost.JSON を使ってJSONデータを生成し、文字列にシリアライズする基本的な例を見てみましょう。

“`cpp
// main.cpp

include // Boost.JSONのメインヘッダ

include

include

int main() {
// 1. boost::json::value オブジェクトを作成
// JSONのルート要素は通常オブジェクトか配列
boost::json::value jv = boost::json::object();

// 2. オブジェクトにキーと値を追加
// operator[] で直接アクセスし、値を代入
jv.at("name") = "Alice"; // at() は存在しないキーの場合に例外をスロー
jv.at("age") = 30;
jv.at("isStudent") = false;

// 配列の追加
boost::json::array hobbies;
hobbies.push_back("reading");
hobbies.push_back("hiking");
hobbies.push_back("coding");
jv.at("hobbies") = hobbies;

// ネストしたオブジェクトの追加
boost::json::object address;
address["street"] = "123 Main St";
address["city"] = "Anytown";
address["zipCode"] = "12345";
jv.at("address") = address;

// operator[] はキーが存在しない場合に自動的に追加し、デフォルト値を設定します。
// その後、値を上書きします。
jv["email"] = "[email protected]";

// 3. JSON値を文字列にシリアライズ
// boost::json::serialize() 関数を使用
// 2番目の引数 boost::json::serialize_options::pretty を指定すると整形されて出力
std::string json_string = boost::json::serialize(jv, {boost::json::serialize_options::pretty});

// 4. 結果を出力
std::cout << "Generated JSON:\n" << json_string << std::endl;

return 0;

}
“`

出力例:

json
Generated JSON:
{
"name": "Alice",
"age": 30,
"isStudent": false,
"hobbies": [
"reading",
"hiking",
"coding"
],
"address": {
"street": "123 Main St",
"city": "Anytown",
"zipCode": "12345"
},
"email": "[email protected]"
}

この例では、boost::json::value がJSONの様々な型を柔軟に保持できること、boost::json::object や boost::json::array を使って構造を構築できること、そして boost::json::serialize で簡単に文字列化できることを示しました。at() と operator[] の違いに注目してください。at() は存在しないキーに対して std::out_of_range 例外をスローしますが、operator[] は自動的にキーを追加し、デフォルト値を初期化します。安全なコードでは at() と適切なエラーハンドリングを組み合わせるのが一般的です。

3.4 JSON文字列のパースとデシリアライズ

次に、JSON文字列をパースして Boost.JSON の値オブジェクトに変換し、そこからデータを読み取る例を示します。

“`cpp
// main.cpp (続き)

include

include

include

int main() {
std::string json_input = R”({
“product”: {
“id”: “PROD-001”,
“name”: “Super Widget”,
“price”: 99.99,
“available”: true,
“tags”: [“electronics”, “gadget”, “sale”],
“dimensions”: {
“width”: 10,
“height”: 5,
“depth”: 2
},
“reviews”: null
},
“orderId”: “ORD-XYZ-789″
})”;

// 1. JSON文字列をパース
// boost::json::parse() は、文字列から boost::json::value を生成
boost::json::error_code ec; // エラーコードを受け取るための変数
boost::json::value parsed_jv = boost::json::parse(json_input, ec);

// 2. パースエラーのチェック
if (ec) {
    std::cerr << "JSON Parse Error: " << ec.message() << std::endl;
    return 1;
}

// 3. パースされたJSONデータへのアクセス
// is_object() で型をチェックし、as_object() で boost::json::object& にキャスト
if (parsed_jv.is_object()) {
    boost::json::object& root_obj = parsed_jv.as_object();

    // キーの存在チェックと値の取得
    if (root_obj.contains("orderId")) {
        std::cout << "Order ID: " << root_obj.at("orderId").as_string() << std::endl;
    }

    if (root_obj.contains("product") && root_obj.at("product").is_object()) {
        boost::json::object& product_obj = root_obj.at("product").as_object();

        std::cout << "Product Name: " << product_obj.at("name").as_string() << std::endl;
        std::cout << "Product Price: " << product_obj.at("price").as_double() << std::endl;
        std::cout << "Product Available: " << (product_obj.at("available").as_bool() ? "Yes" : "No") << std::endl;

        // 配列へのアクセス
        if (product_obj.contains("tags") && product_obj.at("tags").is_array()) {
            boost::json::array& tags_array = product_obj.at("tags").as_array();
            std::cout << "Tags: ";
            for (std::size_t i = 0; i < tags_array.size(); ++i) {
                std::cout << tags_array.at(i).as_string() << (i == tags_array.size() - 1 ? "" : ", ");
            }
            std::cout << std::endl;
        }

        // ネストしたオブジェクトへのアクセス
        if (product_obj.contains("dimensions") && product_obj.at("dimensions").is_object()) {
            boost::json::object& dimensions_obj = product_obj.at("dimensions").as_object();
            std::cout << "Dimensions: "
                      << dimensions_obj.at("width").as_int64() << "x"
                      << dimensions_obj.at("height").as_int64() << "x"
                      << dimensions_obj.at("depth").as_int64() << std::endl;
        }

        // null値のチェック
        if (product_obj.contains("reviews")) {
            if (product_obj.at("reviews").is_null()) {
                std::cout << "Reviews: Not available (null)" << std::endl;
            }
        }
    }
}

return 0;

}
“`

出力例:

Order ID: ORD-XYZ-789
Product Name: Super Widget
Product Price: 99.99
Product Available: Yes
Tags: electronics, gadget, sale
Dimensions: 10x5x2
Reviews: Not available (null)

この例では、boost::json::parse() を使ってJSON文字列を boost::json::value に変換しています。ここでは、エラーハンドリングのために boost::system::error_code を使用するオーバーロードを選択しています。パース後、is_object(), is_array(), is_string() などのメソッドでデータの型を検証し、as_object(), as_string() などで適切な型にキャストして値にアクセスしています。contains() メソッドは、キーが存在するかどうかを確認するのに役立ちます。

これらの基本的な例から、Boost.JSON が提供する直感的かつ堅牢なAPIの一端を理解できたはずです。次に、これらのAPIの背後にあるコアコンセプトをさらに深く掘り下げていきます。

4. Boost.JSONのコアコンセプト

Boost.JSON は、JSONのデータ構造をC++のクラスと関数で表現するための明確なコアコンセプトを持っています。これらを理解することで、Boost.JSON を最大限に活用し、より効率的で安全なコードを書くことができます。

4.1 boost::json::value: ポリモーフィックなJSON値

boost::json::value は Boost.JSON の心臓部であり、JSONが持つすべてのデータ型（オブジェクト、配列、文字列、数値、真偽値、null）を表現できるポリモーフィックなラッパー型です。これは std::variant や std::any に似た概念ですが、JSONデータに特化しています。

value 型は、自身の内部に現在保持しているJSONの型を追跡しており、それに応じたアクセスメソッドを提供します。

• 型判別メソッド:

  • is_object(): オブジェクト型か
  • is_array(): 配列型か
  • is_string(): 文字列型か
  • is_int64(), is_uint64(), is_double(): 数値型が特定の整数/浮動小数点型に収まるか
  • is_number(): 数値型か
  • is_bool(): 真偽値型か
  • is_null(): null型か

• 型キャストメソッド:

  • as_object(): boost::json::object& を返す
  • as_array(): boost::json::array& を返す
  • as_string(): boost::json::string& を返す
  • as_int64(), as_uint64(), as_double(), as_bool(): それぞれのC++プリミティブ型を返す

これらの as_X() メソッドは、value が保持している型と異なる型にキャストしようとすると、boost::json::system_error 例外をスローします。これは、実行時における不正な型アクセスを防ぐための安全メカニズムです。

例:

“`cpp
boost::json::value v_str(“hello”);
boost::json::value v_num(123);
boost::json::value v_bool(true);
boost::json::value v_null(nullptr); // または boost::json::value()

std::cout << v_str.is_string() << std::endl; // 1 (true)
std::cout << v_num.as_int64() << std::endl; // 123
std::cout << v_bool.as_bool() << std::endl; // 1 (true)
std::cout << v_null.is_null() << std::endl; // 1 (true)

try {
v_str.as_int64(); // v_str は文字列なので例外発生
} catch (const boost::system::system_error& e) {
std::cerr << “Error: ” << e.what() << std::endl; // boost.json: bad_cast
}
“`

4.2 boost::json::object: JSONオブジェクト（キー-値ペア）

boost::json::object は、JSONオブジェクトを表現する型で、キーと値のペアの順序付けられていないコレクションです。これは std::map<boost::json::string, boost::json::value> に似ていますが、boost::json::object はより最適化された内部実装を持ちます。

• 操作:
  • emplace(key, value): キーと値を挿入。キーが既に存在する場合は更新。
  • at(key): キーに対応する値への参照を返す。キーが存在しない場合は例外。
  • operator[](key): キーに対応する値への参照を返す。キーが存在しない場合は自動的に挿入し、デフォルト値を設定。
  • contains(key): キーが存在するかどうかをチェック。
  • erase(key): キーと値を削除。
  • イテレータ (begin(), end()): 全てのキー-値ペアを走査。

例:

“`cpp
boost::json::object obj;
obj.emplace(“id”, 1001);
obj[“name”] = “Example Item”; // operator[] は存在しない場合に追加

// イテレータで走査
for (auto const& element : obj) {
std::cout << element.key() << “: ” << element.value() << std::endl;
}

if (obj.contains(“id”)) {
std::cout << “ID: ” << obj.at(“id”).as_int64() << std::endl;
}
“`

4.3 boost::json::array: JSON配列

boost::json::array は、JSON配列を表現する型で、順序付けられた値のコレクションです。これは std::vector<boost::json::value> に似ています。

• 操作:
  • push_back(value): 末尾に値を追加。
  • emplace_back(args...): コンストラクタ引数から値を構築して末尾に追加。
  • at(index): インデックスに対応する値への参照を返す。インデックスが範囲外の場合は例外。
  • operator[](index): インデックスに対応する値への参照を返す。
  • size(): 要素数を返す。
  • イテレータ (begin(), end()): 全ての要素を走査。

例:

“`cpp
boost::json::array arr;
arr.push_back(“apple”);
arr.emplace_back(123);
arr.push_back(boost::json::object{{“type”, “fruit”}});

for (std::size_t i = 0; i < arr.size(); ++i) {
std::cout << “Element ” << i << “: ” << arr.at(i) << std::endl;
}
“`

4.4 boost::json::string: JSON文字列

boost::json::string は、JSON文字列を効率的に扱うための専用の文字列型です。これは std::string とは異なる型であり、UTF-8エンコーディングをサポートします。

• std::string との違い:
  • boost::json::string は boost::json::value 内部に効率的に格納されるように設計されています。
  • 小文字列最適化 (SSO) や、特定のアロケータ戦略（後述のモノトニックアロケータなど）と連携して、メモリ割り当てのオーバーヘッドを削減します。
  • 暗黙的な std::string との変換は可能ですが、場合によってはコピーが発生するため、パフォーマンスが要求される場所では boost::json::string を直接使用することが推奨されます。

例:

“`cpp
boost::json::string json_str = “こんにちは、世界！”;
std::string std_str = “Hello, world!”;

// boost::json::string から std::string へ
std::string converted_std_str = json_str.c_str(); // または (std::string)json_str

// std::string から boost::json::string へ
boost::json::string converted_json_str = std_str;

std::cout << “JSON String: ” << json_str << std::endl;
std::cout << “Std String: ” << std_str << std::endl;
“`

4.5 boost::json::storage_ptr とアロケータの利用

Boost.JSON のパフォーマンスと安全性において最も重要な要素の一つが、メモリ管理です。Boost.JSON のすべての value, object, array, string は、内部的にメモリ割り当てのためにアロケータを使用します。デフォルトでは、std::pmr::polymorphic_allocator (またはそれに相当するもの) を使用し、これはヒープから個別にメモリを割り当てます。

しかし、Boost.JSON はカスタムアロケータ、特に boost::json::monotonic_resource を利用することを強く推奨しています。アロケータは boost::json::storage_ptr でラップされて渡されます。

• boost::json::storage_ptr: std::shared_ptr<boost::json::memory_resource> に似たスマートポインタで、JSONデータ構造全体で共有されるメモリリソースを管理します。

• デフォルトアロケータ: boost::json::value や boost::json::object などを引数なしで作成すると、グローバルなデフォルトアロケータが使用されます。これは boost::json::get_default_resource() で取得できます。デフォルトのデフォルトアロケータは、一般的な用途では十分ですが、パフォーマンスを最大化するにはカスタムアロケータの利用が不可欠です。

アロケータの重要性については、次の「高速化のためのテクニック」セクションで詳しく掘り下げます。ここでは、Boost.JSON のデータ構造がメモリ管理を抽象化し、アロケータを通じて柔軟なメモリ戦略を可能にしていることを理解してください。

これらのコアコンセプトをマスターすることで、Boost.JSON を使ったJSONデータの操作をより効率的かつ意図通りに行うことができるようになります。

5. 高速化のためのテクニック

Boost.JSON は設計段階からパフォーマンスを強く意識しており、特にメモリ管理とI/O処理において、いくつかの高度な最適化テクニックを提供しています。ここでは、それらを活用してJSON処理の速度を最大化する方法を学びます。

5.1 メモリ管理とアロケータの最適化

Boost.JSON のパフォーマンスにおける最大の強みの一つが、その柔軟で効率的なアロケータ戦略です。

5.1.1 monotonic_resource の詳細な解説

boost::json::monotonic_resource は、Boost.JSON が提供する最も強力なアロケータの一つです。その名の通り「単調（monotonic）」にメモリを確保します。

• 原理:

  1. あらかじめ指定されたサイズの連続したメモリブロックを（通常はヒープから）確保します。
  2. そのブロック内で、必要なサイズのメモリを「先頭から」割り当てていきます。
  3. メモリ割り当ては単純なポインタのインクリメント操作で行われるため、非常に高速です。
  4. 割り当てられた個々のメモリブロックを個別に解放することはできません。monotonic_resource インスタンスが破棄されるときに、確保されたすべてのメモリが一括で解放されます。
  5. 割り当て済みのメモリブロックが不足した場合、新しいより大きなメモリブロックを確保し、既存のブロックの後に連鎖させて使用を続けます。

• 利点:

  • 極めて高速な割り当て: メモリ割り当てがポインタの移動だけで済むため、通常の new/delete や malloc/free に比べてオーバーヘッドがゼロに近く、CPUキャッシュヒット率も向上します。
  • メモリフラグメンテーションの抑制: 多数の小さなオブジェクトが作成・破棄されることによるメモリの断片化を防ぎます。
  • 高速な一括解放: 関連するすべてのメモリが一度に解放されるため、大量のJSONデータ構造のライフサイクル管理が非常に効率的になります。

• 利用シナリオ:

  • 一時的なJSON処理: HTTPリクエスト/レスポンスのパースや生成のように、一度処理したらすぐに破棄されるJSONデータに最適です。
  • 大量の同種データ処理: ログ解析やデータ変換など、多くのJSONドキュメントを連続して処理する場合。
  • メモリプールが効果的な場面: プログラムのライフサイクル全体でメモリを再利用したい場合。

5.1.2 monotonic_resource を使ったパースとシリアライズの例

monotonic_resource を使用するには、まず適切なバッファを用意し、そのバッファを使って monotonic_resource オブジェクトを初期化します。そして、このリソースを boost::json::storage_ptr でラップして、boost::json::value のコンストラクタや boost::json::parse() に渡します。

“`cpp

include

include

include

include

int main() {
std::string json_data = R”({“name”: “Boost.JSON”, “version”: 1.76, “features”: [“fast”, “safe”]})”;

// 1. バッファの準備と monotonic_resource の作成
// 適度なサイズのバッファを用意。必要に応じて動的に拡張される。
std::vector<char> buffer(1024); // 1KBの初期バッファ
boost::json::monotonic_resource mr(buffer.data(), buffer.size());
boost::json::storage_ptr sp(&mr); // monotonic_resource を storage_ptr でラップ

// 2. パース時にアロケータを指定
// parsed_jv の全ての内部データ（文字列、オブジェクト、配列）はこのアロケータからメモリを確保
boost::json::value parsed_jv = boost::json::parse(json_data, sp);

// 3. パースされたデータの利用
std::cout << "Name: " << parsed_jv.at("name").as_string() << std::endl;
std::cout << "Version: " << parsed_jv.at("version").as_double() << std::endl;

// 4. 新しいJSONオブジェクトを作成する際にもアロケータを指定
boost::json::value new_jv(boost::json::object_kind, sp); // object_kind を指定し、アロケータを渡す
new_jv.at("status") = "success";
new_jv.at("data") = parsed_jv; // parsed_jv も同じアロケータを使用していれば、コピーではなく参照になる可能性がある（最適化）

// 5. シリアライズ
// シリアライズ自体は通常メモリ割り当てを必要としないが、
// 内部データがモノトニックリソースを使用しているため、メモリ効率が良い。
std::string serialized_data = boost::json::serialize(new_jv);
std::cout << "Serialized new JSON:\n" << serialized_data << std::endl;

// mr がスコープを抜けると、mr が確保した全てのメモリが一括解放される
// 明示的な解放は不要
return 0;

}
“`

5.1.3 グローバルなアロケータ設定

頻繁に monotonic_resource を使用する場合、デフォルトアロケータを一時的に変更することもできます。

“`cpp

include

include

include

include

int main() {
// 1. グローバルなデフォルトアロケータを変更するためのモノトニックリソース
std::vector global_buffer(2048); // より大きなバッファ
boost::json::monotonic_resource global_mr(global_buffer.data(), global_buffer.size());

// 既存のデフォルトアロケータを保存し、新しいアロケータを設定
boost::json::storage_ptr old_default_sp = boost::json::get_default_resource();
boost::json::set_default_resource(&global_mr);

// これ以降、明示的にアロケータを指定しない限り、
// boost::json::value, object, array, string は global_mr を使用する
{
    std::string json_input = R"({"item1": 10, "item2": "hello"})";
    boost::json::value v1 = boost::json::parse(json_input); // global_mr が使用される
    std::cout << "V1 item1: " << v1.at("item1").as_int64() << std::endl;

    boost::json::object obj2; // global_mr が使用される
    obj2["key"] = "value";
    std::cout << "Obj2: " << boost::json::serialize(obj2) << std::endl;
} // v1 と obj2 のメモリは global_mr から割り当てられており、global_mr のスコープが終了するまで解放されない

// 処理が終わったら、元のデフォルトアロケータに戻す（良い習慣）
boost::json::set_default_resource(old_default_sp);

// global_mr がスコープを抜けると、そこから割り当てられた全てのメモリが解放される
return 0;

}
``
**注意**:set_default_resourceはグローバルな状態を変更するため、マルチスレッド環境での使用には注意が必要です。スレッドローカルなアロケータが必要な場合は、各スレッドでstorage_ptrを明示的に渡すか、スレッドローカルなmonotonic_resource` を使用することを検討してください。

5.2 ストリーミングI/Oの活用 (parser, serializer)

boost::json::parse() と boost::json::serialize() は便利ですが、完全なJSON文字列がメモリ上に存在することを前提とします。非常に大きなJSONファイルを扱う場合や、ネットワークストリームからJSONを段階的に読み込む場合には、boost::json::parser と boost::json::serializer を使用したストリーミング処理がより効率的です。

5.2.1 boost::json::parser: ストリーミングパース

parser クラスは、JSONデータをチャンク（断片）ごとに受け取り、パースを進めることができます。これにより、メモリフットプリントを抑えながら、大規模なJSONファイルを処理できます。

“`cpp

include

include

include

include

include

int main() {
// 例として大きなJSONファイルを作成（実際はファイルから読み込む）
std::string large_json_data = “[“;
for (int i = 0; i < 1000; ++i) {
large_json_data += R”({“id”:)” + std::to_string(i) + R”(,”name”:”Item-)” + std::to_string(i) + R”(“})”;
if (i < 999) {
large_json_data += “,”;
}
}
large_json_data += “]”;

// ファイルに書き出す
std::ofstream ofs("large_data.json");
ofs << large_json_data;
ofs.close();

// 1. boost::json::parser オブジェクトを作成
boost::json::parser p;
boost::json::error_code ec;

// 2. ファイルをチャンクごとに読み込み、パーサーに渡す
std::ifstream ifs("large_data.json");
if (!ifs.is_open()) {
    std::cerr << "Failed to open file!" << std::endl;
    return 1;
}

std::vector<char> buffer(1024); // 1KBずつ読み込む
while (ifs.read(buffer.data(), buffer.size())) {
    p.write(buffer.data(), ifs.gcount(), ec);
    if (ec) {
        std::cerr << "Parser write error: " << ec.message() << std::endl;
        return 1;
    }
}
// 最後のチャンク（ファイルの残り）を処理
p.write(buffer.data(), ifs.gcount(), ec); // ifs.gcount() で実際に読み込んだバイト数を得る
if (ec) {
    std::cerr << "Parser final write error: " << ec.message() << std::endl;
    return 1;
}

// 3. パース完了を通知し、結果を取得
// release() を呼ぶことで、パースされた boost::json::value が返される
// これを忘れると、メモリリークや未定義動作の原因になる可能性がある
boost::json::value parsed_value = p.release(ec);
if (ec) {
    std::cerr << "Parser release error: " << ec.message() << std::endl;
    return 1;
}

// 4. パースされたデータの利用
if (parsed_value.is_array()) {
    std::cout << "Parsed " << parsed_value.as_array().size() << " items." << std::endl;
    // 例: 最初のアイテムの名前を出力
    if (!parsed_value.as_array().empty()) {
        std::cout << "First item name: " << parsed_value.as_array().at(0).at("name").as_string() << std::endl;
    }
}

return 0;

}
``p.write()は入力データを処理し、p.release()はパースが完了したvalueを返します。release()が呼ばれるまで、パースされたデータはparser` 内部のメモリリソースに保持されます。これにより、必要なメモリがパース中に徐々に割り当てられ、メモリ使用量のピークを抑えることができます。

5.2.2 boost::json::serializer: ストリーミングシリアライズ

serializer クラスは、boost::json::value を受け取り、指定された出力ストリームにチャンクごとに書き出します。

“`cpp

include

include

include

include

include // std::ostringstream for example

int main() {
// 1. シリアライズするJSONデータを作成
boost::json::value jv = boost::json::object();
jv.at(“timestamp”) = 1678886400;
jv.at(“message”) = “This is a long log message generated by Boost.JSON serializer example.”;
jv.at(“level”) = “INFO”;

boost::json::array data_array;
for (int i = 0; i < 5; ++i) {
    data_array.push_back(i * 10);
}
jv.at("data") = data_array;

// 2. boost::json::serializer オブジェクトを作成
boost::json::serializer s;
s.reset(jv); // シリアライズする boost::json::value を設定

// 3. 出力バッファと書き込みループ
std::string output_buffer_str;
output_buffer_str.reserve(1024); // ある程度の初期容量を確保
std::string_view chunk;

// シリアライザからチャンクを繰り返し取得し、バッファに追加
while (!s.done()) { // シリアライズが完了するまでループ
    chunk = s.prepare(100); // 100バイト程度のチャンクを準備（実際のサイズは異なる場合がある）
    output_buffer_str.append(chunk.data(), chunk.size());
    s.advance(chunk.size()); // 実際に処理したバイト数を通知
}

// 4. シリアライズされた結果を出力
std::cout << "Serialized JSON (chunked):\n" << output_buffer_str << std::endl;

return 0;

}
``s.reset(jv)でシリアライズ対象のvalueを設定し、s.prepare()で出力可能なチャンクを取得します。s.advance()` で、取得したチャンクを消費したことをシリアライザに通知します。このパターンは、ネットワークソケットやファイルストリームに直接書き出す場合に特に有用です。

5.3 ユーザー定義型とのバインディング (value_to, value_from)

Boost.JSON は、C++のカスタムクラスや構造体をJSONデータにシリアライズ・デシリアライズするための強力なメカニズムを提供します。これは、value_to および value_from 関数テンプレートを通じて実現されます。これにより、手動での型チェックやキャストが不要になり、コードの可読性と安全性が向上し、同時に効率的な型変換が実現されます。

5.3.1 ユーザー定義型の変換を実装する

value_to と value_from は、特定の命名規則に従ったフリー関数を定義することで、ユーザー定義型に対応させることができます。

例: 構造体 MyData をJSONと相互変換する

“`cpp

include

include

include

include

// 1. 変換したいユーザー定義型を定義
struct User {
int id;
std::string name;
std::vector roles;
bool isActive;
};

// 2. boost::json::value から User へ変換する value_to オーバーロードを定義
// namespace boost::json に配置することで、ADL (Argument-Dependent Lookup) により自動的に発見される
namespace boost::json {
// テンプレート引数 T は User型を指定、IsAValueTag は変換のメタデータ
template<>
void value_from(value_ref jv, User& user) {
// value_ref は const value& に相当し、jv はJSONデータへの参照
// jv がオブジェクトであることを確認
BOOST_ASSERT(jv.is_object());
object const& obj = jv.as_object();

    // 各フィールドを抽出し、型チェックを行う
    user.id = value_to<int>(obj.at("id"));
    user.name = value_to<std::string>(obj.at("name"));
    user.roles = value_to<std::vector<std::string>>(obj.at("roles"));
    user.isActive = value_to<bool>(obj.at("isActive"));
}

// 3. User から boost::json::value へ変換する value_from オーバーロードを定義
// ここで as_value() を使うと、コンパイラは無限再帰に陥る可能性があるため、
// value_from と value_to は相互に呼び出すのではなく、
// 基本型への変換を利用するか、boost::json::object/array/value_ref を直接構築する。
// 正しいのは、value_from は value_ref に変換し、value_to は T に変換する。
// ここでは、value_to を使用して object を構築する。
// 正しいオーバーロードは boost::json::value を返すようにする。
// （注：Boost.JSONのバージョンによってはvalue_fromがvalue_refを取るものとvalueを返すものがあるため注意）
// 通常のケースでは、`value_from` は `value_ref` を取り、既存の `value` オブジェクトを埋める。
// こちらは、`value_to` を利用して変換する例。
// `value_from(value_ref jv, T& t)` の対として `value_to(T const& t)` を定義するのが自然。

// 以下は古いBoost.JSONバージョンや、value_fromの一般的な用法ではないが、
// 説明のために概念的に value_to<User> の内部で使われるだろうという形を記述。
// 正しいのは、Boost.JSON が推奨する Tagged Value Conversion。

// Boost.JSON 1.76以降での推奨される形 (Tagged Value Conversion)
// まず、ユーザー定義型を JSON の value に変換するヘルパー関数を定義
void tag_invoke(value_from_tag, value& jv, User const& user) {
    // jv は output value。ここでは object として構築する。
    jv = object{
        {"id", user.id},
        {"name", user.name},
        {"roles", user.roles}, // std::vector<std::string> は自動的に array に変換される
        {"isActive", user.isActive}
    };
}

} // namespace boost::json

int main() {
// ユーザー定義型からJSONへ (value_to の利用)
User user1 = {1, “Alice”, {“admin”, “developer”}, true};
// boost::json::value_from は User から value を生成するのに使う
boost::json::value json_user = boost::json::value_from(user1);
std::cout << “User to JSON:\n” << boost::json::serialize(json_user, {boost::json::serialize_options::pretty}) << std::endl;

// JSONからユーザー定義型へ (value_from の利用)
std::string json_input = R"({
    "id": 2,
    "name": "Bob",
    "roles": ["guest"],
    "isActive": false
})";

boost::json::error_code ec;
boost::json::value parsed_json = boost::json::parse(json_input, ec);
if (ec) {
    std::cerr << "Parse error: " << ec.message() << std::endl;
    return 1;
}

User user2;
// boost::json::value_to は value から User を生成するのに使う
try {
    user2 = boost::json::value_to<User>(parsed_json);
    std::cout << "\nJSON to User:\n";
    std::cout << "ID: " << user2.id << std::endl;
    std::cout << "Name: " << user2.name << std::endl;
    std::cout << "Roles: ";
    for (const auto& role : user2.roles) {
        std::cout << role << " ";
    }
    std::cout << std::endl;
    std::cout << "Is Active: " << (user2.isActive ? "true" : "false") << std::endl;
} catch (const boost::system::system_error& e) {
    std::cerr << "Conversion error: " << e.what() << std::endl;
}

return 0;

}
``
**解説**:
*boost::json::value_from_tagを引数に取るtag_invoke関数は、C++20のstd::invocableにインスパイアされた「タグディスパッチ」メカニズムの一部です。これにより、グローバル名前空間を汚染することなく、Boost.JSONの変換システムにカスタム型をフックできます。
*value_from_tagオーバーロードは、ユーザー定義型Userを受け取り、boost::json::value型の参照jvを変更してJSONオブジェクトを構築します。
* このシステムを使うと、std::vectorのような標準コンテナやプリミティブ型は、Boost.JSONが提供する既存のvalue_to/value_from` オーバーロードによって自動的に処理されます。

これにより、JSONのパース結果をC++の強力な型システムにマッピングし、より安全で保守性の高いコードを書くことができます。手動でのキーアクセスや型キャストが不要になるため、バグの温床を減らし、コードの意図を明確にできます。このバインディングは、特にREST APIクライアントやサーバーサイドアプリケーションで頻繁に利用されます。

6. 安全なJSON処理のための考慮事項

Boost.JSON は、堅牢なエラーハンドリング、メモリ安全性、そして入力データの検証メカニズムを提供することで、安全なJSON処理をサポートします。ここでは、これらの機能を活用して、より信頼性の高いアプリケーションを構築する方法を探ります。

6.1 堅牢なエラーハンドリング

Boost.JSON は、エラーを報告するために boost::system::error_code と例外の両方を提供します。どちらを使用するかは、アプリケーションの設計とエラー処理ポリシーに依存します。

6.1.1 boost::system::error_code によるエラー処理

error_code を使用するオーバーロードは、エラーが発生した場合に例外をスローせず、error_code オブジェクトにエラー情報を格納します。これは、例外を使用できない、または使用したくない環境（例: 特定の組込みシステム、ゼロオーバーヘッドが要求される高性能コードパス）で特に有用です。

例: parse() でのエラーコードの使用

“`cpp

include

include

include

int main() {
std::string malformed_json = “{ \”key\”: \”value\”, \”bad\”: ] }”; // 不正なJSON
boost::json::error_code ec;

// parse() の error_code オーバーロードを使用
boost::json::value parsed_value = boost::json::parse(malformed_json, ec);

if (ec) {
    // エラーが発生した場合
    std::cerr << "JSON Parse Error (" << ec.category().name() << "): "
              << ec.message() << " (Code: " << ec.value() << ")" << std::endl;
    // エラーの種類に応じた追加の処理
    if (ec == boost::json::error::syntax_error) {
        std::cerr << "  This is a syntax error." << std::endl;
    }
    return 1;
}

// パース成功時の処理
std::cout << "JSON Parsed Successfully: " << parsed_value << std::endl;
return 0;

}
“`

6.1.2 例外ベースのエラー処理

デフォルトでは、多くの Boost.JSON 関数（例: parse() の一部のオーバーロード、value::at(), value::as_X()）は、エラー時に boost::system::system_error 例外をスローします。これは、C++標準ライブラリの例外処理パターンに従っており、エラー処理をビジネスロジックから分離しやすくなります。

例: at() と as_string() での例外キャッチ

“`cpp

include

include

include

int main() {
std::string json_data = R”({“name”: “Alice”, “age”: 30})”;
boost::json::value jv = boost::json::parse(json_data);

try {
    // 存在しないキーへのアクセス
    std::cout << jv.at("email").as_string() << std::endl;
} catch (const boost::system::system_error& e) {
    std::cerr << "Error accessing 'email': " << e.what() << std::endl;
    // boost.json: key not found
}

try {
    // 型変換エラー (ageは数値なのに文字列としてアクセスしようとする)
    std::cout << jv.at("age").as_string() << std::endl;
} catch (const boost::system::system_error& e) {
    std::cerr << "Error converting 'age' to string: " << e.what() << std::endl;
    // boost.json: bad_cast
}

// 安全なアクセス方法 (contains() と is_X() で事前チェック)
if (jv.is_object() && jv.as_object().contains("name") && jv.as_object().at("name").is_string()) {
    std::cout << "Name (safely accessed): " << jv.at("name").as_string() << std::endl;
} else {
    std::cout << "Name field not found or not a string." << std::endl;
}

return 0;

}
“`

開発者は、プロジェクトの要件に応じて、error_code と例外のどちらか、または両方を組み合わせた戦略を選択できます。一般的に、回復可能なエラーや頻繁に発生する可能性のあるエラーには error_code が適しており、プログラムの実行を継続できないような致命的なエラーには例外が適しています。

6.2 入力データの検証とサニタイズ

Boost.JSON はJSONをパースする機能を提供しますが、パースされたJSONデータの内容がアプリケーションの期待する形式や値であるかを検証する機能は提供しません（JSONスキーマ検証など）。しかし、悪意のある、あるいは単に不正なJSON入力からアプリケーションを保護するための機能は提供します。

6.2.1 parser_options の利用

boost::json::parser_options を使用すると、パース時の制約を設定し、悪意のある入力によって発生する可能性のあるリソース枯渇攻撃（DoS攻撃）などからシステムを保護できます。

• max_depth: JSONのネストの最大深さを制限します。非常に深くネストされたJSONは、スタックオーバーフローや処理時間の増大を引き起こす可能性があります。
• max_string_length: JSON文字列の最大長を制限します。非常に長い文字列はメモリ消費を増大させ、攻撃に利用される可能性があります。
• max_members: JSONオブジェクトのメンバー数や配列の要素数の最大値を制限します。
• allow_comments: コメント (// や /* */) を許可するかどうかを指定します。通常は無効です。
• allow_trailing_commas: 末尾のカンマを許可するかどうかを指定します。通常は無効です。

例: 厳格なパースオプションの設定

“`cpp

include

include

include

int main() {
std::string valid_json = R”({“a”: 1, “b”: {“c”: 2}})”;
std::string deeply_nested_json = R”({“a”:{“b”:{“c”:{“d”:{“e”:{“f”:1}}}}}})”; // 6 deep
std::string long_string_json = R”({“data”: “)” + std::string(2000, ‘X’) + R”(“})”; // 2000 chars

boost::json::parser_options opt;
opt.max_depth = 5;         // ネストの最大深度を5に制限
opt.max_string_length = 1024; // 文字列の最大長を1KBに制限
opt.allow_comments = false;
opt.allow_trailing_commas = false;

boost::json::error_code ec;

// 有効なJSON
boost::json::parse(valid_json, ec, opt);
if (ec) {
    std::cerr << "Valid JSON Error (should not happen): " << ec.message() << std::endl;
} else {
    std::cout << "Valid JSON parsed successfully." << std::endl;
}

// 深くネストされたJSON
boost::json::parse(deeply_nested_json, ec, opt);
if (ec) {
    std::cerr << "Deeply nested JSON Error: " << ec.message() << std::endl; // depth_too_large
}

// 長い文字列のJSON
boost::json::parse(long_string_json, ec, opt);
if (ec) {
    std::cerr << "Long string JSON Error: " << ec.message() << std::endl; // string_too_long
}

return 0;

}
“`

これらのオプションを適切に設定することで、予期せぬ、あるいは悪意のある入力からアプリケーションを保護し、リソース消費を制限できます。

6.2.2 JSONスキーマ検証の外部ライブラリとの連携

Boost.JSON 自体はJSONスキーマ検証機能を提供しません。JSONスキーマは、JSONデータの構造とコンテンツを記述するための仕様であり、データの有効性を検証するために使用されます。アプリケーションが特定のスキーマに準拠したJSONデータを必要とする場合、Boost.JSON でパースした後、別のC++ JSONスキーマ検証ライブラリ（例: json-schema-validator）を組み合わせて使用することを検討してください。

6.3 メモリ安全性

Boost.JSON はC++で書かれているため、基本的なメモリ安全性はC++の標準とBoostライブラリの堅牢な設計に依存します。

• RAII (Resource Acquisition Is Initialization): Boost.JSON のデータ型（value, object, array など）は、RAII原則に従って設計されており、オブジェクトがスコープを離れるときに、関連するメモリが自動的に解放されます。これにより、手動での delete や free の呼び出しを避け、メモリリークのリスクを大幅に軽減します。
• アロケータによる管理: 前述の monotonic_resource を含むアロケータは、メモリの割り当てと解放を抽象化し、メモリフラグメンテーションの抑制や、一括解放によるパフォーマンス向上に寄与します。適切にアロケータを使用することで、メモリリークや二重解放といった一般的なC++のメモリ関連エラーを防ぐことができます。
• 不変性: const 正しさを活用し、読み取り専用のJSONデータに対して変更を加えないようにすることで、意図しないデータ破壊を防ぐことができます。

6.4 スレッドセーフティ

Boost.JSON のコンテナクラス（value, object, array など）は、std::map や std::vector と同様に、スレッドセーフではありません。つまり、複数のスレッドから同時に同じ Boost.JSON オブジェクトを読み書きすると、データ競合や未定義動作が発生する可能性があります。

スレッド間で Boost.JSON オブジェクトを共有する必要がある場合は、以下の標準的なC++並行処理のメカニズムを使用して同期を確保する必要があります。

• ミューテックス (std::mutex): オブジェクトへのアクセスを排他的に保護します。
• 読み書きロック (std::shared_mutex): 読み取り操作が多数ある場合に、複数の読み取りを許可しつつ、書き込み操作を排他的に保護します。
• スレッドローカルストレージ: 各スレッドが自身の Boost.JSON オブジェクトのコピーを保持し、共有を避けます。
• メッセージキュー: JSONデータをシリアライズしてメッセージとして渡し、受信側でデシリアライズすることで、直接的なオブジェクト共有を避けます。

例: ミューテックスによる保護 (概念)

“`cpp

include

include

include

include

include

boost::json::value shared_config;
std::mutex config_mutex;

void update_config(const std::string& new_json) {
std::lock_guard lock(config_mutex);
try {
shared_config = boost::json::parse(new_json);
std::cout << “Config updated by thread ” << std::this_thread::get_id() << std::endl;
} catch (const boost::system::system_error& e) {
std::cerr << “Config update error: ” << e.what() << std::endl;
}
}

void read_config() {
std::lock_guard lock(config_mutex);
if (shared_config.is_object() && shared_config.as_object().contains(“version”)) {
std::cout << “Thread ” << std::this_thread::get_id()
<< ” reads config version: ” << shared_config.at(“version”).as_int64() << std::endl;
}
}

int main() {
// 初期設定
update_config(R”({“version”: 1, “setting”: “default”})”);

// 複数のスレッドを起動して読み書きをシミュレート
std::thread t1(read_config);
std::thread t2(update_config, R"({"version": 2, "setting": "new"})");
std::thread t3(read_config);

t1.join();
t2.join();
t3.join();

std::cout << "Final config:\n" << boost::json::serialize(shared_config, {boost::json::serialize_options::pretty}) << std::endl;

return 0;

}
``Boost.JSONの内部アロケータ（特にmonotonic_resource`）は、通常は呼び出し元のスレッドのコンテキストで管理されるため、それ自体が直接的なスレッドセーフティの問題を引き起こすことは稀ですが、グローバルなデフォルトアロケータを変更する場合は、上記のように同期を考慮する必要があります。

これらの安全対策を講じることで、Boost.JSON を利用したアプリケーションは、高速性だけでなく、高い信頼性と堅牢性を備えることができます。

7. 実践的な使用例と高度なトピック

このセクションでは、Boost.JSON が実世界のアプリケーションでどのように活用されるか、いくつかの実践的な使用例と高度なトピックを紹介します。

7.1 REST APIとの連携

今日の多くのWebサービスは、RESTful APIを通じてJSON形式でデータをやり取りします。Boost.JSON は、HTTPリクエストのボディをパースしたり、HTTPレスポンスのボディを生成したりするのに理想的です。特に、Boostエコシステム内の他のライブラリ、例えば非同期I/Oを提供する Boost.Asio や、HTTP/WebSocket通信を扱う Boost.Beast と組み合わせることで、堅牢で高性能なネットワークアプリケーションを構築できます。

概念的なワークフロー:

1. リクエストの受信: Boost.Beast を使用してHTTPリクエストを受信。
2. JSONボディのパース: リクエストボディ（std::string や boost::beast::flat_buffer など）からJSON文字列を抽出。
   • boost::json::parse() を使用して、ボディ全体を一括でパース。
   • 大規模なボディの場合は、boost::json::parser を使用してチャンクごとにパースし、メモリフットプリントを最適化。
3. データ処理: パースされた boost::json::value から必要なデータを抽出し、C++のビジネスロジックで処理。この際、value_to を使ってユーザー定義型に変換すると、コードがより読みやすく安全になります。
4. レスポンスの生成: 処理結果を元に、C++データ（例: 構造体）を boost::json::value に変換（value_from を使用）。
5. JSONボディのシリアライズ: boost::json::serialize() を使用して boost::json::value をJSON文字列に変換。
   • 整形された出力が必要な場合は serialize_options::pretty を使用（デバッグやログ向け）。
   • 本番環境では、スペースを削減するために通常のシリアライズを使用。
6. レスポンスの送信: Boost.Beast を使用してHTTPレスポンスをクライアントに送信。

例 (擬似コード):

“`cpp
// Boost.Beast のハンドラ内で呼ばれることを想定
void handle_api_request(const std::string& request_body) {
try {
// 1. リクエストボディのJSONをパース
// モノトニックアロケータを使って、一時的なメモリ効率を最適化
std::vector buffer(2048);
boost::json::monotonic_resource mr(buffer.data(), buffer.size());
boost::json::storage_ptr sp(&mr);

    boost::json::value request_json = boost::json::parse(request_body, sp);

    // 2. ユーザー定義型への変換 (value_to を使用)
    // struct OrderRequest { std::string itemId; int quantity; };
    // boost::json::value_to<OrderRequest> が定義されている前提
    OrderRequest order_req = boost::json::value_to<OrderRequest>(request_json);

    // 3. ビジネスロジック処理
    OrderResponse order_resp = process_order(order_req); // 実際の処理

    // 4. レスポンスJSONの生成 (value_from を使用)
    boost::json::value response_json = boost::json::value_from(order_resp, sp); // 同じアロケータを使用

    // 5. JSONを文字列にシリアライズ
    std::string response_body = boost::json::serialize(response_json);

    // 6. HTTPレスポンスとして送信 (Boost.Beast::http::response を使用)
    // ... (response_body をレスポンスに設定して送信)
    std::cout << "Processed request and sent response." << std::endl;

} catch (const boost::system::system_error& e) {
    std::cerr << "API Error: " << e.what() << std::endl;
    // ... エラーレスポンスを生成して送信
} catch (const std::exception& e) {
    std::cerr << "Unexpected API Error: " << e.what() << std::endl;
    // ... 汎用エラーレスポンスを生成して送信
}

}
“`

7.2 設定ファイルの読み込み

JSONは、アプリケーションの設定ファイルを記述するのにも非常に適しています。Boost.JSON を使用することで、複雑な階層構造を持つ設定ファイルを簡単に読み込み、C++のデータ構造にマッピングできます。

“`cpp

include

include

include

include

include

// 設定構造体
struct DatabaseConfig {
std::string host;
int port;
std::string user;
std::string password;
std::string database;
};

struct ApplicationConfig {
int logLevel;
std::string appName;
DatabaseConfig dbConfig;
std::map features; // 可変な機能フラグ
};

// Boost.JSON への変換ヘルパー (前述の value_from_tag を使用)
namespace boost::json {
void tag_invoke(value_from_tag, value& jv, DatabaseConfig const& config) {
jv = object{
{“host”, config.host},
{“port”, config.port},
{“user”, config.user},
{“password”, config.password},
{“database”, config.database}
};
}

void tag_invoke(value_from_tag, value& jv, ApplicationConfig const& config) {
    jv = object{
        {"logLevel", config.logLevel},
        {"appName", config.appName},
        {"dbConfig", config.dbConfig}, // 再帰的に変換される
        {"features", config.features} // std::map も自動変換
    };
}

void value_from(value_ref jv, DatabaseConfig& config) {
    object const& obj = jv.as_object();
    config.host = value_to<std::string>(obj.at("host"));
    config.port = value_to<int>(obj.at("port"));
    config.user = value_to<std::string>(obj.at("user"));
    config.password = value_to<std::string>(obj.at("password"));
    config.database = value_to<std::string>(obj.at("database"));
}

void value_from(value_ref jv, ApplicationConfig& config) {
    object const& obj = jv.as_object();
    config.logLevel = value_to<int>(obj.at("logLevel"));
    config.appName = value_to<std::string>(obj.at("appName"));
    config.dbConfig = value_to<DatabaseConfig>(obj.at("dbConfig"));
    config.features = value_to<std::map<std::string, std::string>>(obj.at("features"));
}

} // namespace boost::json

int main() {
// 設定ファイルの内容 (config.json に保存されていると仮定)
std::string config_json_content = R”({
“logLevel”: 3,
“appName”: “MyAwesomeApp”,
“dbConfig”: {
“host”: “localhost”,
“port”: 5432,
“user”: “appuser”,
“password”: “password123”,
“database”: “myapp_db”
},
“features”: {
“enableTelemetry”: “true”,
“darkTheme”: “false”
}
})”;

try {
    // 1. JSON文字列をパース
    boost::json::value jv = boost::json::parse(config_json_content);

    // 2. ユーザー定義のApplicationConfig構造体に変換
    ApplicationConfig app_config = boost::json::value_to<ApplicationConfig>(jv);

    // 3. 設定値の利用
    std::cout << "Application Name: " << app_config.appName << std::endl;
    std::cout << "Log Level: " << app_config.logLevel << std::endl;
    std::cout << "DB Host: " << app_config.dbConfig.host << std::endl;
    std::cout << "DB Port: " << app_config.dbConfig.port << std::endl;
    std::cout << "Feature 'enableTelemetry': " << app_config.features["enableTelemetry"] << std::endl;

    // 例: 存在しない設定項目にアクセスする場合のデフォルト値設定
    std::string missing_feature = "unknownFeature";
    if (app_config.features.count(missing_feature)) {
        std::cout << missing_feature << ": " << app_config.features[missing_feature] << std::endl;
    } else {
        std::cout << missing_feature << ": Defaulting to 'false'" << std::endl;
    }

} catch (const boost::system::system_error& e) {
    std::cerr << "Error reading config: " << e.what() << std::endl;
}

return 0;

}
``
この例では、value_toとvalue_from` オーバーロードを適切に定義することで、JSONとC++構造体間の複雑なマッピングを自動化できることを示しています。これにより、設定ファイルの読み込みが容易になり、型安全性が保証されます。

7.3 ロギングとデバッグ

構造化ログは、ログデータを機械が解析しやすいJSON形式で出力する手法です。これにより、ログの集計、分析、検索が格段に容易になります。Boost.JSON は、この構造化ログの生成に非常に適しています。

“`cpp

include

include

include

include

// シンプルなロギング関数
void log_event(const std::string& level, const std::string& message, boost::json::value_ref data = {}) {
boost::json::object log_entry;

// タイムスタンプを追加
auto now = std::chrono::system_clock::now();
auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
log_entry["timestamp_ms"] = timestamp;

log_entry["level"] = level;
log_entry["message"] = message;

if (!data.is_null()) {
    // 追加のデータがあれば、オブジェクトとしてマージ
    // data が object でなければ、"data" フィールドにそのまま追加
    if (data.is_object()) {
        for (auto const& element : data.as_object()) {
            log_entry[element.key()] = element.value();
        }
    } else {
        log_entry["context_data"] = data; // ログエントリのトップレベルに直接マージできない場合
    }
}

// JSON形式で出力 (整形なしで1行で出力されるのが一般的)
std::cout << boost::json::serialize(log_entry) << std::endl;

}

int main() {
// 通常のログ
log_event(“INFO”, “Application started successfully.”);

// エラーログ (追加データ付き)
boost::json::object error_context;
error_context["errorCode"] = 500;
error_context["endpoint"] = "/api/v1/users";
error_context["userId"] = 123;
log_event("ERROR", "Failed to process user request.", error_context);

// デバッグ時の中間データ出力
boost::json::value debug_data = boost::json::object{
    {"intermediateResult", 42.5},
    {"status", "processing"},
    {"subTasks", boost::json::array{"taskA", "taskB"}}
};
// デバッグ時は見やすいように整形して出力
std::cout << "DEBUG: Intermediate Data:\n" 
          << boost::json::serialize(debug_data, {boost::json::serialize_options::pretty}) 
          << std::endl;

return 0;

}
``boost::json::serialize()のserialize_options::pretty` を使用することで、開発者はデバッグ時に視認性の高い整形されたJSON出力を得ることもできます。

7.4 パフォーマンスベンチマーク (簡易版)

Boost.JSON はそのパフォーマンスを売りにしていますが、実際のアプリケーションでその恩恵を最大化するには、ボトルネックを特定し、適切な最適化を適用することが重要です。ここでは、簡単なベンチマークの概念と、Boost.JSON が特に強みを発揮するケースについて説明します。

ベンチマークのポイント:

• 入力データのサイズと構造:
  • 非常に大きな単一のJSONドキュメント（MB単位）。
  • 多数の小さなJSONドキュメント（KB単位）。
  • 深いネスト、非常に長い文字列、多数のキー/要素など、JSON構造の複雑さ。
• メモリ割り当て戦略: デフォルトのアロケータと monotonic_resource の比較。
• 処理の種類: パース、シリアライズ、DOM操作（要素の追加/削除/変更）。

簡易測定例:

“`cpp

include

include

include

include

include

// ベンチマークヘルパー関数
void benchmark_parse(const std::string& json_str, int iterations) {
auto start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < iterations; ++i) {
boost::json::value jv = boost::json::parse(json_str);
// パース結果を実際に使うことで、コンパイラの最適化を防ぐ
if (!jv.is_object()) {
std::cerr << “Error: Not an object!” << std::endl;
break;
}
(void)jv.as_object().size(); // 使用しないと最適化で消える可能性
}
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration duration = end – start;
std::cout << “Parse ” << iterations << ” times: ” << duration.count() << ” ms” << std::endl;
}

void benchmark_parse_monotonic(const std::string& json_str, int iterations) {
auto start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < iterations; ++i) {
// 毎回新しいモノトニックリソースを作成・破棄
std::vector buffer(json_str.size() * 2); // 必要に応じてサイズを調整
boost::json::monotonic_resource mr(buffer.data(), buffer.size());
boost::json::storage_ptr sp(&mr);

    boost::json::value jv = boost::json::parse(json_str, sp);
    if (!jv.is_object()) {
        std::cerr << "Error: Not an object!" << std::endl;
        break;
    }
    (void)jv.as_object().size();
}
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double, std::milli> duration = end - start;
std::cout << "Parse " << iterations << " times (Monotonic): " << duration.count() << " ms" << std::endl;

}

int main() {
std::string large_json = “{“;
for (int i = 0; i < 1000; ++i) {
large_json += “\”key” + std::to_string(i) + “\”:” + std::to_string(i);
if (i < 999) large_json += “,”;
}
large_json += “}”;

int iterations = 10000; // 繰り返し回数

std::cout << "Benchmarking JSON size: " << large_json.length() << " bytes" << std::endl;

benchmark_parse(large_json, iterations);
benchmark_parse_monotonic(large_json, iterations);

return 0;

}
``
**Boost.JSON` の強み:**

• 大量の小規模JSONドキュメントの処理: monotonic_resource が真価を発揮し、個別のメモリ割り当てのオーバーヘッドを大幅に削減します。
• 安定したパフォーマンス: メモリフラグメンテーションが少ないため、長時間稼働するサーバーアプリケーションで性能劣化しにくいです。
• 厳格な入力に対する堅牢性: パースオプションや型チェックにより、不正なJSONに対する安全性が高まります。

実際のシステムでは、プロファイリングツール（Valgrind, perf, Intel VTuneなど）を使用して、CPU使用率、メモリ使用量、キャッシュミスなどを詳細に分析することが不可欠です。

7.5 Boost.JSONの拡張性

Boost.JSON はそのコア機能に加えて、カスタムの型変換（value_to/value_from）をサポートすることで、様々なデータ型をJSONにマッピングする柔軟性を提供します。
例えば、std::chrono::time_point や独自の列挙型、幾何学的な点 (Point {x, y}) など、標準ではサポートされていない型をJSONと相互変換するオーバーロードを定義できます。

例: std::chrono::time_point とJSON文字列の変換

“`cpp

include

include

include

include

include // For std::put_time

// std::chrono::system_clock::time_point と JSON 文字列 (ISO 8601) の変換
namespace boost::json {
// time_point から value へ
void tag_invoke(value_from_tag, value& jv, std::chrono::system_clock::time_point const& tp) {
std::time_t tt = std::chrono::system_clock::to_time_t(tp);
std::tm tm = *std::gmtime(&tt); // UTC時間
std::ostringstream oss;
oss << std::put_time(&tm, “%Y-%m-%dT%H:%M:%SZ”); // ISO 8601 フォーマット
jv = oss.str();
}

// value から time_point へ
void value_from(value_ref jv, std::chrono::system_clock::time_point& tp) {
    std::string s = value_to<std::string>(jv);
    std::tm tm = {};
    std::istringstream iss(s);
    iss >> std::get_time(&tm, "%Y-%m-%dT%H:%M:%SZ");
    if (iss.fail()) {
        BOOST_THROW_EXCEPTION(system_error(error::invalid_argument));
    }
    tp = std::chrono::system_clock::from_time_t(std::mktime(&tm)); // mktimeはローカル時間なので注意
    // UTCからの変換には、gmtimeとtimegm (GNU拡張) または Boost.DateTime を使うのがより安全
    // 簡単化のため、ここでは std::mktime を使用
}

} // namespace boost::json

int main() {
using namespace std::chrono;

// 現在時刻をJSONに変換
system_clock::time_point now = system_clock::now();
boost::json::value json_time = boost::json::value_from(now);
std::cout << "Current time in JSON: " << json_time << std::endl;

// JSON文字列から時刻に変換
std::string time_str_json = "\"2023-10-27T10:30:00Z\"";
boost::json::value parsed_time_jv = boost::json::parse(time_str_json);
system_clock::time_point parsed_time = boost::json::value_to<system_clock::time_point>(parsed_time_jv);

// 変換された時刻を出力
std::time_t parsed_tt = system_clock::to_time_t(parsed_time);
std::cout << "Parsed time: " << std::asctime(std::gmtime(&parsed_tt)); // UTCで出力

return 0;

}
``
このように、Boost.JSON` の拡張ポイントを利用することで、特定のデータ型をシームレスにJSONと相互変換し、アプリケーションのドメインモデルとJSONデータの間のギャップを埋めることができます。

8. よくある質問 (FAQ) とトラブルシューティング

Boost.JSON を利用する際に遭遇しがちな問題とその解決策について説明します。

8.1 コンパイルエラー

Q1: Boost.JSON ヘッダーが見つからない、またはライブラリがリンクされない。

A:
* ヘッダーパス: CMakeLists.txt で find_package(Boost REQUIRED COMPONENTS json) が正しく設定されているか確認してください。もし手動でインクルードパスを設定しているなら、#include <boost/json.hpp> が見つかるようにパスが通っていることを確認してください。
* ライブラリリンク: target_link_libraries(my_app PRIVATE Boost::json) が存在するか確認してください。Boostは多くのモジュールを持っており、必要なものだけをリンクする必要があります。
* vcpkg/Conan: パッケージマネージャーを使用している場合、vcpkg integrate install または conan install が正しく実行され、CMakeがツールチェーンファイルを認識しているか確認してください。

Q2: error: reference to 'value_to' is ambiguous または error: call to 'value_from' is ambiguous

A:
* これは、同じ名前の関数が複数存在し、コンパイラがどちらを呼び出すべきか判断できない場合に発生します。
* 特に、カスタムの value_to/value_from オーバーロードを定義した場合に起こりやすいです。
* 解決策: カスタム変換関数は、namespace boost::json 内に定義し、value_from_tag を使用する tag_invoke 形式を使用することを強く推奨します。これにより、ADL (Argument-Dependent Lookup) が正しく機能し、Ambiguityを避けることができます。既存の std::string などへの変換と衝突しないようにしてください。

8.2 ランタイムエラー

Q3: boost::system::system_error (例: bad_cast, key not found) がスローされる。

A:
* bad_cast: value::as_object(), value::as_string(), value_to<T>() などの型キャストメソッドを呼び出した際に、value が保持している実際の型が期待する型と異なる場合に発生します。
* 解決策: 値にアクセスする前に value::is_object(), value::is_string() などの型判別メソッドで型をチェックしてください。また、value_to を使用する際は、入力JSONの構造とC++の型が一致していることを確認してください。
* key not found: boost::json::object::at("key_name") を呼び出した際に、指定されたキーがオブジェクトに存在しない場合に発生します。
* 解決策: 値にアクセスする前に boost::json::object::contains("key_name") でキーの存在をチェックしてください。または、デフォルト値を提供できる場合は object::operator[] を検討してください（ただし、これはキーが存在しない場合に新しい要素を挿入します）。

Q4: メモリリークやパフォーマンスが期待よりも低い。

A:
* メモリリーク: Boost.JSON はRAIIを重視しているため、通常は明示的なメモリリークは発生しにくいです。もしメモリリークが疑われる場合は、以下の点を確認してください。
* boost::json::parser::release() を呼び出しているか？ parser は、結果が release() されるまで内部にメモリを保持します。
* boost::json::monotonic_resource を使用している場合、その寿命が適切に管理されているか？ monotonic_resource がスコープを離れると、割り当てられたメモリは一括解放されます。もし monotonic_resource がグローバルに設定されており、適切にリセットされていない場合、メモリが蓄積される可能性があります。
* パフォーマンス:
* アロケータ: monotonic_resource を使っていますか？ 大量のJSONを処理する場合、デフォルトのアロケータ（std::allocator ベース）は頻繁なメモリ割り当て/解放によるオーバーヘッドが大きくなります。monotonic_resource の適切なサイズ見積もり（json_str.size() * 1.5 などから始める）と再利用を検討してください。
* I/O: boost::json::parser および boost::json::serializer をストリーミングI/Oに使用していますか？ 巨大なJSONを一度にメモリに読み込む parse() は、メモリ使用量が大きくなり、遅延の原因になります。
* 不必要なコピー: boost::json::string と std::string の間で頻繁な変換を行っていませんか？ boost::json::string はJSON内部で最適化されています。

8.3 std::string と boost::json::string の変換オーバーヘッド

boost::json::string は std::string とは異なる型であり、変換にはオーバーヘッドが伴います。

• boost::json::string から std::string への変換: 通常はコピーが発生します。パフォーマンスが重要な場面では、string_view を使用して読み取り専用アクセスを行うことを検討してください（例: boost::json::value::as_string().data() と boost::json::value::as_string().size() を組み合わせて std::string_view を構築）。
• std::string から boost::json::string への変換: 同様にコピーが発生します。parse() の入力としては std::string_view や const char* を受け付けるため、不必要な std::string の生成を避けることができます。

できる限り boost::json::string 型を直接使用し、必要な場合のみ std::string との変換を行うように心がけてください。

8.4 monotonic_resource の適切なサイズ見積もり

monotonic_resource は初期バッファサイズが必要です。このサイズが小さすぎると、内部でより大きなバッファが再割り当てされることでパフォーマンスが低下する可能性があります。逆に大きすぎると、不必要なメモリ消費につながります。

• 見積もり方法:
  • 入力JSON文字列のサイズ (input_string.size()) の1.5倍から2倍程度を初期値として試すのが一般的です。これは、JSONのパース中に文字列以外のデータ構造（オブジェクト、配列、数値など）のメモリも必要となるためです。
  • 実際のアプリケーションでプロファイリングを行い、ピークメモリ使用量を監視して、最適なサイズを見つけるのが最も確実な方法です。
  • monotonic_resource はバッファが不足しても自動的に新しいバッファを割り当ててくれるため、厳密なサイズ指定ができなくても動作は保証されますが、パフォーマンスに影響します。

8.5 C++標準との互換性

Boost.JSON はC++11以降の標準に準拠していますが、最新の機能（例: C++17の std::string_view や C++20の std::span）を活用することで、より効率的なコードを書くことができます。Boostライブラリは通常、様々なC++標準バージョンで動作するように設計されているため、特定のC++標準に固執することなく、最新のコンパイラと標準機能を利用することが推奨されます。

9. まとめと今後の展望

本記事では、C++でのJSON処理における Boost.JSON の重要性、その高速性、安全性、そして使いやすさに焦点を当てて詳しく解説しました。Boost.JSON は、以下のような主要なメリットを提供します。

• 高速性: monotonic_resource をはじめとする先進的なメモリ管理戦略と、ストリーミングI/Oのための parser/serializer により、競合ライブラリと比較してもトップクラスのパフォーマンスを発揮します。
• 安全性: 厳格な型チェック、堅牢なエラーハンドリング（error_code と例外の両方）、そして parser_options による入力検証により、予期せぬ入力や攻撃からアプリケーションを保護します。RAIIとアロケータの利用により、メモリ安全性も確保されます。
• 柔軟性: boost::json::value のポリモーフィックな性質、object や array の直感的なAPI、そして value_to/value_from を通じたユーザー定義型とのシームレスなバインディングにより、複雑なJSONデータ構造も容易に扱えます。
• Boostエコシステムとの統合: Boost.Asio, Boost.Beast など、他のBoostライブラリとの連携が容易であり、堅牢なネットワークアプリケーションやシステムを構築する際の強力な基盤となります。

C++エコシステムにおけるJSON処理は、日々進化しています。Boost.JSON は、その中でもパフォーマンスと安全性のバランスが取れた、非常に優れた選択肢です。特に、大規模なデータ処理、低レイテンシが求められるサービス、あるいは組み込みシステムなど、リソース制約が厳しい環境でその真価を発揮するでしょう。

本記事が、Boost.JSON を導入し、C++アプリケーションでのJSON処理を次のレベルへと引き上げるための一助となれば幸いです。JSONは現代のソフトウェアの不可欠な要素であり、Boost.JSON を活用することで、より高速かつ安全で、そして保守しやすいC++コードを記述することが可能になります。

ぜひ、皆さんのプロジェクトで Boost.JSON を試してみてください。そして、そのメリットを最大限に引き出すために、本記事で紹介した高速化と安全性のためのテクニックを積極的に活用してください。未来のC++アプリケーションは、きっと、よりパワフルで信頼性の高いものになるでしょう。