QMap::ConstIteratorのベストプラクティス：Qtで効率的なデータ走査

QMap::ConstIterator とは

QMap::ConstIteratorは、QtフレームワークのコンテナクラスであるQMap（キーと値のペアを格納し、キーでソートされた状態を保つマップ）の要素を読み取り専用で走査（イテレート）するためのイテレータクラスです。C++標準ライブラリのstd::map::const_iteratorに相当する機能を提供します。

特徴と役割

1. 読み取り専用 (Const Iterator): QMap::ConstIteratorを使用すると、QMap内の要素（キーと値のペア）を参照できますが、値を変更することはできません。もし、イテレータを使って値を変更したい場合は、QMap::iteratorを使用する必要があります。

2. STLスタイルイテレータ: QtのQMapは、STL（Standard Template Library）スタイルのイテレータ（QMap::iteratorとQMap::const_iterator）と、より高レベルで使いやすいJavaスタイルのイテレータ（QMapIteratorとQMutableMapIterator）の両方を提供します。QMap::ConstIteratorはSTLスタイルに分類されます。STLに慣れている開発者にとっては馴染み深く、低レベルな制御が可能で、わずかに高速であるという利点があります。

3. 要素の順序: QMapはキーによって要素をソートして格納するため、QMap::ConstIteratorでイテレートすると、キーの昇順で要素が取得されます。

4. イテレータの初期化: QMap::ConstIteratorを宣言した後、実際に使用する前にQMapの関数（例: QMap::constBegin(), QMap::constEnd(), QMap::constFind()）を使って初期化する必要があります。

   • constBegin(): マップの最初の要素を指すイテレータを返します。
   • constEnd(): マップの最後の要素の「次」を指すイテレータを返します（ループの終了条件として使用されます）。
   • constFind(key): 指定されたキーを持つ要素を指すイテレータを返します。見つからない場合はconstEnd()を返します。

5. 基本的な操作: QMap::ConstIteratorは、ポインタのように振る舞います。

   • *iter: イテレータが指す要素の値（const T&）を取得します。
   • iter.key(): イテレータが指す要素のキー（const Key&）を取得します。
   • iter.value(): イテレータが指す要素の値（const T&）を取得します。
   • ++iter / iter++: 次の要素に進みます。
   • --iter / iter--: 前の要素に戻ります。
   • iter != map.constEnd(): ループの終了条件として使用されます。

使用例

QMap<QString, int>内のすべての要素をQMap::ConstIteratorを使って表示する典型的なループの例です。

#include <QCoreApplication>
#include <QMap>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QMap<QString, int> map;
    map.insert("January", 1);
    map.insert("February", 2);
    map.insert("March", 3);
    map.insert("April", 4);

    // QMap::ConstIterator を使用してマップの要素を走査
    QMap<QString, int>::const_iterator i;
    for (i = map.constBegin(); i != map.constEnd(); ++i) {
        qDebug() << i.key() << ": " << i.value();
    }

    // Qt 5.10 以降では range-based for ループも使用可能
    // ただし、キーと値のペアを直接取得するには QMap::constKeyValueBegin() などを使用する場合が多い
    // 例: for (auto const& [key, value] : map.asKeyValueRange()) { ... }

    return a.exec();
}

このコードを実行すると、次のような出力が得られます。

"April": 4
"February": 2
"January": 1
"March": 3

(QMapはキーでソートされるため、キーのアルファベット順に出力されます。)

特徴	QMap::ConstIterator	QMap::Iterator
読み書き権限	読み取り専用	読み書き可能
value() の戻り値	const T&	T&
使用ケース	マップの内容を変更しない場合	マップの内容を変更する場合
パフォーマンス	わずかに高速である可能性がある	標準的
コードの可読性	変更しないことを明示的に示すため、可読性が向上する場合がある

---

QMap::ConstIteratorは、QMapの要素を安全に読み取るための便利なツールですが、C++のイテレータの一般的な落とし穴やQtの暗黙的な共有（Implicit Sharing）の特性により、特定のエラーや予期せぬ動作が発生することがあります。

コンパイルエラー: const_iteratorからiteratorへの変換

エラーの症状: QMap::constBegin()やQMap::constEnd()から返されるQMap::ConstIteratorを、QMap::iterator型の変数に代入しようとするとコンパイルエラーが発生します。

QMap<QString, int> myMap;
// ...
QMap<QString, int>::iterator it = myMap.constBegin(); // エラー！

原因: QMap::ConstIteratorは読み取り専用のイテレータであり、QMap::iteratorは読み書き可能なイテレータです。読み取り専用のものを読み書き可能なものに変換することはできません。これは、const修飾子が持つ意味合いと同じです。

トラブルシューティング: QMap::ConstIteratorを使用したい場合は、適切な型で宣言します。

QMap<QString, int> myMap;
// ...
QMap<QString, int>::const_iterator it = myMap.constBegin(); // OK

または、QMapの要素を変更する必要がある場合は、QMap::begin()やQMap::end()を使用してQMap::iteratorを取得します。

QMap<QString, int> myMap;
// ...
QMap<QString, int>::iterator it = myMap.begin(); // OK (mapの内容を変更できる)

Qt 5.10以降では、autoキーワードを使うことで型の推論に任せるのが最も安全で推奨される方法です。

QMap<QString, int> myMap;
// ...
for (auto it = myMap.constBegin(); it != myMap.constEnd(); ++it) {
    // ...
}

未初期化イテレータの使用

エラーの症状: QMap::ConstIteratorを宣言したが、QMap::constBegin()などで初期化する前に*itやit.key()などの操作を行うと、未定義の動作（クラッシュや予期せぬ値）が発生します。

QMap<QString, int> myMap;
QMap<QString, int>::const_iterator it; // 未初期化
qDebug() << it.key(); // 未定義の動作、クラッシュの可能性あり

原因: イテレータはポインタと同様に、有効な場所を指すように初期化される必要があります。デフォルトコンストラクタで作成されたイテレータは「未初期化」状態です。

トラブルシューティング: 必ずQMap::constBegin(), QMap::constEnd(), QMap::constFind()など、QMapの関数から返される有効なイテレータで初期化してから使用します。

QMap<QString, int> myMap;
myMap.insert("Hello", 1);
QMap<QString, int>::const_iterator it = myMap.constBegin(); // 有効な初期化
if (it != myMap.constEnd()) {
    qDebug() << it.key(); // OK
}

無効化されたイテレータ（Dangling Iterator）の使用

エラーの症状: イテレータが指していた要素がマップから削除された後も、そのイテレータを使用しようとすると未定義の動作（クラッシュ、メモリ破損、誤ったデータ）が発生します。

QMap<QString, int> myMap;
myMap.insert("A", 1);
myMap.insert("B", 2);

QMap<QString, int>::const_iterator it = myMap.constBegin(); // "A" を指す
myMap.remove("A"); // "A" が削除され、'it' は無効になる

qDebug() << it.key(); // 未定義の動作！

原因: 要素が削除されると、その要素を指していたイテレータは無効になります。これは「ダングリングイテレータ」と呼ばれます。

トラブルシューティング: 要素を削除する操作（remove()、clear()など）を行った後は、既存のイテレータが無効になる可能性があることを認識し、必要に応じてイテレータを再取得するか、削除操作に合わせてループのロジックを調整します。

QMap::erase()の使用: QMap::erase()は、引数としてイテレータを受け取り、削除後の次の有効なイテレータを返します。これにより、ループ内で安全に要素を削除しながらイテレートを続けることができます。

QMap<QString, int> myMap;
myMap.insert("A", 1);
myMap.insert("B", 2);
myMap.insert("C", 3);

QMap<QString, int>::iterator i = myMap.begin(); // const_iteratorではないことに注意 (削除にはiteratorが必要)
while (i != myMap.end()) {
    if (i.key() == "B") {
        i = myMap.erase(i); // 要素を削除し、次の有効なイテレータを取得
    } else {
        ++i;
    }
}
// QMap::ConstIterator では直接削除できないため、この例は QMap::iterator を使用しています。
// ConstIterator の場合は、マップの内容を変更する関数を呼ぶことができないため、
// そもそも削除操作は不可能です。

constではないQMapに対してconstBegin()/constEnd()以外を使用する際の注意

エラーの症状: これはエラーというよりはパフォーマンスに関する注意点です。 const QMap&に対してではなく、QMapオブジェクト自体がconstではない場合でもconst_iteratorを使用できますが、begin()やend()を呼ぶと、Qtの暗黙的な共有が原因で不必要なデタッチ（コピーオンライト）が発生する可能性があります。

QMap<QString, int> myMap;
QMap<QString, int> anotherMap = myMap; // ここでmyMapとanotherMapはデータを共有

// 以下のようにすると、myMapのデータがanotherMapからデタッチされる可能性がある
// (QMap::begin() が非constなので、共有されたデータが変更される可能性があると判断されるため)
QMap<QString, int>::const_iterator it = myMap.begin(); // ここでデタッチが発生する可能性

原因: Qtのコンテナは暗黙的な共有（コピーオンライト）メカニズムを持っています。これは、コンテナがコピーされたときにデータをすぐに複製せず、実際にデータが変更されるまで共有するというものです。constではないbegin()やend()を呼び出すと、コンテナは「書き込み準備ができた」と判断し、共有されたデータからデタッチ（複製）することがあります。これはQMap::ConstIteratorを使用しているにもかかわらず発生しうるパフォーマンスのオーバーヘッドです。

トラブルシューティング: QMapがconstではない場合でも、const_iteratorを使用する際は必ずconstBegin()とconstEnd()を使用することで、不必要なデタッチを防ぎ、パフォーマンスを最適化できます。

QMap<QString, int> myMap;
QMap<QString, int> anotherMap = myMap; // データ共有

// constBegin() を使用しているので、デタッチは発生しない
for (auto it = myMap.constBegin(); it != myMap.constEnd(); ++it) {
    qDebug() << it.key() << ": " << it.value();
}

イテレータの比較に関する注意

エラーの症状: 異なるQMapインスタンスから取得したイテレータを比較しようとすると、論理的な間違いや未定義の動作につながる可能性があります。

QMap<QString, int> map1;
map1.insert("A", 1);
QMap<QString, int> map2;
map2.insert("A", 1);

QMap<QString, int>::const_iterator it1 = map1.constBegin();
QMap<QString, int>::const_iterator it2 = map2.constBegin();

if (it1 == it2) { // 常にfalse、意味がない
    // ...
}

原因: イテレータは特定のコンテナインスタンス内の位置を指すものです。異なるコンテナインスタンスのイテレータを比較しても、概念的に意味がありません。

トラブルシューティング: イテレータは、同じコンテナインスタンスから取得されたもの同士でのみ比較します。特に、ループの終了条件としてconstEnd()を使用する場合は、必ず同じQMapインスタンスのconstEnd()と比較します。

---

マップの全要素を順に読み取る（基本的なループ）

これは最も一般的なQMap::ConstIteratorの使用方法です。マップ内のすべてのキーと値のペアをキーの昇順で走査します。

#include <QCoreApplication>
#include <QMap>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // QMapを宣言し、データを挿入
    QMap<QString, int> studentGrades;
    studentGrades.insert("Alice", 95);
    studentGrades.insert("Bob", 88);
    studentGrades.insert("Charlie", 72);
    studentGrades.insert("David", 91);
    studentGrades.insert("Eve", 85);

    qDebug() << "--- 生徒の成績リスト ---";

    // QMap::ConstIterator を使用してマップを走査
    QMap<QString, int>::const_iterator i;
    for (i = studentGrades.constBegin(); i != studentGrades.constEnd(); ++i) {
        // i.key() でキー、i.value() で値にアクセス
        qDebug() << "名前: " << i.key() << ", 成績: " << i.value();
    }

    // Qt 5.10 以降では、C++11 のレンジベースforループと 'auto' を使うのがより現代的で推奨されます。
    // QMap::constKeyValueBegin() と QMap::constKeyValueEnd() を使用すると、
    // std::pair<const Key, const T> を返すイテレータを取得できます。
    // C++17 以降では構造化束縛 (structured bindings) を使うとさらに簡潔です。
    qDebug() << "\n--- 生徒の成績リスト (C++17 構造化束縛を使用) ---";
    for (auto const& [name, grade] : studentGrades.asKeyValueRange()) {
        qDebug() << "名前: " << name << ", 成績: " << grade;
    }


    return a.exec();
}

出力例

--- 生徒の成績リスト ---
名前: "Alice" , 成績: 95
名前: "Bob" , 成績: 88
名前: "Charlie" , 成績: 72
名前: "David" , 成績: 91
名前: "Eve" , 成績: 85

--- 生徒の成績リスト (C++17 構造化束縛を使用) ---
名前: "Alice" , 成績: 95
名前: "Bob" , 成績: 88
名前: "Charlie" , 成績: 72
名前: "David" , 成績: 91
名前: "Eve" , 成績: 85

特定の要素を検索し、その値を取得する

QMap::constFind()を使用して、特定のキーを持つ要素を探し、そのイテレータを取得します。要素が見つかった場合のみ、そのキーと値にアクセスします。

#include <QCoreApplication>
#include <QMap>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QMap<QString, QString> capitals;
    capitals.insert("Japan", "Tokyo");
    capitals.insert("USA", "Washington D.C.");
    capitals.insert("France", "Paris");
    capitals.insert("Germany", "Berlin");

    QString searchKey1 = "Japan";
    QString searchKey2 = "Canada";

    // 存在するキーを検索
    QMap<QString, QString>::const_iterator it1 = capitals.constFind(searchKey1);
    if (it1 != capitals.constEnd()) {
        qDebug() << searchKey1 << "の首都は" << it1.value() << "です。";
    } else {
        qDebug() << searchKey1 << "は見つかりませんでした。";
    }

    // 存在しないキーを検索
    QMap<QString, QString>::const_iterator it2 = capitals.constFind(searchKey2);
    if (it2 != capitals.constEnd()) {
        qDebug() << searchKey2 << "の首都は" << it2.value() << "です。";
    } else {
        qDebug() << searchKey2 << "は見つかりませんでした。";
    }

    return a.exec();
}

出力例

"Japan" の首都は "Tokyo" です。
"Canada" は見つかりませんでした。

イテレータの前方・後方移動（++, -- 演算子）

QMap::ConstIteratorは、++（インクリメント）や--（デクリメント）演算子を使用して、イテレータを前後に移動させることができます。これは、特定の範囲内の要素を処理する場合や、特定の開始点からイテレートを開始する場合に役立ちます。

#include <QCoreApplication>
#include <QMap>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QMap<int, QString> numbers;
    numbers.insert(1, "One");
    numbers.insert(2, "Two");
    numbers.insert(3, "Three");
    numbers.insert(4, "Four");
    numbers.5insert(5, "Five");

    // マップの最初から3番目の要素に移動
    QMap<int, QString>::const_iterator it = numbers.constBegin();
    if (numbers.size() >= 3) {
        it += 2; // 最初の要素 (0番目) から2つ進むので、3番目の要素を指す
        qDebug() << "3番目の要素 (キーと値):" << it.key() << ":" << it.value();
    }

    // 最後の要素から1つ手前の要素に移動 (注意: constEnd()はマップの「次」を指す)
    QMap<int, QString>::const_iterator lastButOne = numbers.constEnd();
    if (numbers.size() > 0) {
        --lastButOne; // constEnd() から1つ戻ると最後の要素を指す
        qDebug() << "最後の要素:" << lastButOne.key() << ":" << lastButOne.value();
    }

    return a.exec();
}

出力例

3番目の要素 (キーと値): 3 : "Three"
最後の要素: 5 : "Five"

QMapオブジェクト自体がconstとして宣言されている場合、const_iteratorしか使用できません。この場合、begin()やend()も自動的にconst_iteratorを返します。

#include <QCoreApplication>
#include <QMap>
#include <QDebug>

// const QMap を受け取る関数
void printConstMap(const QMap<int, double>& data)
{
    qDebug() << "--- const QMap の要素 ---";
    // const QMap では begin() と end() も const_iterator を返す
    for (QMap<int, double>::const_iterator it = data.begin(); it != data.end(); ++it) {
        qDebug() << "キー:" << it.key() << ", 値:" << it.value();
    }
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QMap<int, double> myData;
    myData.insert(10, 10.5);
    myData.insert(20, 20.0);
    myData.insert(30, 30.3);

    printConstMap(myData); // myData を const 参照として関数に渡す

    return a.exec();
}

--- const QMap の要素 ---
キー: 10 , 値: 10.5
キー: 20 , 値: 20
キー: 30 , 値: 30.3

---

Javaスタイルのイテレータ (QMapIterator)

Qtは、STLスタイルのイテレータ（QMap::const_iteratorなど）とは別に、より高レベルで使いやすい「Javaスタイルのイテレータ」を提供しています。QMapの場合、読み取り専用のJavaスタイルイテレータはQMapIteratorです。

特徴

• マップが変更された場合でも、古いイテレータは有効なまま元のマップのコピーを走査し続けます（QtのImplicit Sharingによる）。
• STLスタイルのイテレータとは異なり、イテレータが指す位置は要素の「間」です。next()を呼び出すと次の要素に進み、その要素を返します。
• より簡潔なAPI (hasNext(), next(), key(), value())。

コード例

#include <QCoreApplication>
#include <QMap>
#include <QDebug>
#include <QMapIterator> // QMapIterator を使用するために必要

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QMap<QString, int> scores;
    scores.insert("Math", 90);
    scores.insert("Physics", 85);
    scores.insert("Chemistry", 78);

    qDebug() << "--- スコアリスト (Javaスタイルイテレータ) ---";
    QMapIterator<QString, int> i(scores); // マップを引数にコンストラクタを呼び出す
    while (i.hasNext()) {
        i.next(); // 次の要素に進む
        qDebug() << i.key() << ": " << i.value();
    }

    // 逆順に走査することも可能
    qDebug() << "\n--- スコアリスト (Javaスタイルイテレータ、逆順) ---";
    i.toBack(); // イテレータをマップの最後に移動
    while (i.hasPrevious()) {
        i.previous(); // 前の要素に戻る
        qDebug() << i.key() << ": " << i.value();
    }

    return a.exec();
}

利点

• findNext()やfindPrevious()などの検索機能も提供される。
• ループの条件が直感的。

欠点

• C++標準ライブラリのアルゴリズムとは直接互換性がない。
• STLスタイルのイテレータよりわずかにオーバーヘッドが大きい場合がある（通常は無視できるレベル）。

レンジベースforループ (C++11以降)

C++11で導入されたレンジベースforループは、コンテナの全要素を走査するのに非常に簡潔な構文を提供します。Qtのコンテナもこれに対応しています。

注意点（QtのImplicit Sharingとの兼ね合い）
Qtのコンテナは暗黙的な共有（Implicit Sharing / コピーオンライト）を使用しているため、QMapが非constの場合に直接レンジベースforループを使うと、不要なデータデタッチ（コピー）が発生する可能性があります。これを避けるためには、qAsConst()ヘルパー関数（Qt 5.7以降）またはC++17のstd::as_const()を使用します。

コード例

#include <QCoreApplication>
#include <QMap>
#include <QDebug>
#include <QList> // qAsConst のために必要

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QMap<int, QString> products;
    products.insert(101, "Laptop");
    products.insert(102, "Mouse");
    products.insert(103, "Keyboard");
    products.insert(104, "Monitor");

    qDebug() << "--- 製品リスト (レンジベースforループ) ---";

    // 方法1: キーと値のペアを直接イテレート (Qt 5.10+ QMap::keyValueBegin/End, Qt 6.4+ QMap::asKeyValueRange)
    // Qt 6.4以降で推奨される方法 (C++17 構造化束縛と組み合わせる)
    #if QT_VERSION >= QT_VERSION_CHECK(6, 4, 0)
    for (auto const& [id, name] : products.asKeyValueRange()) {
        qDebug() << "ID: " << id << ", 製品名: " << name;
    }
    #elif QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
    // Qt 5.10から6.3までの方法
    for (auto it = products.constKeyValueBegin(); it != products.constKeyValueEnd(); ++it) {
        qDebug() << "ID: " << it->first << ", 製品名: " << it->second;
    }
    #else
    // それ以前のバージョンでキーと値を両方取得したい場合 (次で説明する keys() と [] 演算子の組み合わせ)
    for (const int& id : qAsConst(products.keys())) { // ここで keys() は QList<Key> を返すため、この方法は非効率になる可能性あり
        qDebug() << "ID: " << id << ", 製品名: " << products.value(id);
    }
    #endif

    // 方法2: 値のみをイテレートしたい場合 (非推奨、キーにアクセスできないため)
    // 注意: 非constのQMapに対してこれを行うとデタッチが発生する可能性がある
    qDebug() << "\n--- 製品名のみ (値によるレンジベースforループ, 非推奨の可能性あり) ---";
    for (const QString& name : qAsConst(products)) { // products は const 参照として扱われる
        qDebug() << "製品名: " << name;
    }


    return a.exec();
}

利点

• 現代C++のイディオムに沿っている。
• 非常に簡潔で読みやすい構文。

欠点

• デフォルトでは値のみをイテレートするため、キーと値のペアにアクセスするにはkeyValueBegin()/keyValueEnd()やasKeyValueRange()を使用する必要がある（Qt 5.10以降）。
• QtのImplicit Sharingとの兼ね合いでqAsConst()やstd::as_const()（またはconst修飾）を忘れると、不必要なコピーが発生しうる。

keys()またはvalues()関数とインデックスまたはoperator[]によるアクセス

QMap::keys()はマップのすべてのキーを含むQListを返し、QMap::values()はすべての値を含むQListを返します。これらのリストをイテレートし、必要に応じてoperator[]やvalue()関数で関連する要素にアクセスできます。

注意点
keys()やvalues()は新しいQListオブジェクトを作成するため、マップが非常に大きい場合、この方法はパフォーマンスのオーバーヘッドが大きくなる可能性があります。読み取り専用のシナリオであっても、これらの関数はマップの完全なコピーではないものの、キーや値のリストを構築するため、一時的なメモリ割り当てとコピーが発生します。

コード例

#include <QCoreApplication>
#include <QMap>
#include <QDebug>
#include <QList> // QList を使用するために必要

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QMap<QString, int> cityPopulations;
    cityPopulations.insert("Tokyo", 14000000);
    cityPopulations.insert("London", 9000000);
    cityPopulations.insert("Paris", 2100000);
    cityPopulations.insert("New York", 8400000);

    qDebug() << "--- 都市の人口リスト (keys() と [] 演算子) ---";
    // keys() が返す QList を利用してイテレート
    // keys() は新しい QList を作成するため、大規模なマップではパフォーマンスに注意
    for (const QString& cityName : cityPopulations.keys()) {
        qDebug() << "都市: " << cityName << ", 人口: " << cityPopulations[cityName];
        // または cityPopulations.value(cityName) を使用
    }

    qDebug() << "\n--- 都市の人口リスト (values() のみ) ---";
    // values() が返す QList を利用してイテレート
    for (int population : cityPopulations.values()) {
        qDebug() << "人口: " << population;
    }

    return a.exec();
}

利点

• キーや値のリストを個別に操作したい場合に便利。
• シンプルで分かりやすいコード。

• keys()やvalues()はコンテナの要素のコピーを生成するため、パフォーマンスやメモリ使用の点で非効率になる可能性がある。大規模なマップや頻繁な操作には不向き。

• キーや値のリスト全体が必要な場合、またはマップのサイズが比較的小さい場合
  

  • QMap::keys()またはQMap::values()

• より高レベルで使いやすいAPIを好む場合、またはマップ変更時のイテレータの挙動に柔軟性が必要な場合
  

  • QMapIterator

• マップの内容を変更しない読み取り専用の走査で、C++11以前の環境やSTLスタイルに慣れている場合
  

  • QMap::const_iterator (for (QMap<K, T>::const_iterator it = map.constBegin(); ... ))

• 最も推奨される方法 (現代C++のイディオム)
  

  • Qt 6.4以降: QMap::asKeyValueRange() と C++17の構造化束縛 (for (auto const& [key, value] : map.asKeyValueRange()))
  • Qt 5.10からQt 6.3: QMap::constKeyValueBegin() / constKeyValueEnd() を用いたレンジベースforループ (for (auto it = map.constKeyValueBegin(); it != map.constKeyValueEnd(); ++it))