<T>::reverse_iterator QList::rend()

2025-06-06

QList とイテレータの基本

まず、QList<T> はQtで提供される汎用コンテナクラスの一つで、動的配列のようなものです。T はリストに格納される要素の型を示します。

イテレータは、コンテナ内の要素にアクセスするための一般的な方法を提供します。C++のSTL (Standard Template Library) と同様に、Qtのコンテナもイテレータをサポートしています。

reverse_iterator とは？

reverse_iterator は、コンテナを逆順に（末尾から先頭に向かって）走査するための特別なイテレータです。通常のイテレータが begin() でコンテナの先頭を指し、end() でコンテナの末尾の「1つ後ろ」を指すのに対し、reverse_iterator は次のように振る舞います。

rend(): コンテナの**先頭の要素の「1つ前」**を指します。
rbegin(): コンテナの末尾の要素を指します。

<T>::reverse_iterator QList::rend() の意味

QList::rend() は、QList クラスのメンバ関数で、T 型の要素を持つ QList のための reverse_iterator を返します。具体的には、コンテナの先頭の要素の「1つ前」を指す逆イテレータを返します。これは、逆順でのイテレーションの「終了条件」として使用されます。

なぜ rend() が「1つ前」を指すのか？

これは、通常のイテレータの end() が「1つ後ろ」を指すのと同様の考え方です。ループの条件として it != rend() を使うことで、先頭の要素まで処理し終えたときにループが終了するように設計されています。

使用例

QList を逆順にイテレートする一般的な方法は次のようになります。

#include <QList>
#include <QDebug> // qDebug() を使うために必要

int main() {
    QList<int> numbers;
    numbers << 10 << 20 << 30 << 40 << 50;

    // 逆順にイテレート
    for (QList<int>::reverse_iterator it = numbers.rbegin(); it != numbers.rend(); ++it) {
        qDebug() << *it;
    }

    return 0;
}

上記のコードは、以下のように出力されます。

C++のSTLの std::reverse_iterator と同様の動作をします。
rbegin() と組み合わせて使用することで、QList の末尾から先頭に向かって要素にアクセスできます。
<T>::reverse_iterator QList::rend() は、QList の要素を逆順に走査する際に使用する逆イテレータの「終端」を指します。

イテレータの無効化 (Iterator Invalidation)

これは QList や他のコンテナを操作する際に最もよくある問題です。 reverse_iterator も例外ではありません。

エラーの症状

デバッグ時にイテレータが「無効」と表示される
予期せぬデータ
セグメンテーション違反 (Segmentation fault) やクラッシュ

原因
イテレータを使って QList を走査している最中に、その QList の内容が変更された場合（要素の追加、削除、並び替えなど）、イテレータが無効になります。無効になったイテレータを dereference ( *it ) したり、インクリメント/デクリメントしたりすると、未定義の動作 (Undefined Behavior) が発生し、クラッシュや予期せぬ結果を招きます。

QList の特性
QList は内部的には動的配列のような実装を持つため、要素の追加や削除がリストの途中で行われると、メモリの再割り当てや要素の移動が発生し、既存のすべてのイテレータが無効になる可能性があります。特に、QList がポインタよりも大きい型の要素を格納している場合や、Q_MOVABLE_TYPE または Q_PRIMITIVE_TYPE として宣言されていない型を格納している場合、QList は内部的にポインタの配列として実装されるため、より注意が必要です。

トラブルシューティング/解決策

const_reverse_iterator を使用する
コンテナの内容を変更しないのであれば、QList::const_reverse_iterator (または QList::crend()) を使用します。これにより、誤って内容を変更してしまうことを防ぎ、コンパイラが問題を検出してくれる可能性があります。

空の QList でのイテレータ操作

エラーの症状

クラッシュ (特に *it をデリファレンスしようとした場合)

原因
空の QList では、rbegin() と rend() は同じイテレータを返します。この状態で *it をデリファレンスしようとすると、無効なメモリにアクセスしようとしてクラッシュします。

トラブルシューティング/解決策
イテレーションを開始する前に、QList::isEmpty() または QList::size() を使ってリストが空でないことを確認します。

QList<int> emptyList;
if (!emptyList.isEmpty()) { // 重要: 空でないかチェック
    for (auto it = emptyList.rbegin(); it != emptyList.rend(); ++it) {
        // このループは実行されない
        qDebug() << *it;
    }
} else {
    qDebug() << "List is empty.";
}

イテレータの範囲外アクセス

エラーの症状

予期せぬ値
セグメンテーション違反 (Segmentation fault) またはクラッシュ

原因
rend() はコンテナの「末尾の1つ前」（逆順走査の終了地点）を指すため、rend() そのものをデリファレンスすることはできません。また、rbegin() から rend() の範囲外にイテレータを移動させようとすると問題が発生します。

トラブルシューティング/解決策

--it ではなく ++it
逆イテレータは、概念的には「逆方向」に進むため、++it がリストの先頭方向（つまり、要素のインデックスが減少する方向）に進みます。通常のイテレータの ++ とは逆の動作になることに注意してください。これはエラーというよりは、理解の誤りによる混乱です。
ループ条件の確認
it != list.rend() の条件を厳密に守る。

Q_FOREACH (Qt 5以前) と reverse_iterator

背景
Qt 5までは Q_FOREACH マクロがよく使われましたが、これは const_iterator を使用するため、読み取り専用のイテレーションにしか使えませんでした。また、reverse_iterator と直接組み合わせて逆順にイテレートするようには設計されていません。

トラブルシューティング/解決策

Qt 6からは Q_FOREACH は非推奨となり、標準C++の範囲ベースforループが推奨されています。reverse_iterator を使う場合は、引き続きSTLスタイルのforループが適切です。

C++11以降の範囲ベースforループを使用する。

QList<int> numbers = {10, 20, 30};
// 逆順イテレーションには直接使えない
// for (int num : numbers) { // 順方向
//    qDebug() << num;
// }

// 逆順イテレーションにはSTLスタイルのforループを使うのが一般的
for (auto it = numbers.rbegin(); it != numbers.rend(); ++it) {
    qDebug() << *it;
}

std::reverse_iterator と QList::reverse_iterator の混同

背景
QList はSTL互換のイテレータも提供していますが、内部的な実装は異なる場合があります。特にQListが暗黙的共有（Implicit Sharing）を使用している場合、イテレータの挙動に注意が必要です。

トラブルシューティング/解決策

STLのアルゴリズム (std::sort など) と組み合わせる場合は、互換性があることを確認するか、QList の要素を一時的に std::vector などにコピーして処理することも検討します。
基本的にQtのコンテナにはQtが提供するイテレータ (QList<T>::iterator, QList<T>::reverse_iterator など) を使用することをお勧めします。

イテレータ関連の問題はデバッグが難しい場合がありますが、以下の点が役立ちます。

最小限の再現コードを作成する
問題が発生した場合は、その問題を再現する最小限のコードスニペットを作成します。これにより、複雑なコードベースから問題を切り離し、原因を特定しやすくなります。

アサーションを使用する
開発中に Q_ASSERT や C++ の assert を使用して、イテレータが無効でないことを確認するコードを追加します。

// ループ内でイテレータを再取得するような複雑な処理の場合
Q_ASSERT(it != list.rend()); // rend()をデリファレンスしない
// Q_ASSERT(it.isValid()); // QList::iteratorにはisValid()がないが、概念として有効性を確認する

デバッガでイテレータの値を確認する
デバッガでイテレータ変数 it の値や、*it のデリファレンス結果をステップ実行しながら確認します。無効なイテレータはデバッガによって「invalid」と表示されることがあります。

例1: `QList` の要素を逆順に表示する基本的な例

最も基本的な使用例です。QList の末尾から先頭に向かって要素を処理します。

#include <QList>
#include <QDebug> // qDebug() を使用するために必要

int main() {
    QList<QString> fruits;
    fruits << "Apple" << "Banana" << "Cherry" << "Date";

    qDebug() << "--- Fruits in reverse order ---";

    // QList<QString>::reverse_iterator を明示的に使用
    // rbegin() はリストの最後の要素 ("Date") を指す
    // rend() はリストの最初の要素の「一つ前」を指す (ループの終了条件)
    for (QList<QString>::reverse_iterator it = fruits.rbegin(); it != fruits.rend(); ++it) {
        qDebug() << *it; // イテレータが指す要素の値を取得
    }

    qDebug() << "\n--- Using 'auto' for convenience ---";

    // C++11以降の 'auto' キーワードを使って型推論させることで、コードが簡潔になります
    for (auto it = fruits.rbegin(); it != fruits.rend(); ++it) {
        qDebug() << *it;
    }

    return 0;
}

出力

--- Fruits in reverse order ---
"Date"
"Cherry"
"Banana"
"Apple"

--- Using 'auto' for convenience ---
"Date"
"Cherry"
"Banana"
"Apple"

解説

*it: イテレータが現在指している要素の値を取得します。
++it: 逆イテレータを「進める」操作です。reverse_iterator の ++ は、コンテナの先頭方向（つまり、要素のインデックスが減少する方向）に移動します。
fruits.rend(): 逆イテレータの終了位置で、リストの最初の要素 "Apple" の一つ前を指します。ループはこのイテレータに到達すると終了します。
fruits.rbegin(): 逆イテレータの開始位置で、リストの最後の要素 "Date" を指します。

例2: `QList` を逆順にコピーして新しいリストを作成する

reverse_iterator を使用して、既存のリストの要素を逆順で新しいリストにコピーする例です。

#include <QList>
#include <QDebug>

int main() {
    QList<int> originalNumbers;
    originalNumbers << 1 << 2 << 3 << 4 << 5;

    QList<int> reversedNumbers;

    qDebug() << "Original Numbers:";
    for (int num : originalNumbers) {
        qDebug() << num;
    }

    // reverse_iterator を使って逆順に要素をコピー
    for (auto it = originalNumbers.rbegin(); it != originalNumbers.rend(); ++it) {
        reversedNumbers.append(*it); // 新しいリストの末尾に追加
    }

    qDebug() << "\nReversed Numbers:";
    for (int num : reversedNumbers) {
        qDebug() << num;
    }

    return 0;
}

出力

Original Numbers:
1
2
3
4
5

Reversed Numbers:
5
4
3
2
1

解説
この例では、originalNumbers を rbegin() から rend() まで走査し、各要素を reversedNumbers の末尾に append() しています。結果として、逆順に並んだ新しいリストが作成されます。

例3: `QList` の要素を逆順で条件付きで変更する（非推奨/注意が必要な方法）

警告
ループ中にQListの要素を追加・削除・並べ替えを行うと、イテレータが無効になる可能性が高いため、以下の方法は推奨されません。特にreverse_iteratorを使って逆方向から要素を削除する場合は、非常に複雑で間違いやすいです。代わりに、インデックスベースのループを使うか、処理対象の要素を一度別のリストに格納してから処理するなどの代替手段を検討してください。

この例は、reverse_iteratorを操作する際の注意点を示すためのものです。

#include <QList>
#include <QDebug>

int main() {
    QList<int> numbers = {10, 25, 30, 45, 50, 65, 70};

    qDebug() << "Original list:";
    qDebug() << numbers;

    // 逆順にイテレートし、3の倍数を削除する (非常に注意が必要な操作)
    // reverse_iteratorからの削除は非常に複雑になるため、この方法は一般的ではない
    // erase() は順方向イテレータを返すため、reverse_iteratorに変換し直す必要がある
    // std::next(it).base() は、現在のreverse_iteratorが指す要素の「1つ前」の順方向イテレータを返す
    // erase() は、削除された要素の「次」の要素を指す順方向イテレータを返す
    // その結果を再度reverse_iteratorに変換する
    for (auto it = numbers.rbegin(); it != numbers.rend(); /* no ++it here */) {
        if (*it % 3 == 0) { // 3の倍数
            qDebug() << "Removing:" << *it;
            // reverse_iteratorは、その性質上、要素の削除を処理するのが複雑
            // .base() は "forward" イテレータを返すが、これは reverse_iterator が指す要素の「1つ後」の要素を指す
            // したがって、実際に削除したい要素を得るには std::next(it).base() を使う必要がある
            // erase() は削除後の次の要素を指すイテレータを返すため、それを reverse_iterator に変換し直す
            it = QList<int>::reverse_iterator(numbers.erase(std::next(it).base()));
        } else {
            ++it; // 3の倍数でなければ次に進む
        }
    }

    qDebug() << "\nList after removal:";
    qDebug() << numbers;

    return 0;
}

出力

Original list:
QList(10, 25, 30, 45, 50, 65, 70)
Removing: 70  // 30の前に70, 45の前に50, 65の前に45, 70の前に65
Removing: 45
Removing: 30

List after removal:
QList(10, 25, 50, 65)

解説 (この複雑な削除操作について)
この例は、reverse_iterator で削除を行う際の複雑さを示しています。

it.base() は、逆イテレータ it が指す要素の「1つ後」の通常のイテレータを返します。
std::next(it) は、it を論理的に「1つ進めた」逆イテレータを返します。その base() は、元の it が指していた要素の「1つ前」の通常のイテレータを返します。
numbers.erase(std::next(it).base()) は、実際に現在の逆イテレータが指している要素を削除し、削除された要素の次の通常のイテレータを返します。
この返された通常のイテレータを QList<int>::reverse_iterator(...) で逆イテレータに変換し直すことで、次の適切な位置からイテレーションを続行できます。

より安全な代替手段 (逆順での削除)
前述したように、逆順で要素を削除する場合は、インデックスベースのループが最も安全で理解しやすいです。

#include <QList>
#include <QDebug>

int main() {
    QList<int> numbers = {10, 25, 30, 45, 50, 65, 70};

    qDebug() << "Original list:";
    qDebug() << numbers;

    // インデックスベースで逆順にイテレートし、3の倍数を削除する
    for (int i = numbers.size() - 1; i >= 0; --i) {
        if (numbers.at(i) % 3 == 0) {
            qDebug() << "Removing at index" << i << ":" << numbers.at(i);
            numbers.removeAt(i);
        }
    }

    qDebug() << "\nList after removal (using index):";
    qDebug() << numbers;

    return 0;
}

出力 (インデックスベースの削除)

Original list:
QList(10, 25, 30, 45, 50, 65, 70)
Removing at index 6 : 70
Removing at index 4 : 50 // 65は3の倍数ではないため残る
Removing at index 3 : 45
Removing at index 2 : 30

List after removal (using index):
QList(10, 25, 65)

解説 (インデックスベースの削除)
インデックスベースのループでは、removeAt(i) を呼び出しても、それより小さいインデックスの要素には影響がないため、イテレータの無効化を心配する必要がありません。このため、逆順での削除にはこの方法が推奨されます。

リストの内容を変更しないことが保証されている場合、const_reverse_iterator を使用することで、意図しない変更を防ぎ、コードの安全性を高めることができます。crend() は const_reverse_iterator を返します。

#include <QList>
#include <QDebug>

// リストの内容を変更しない関数
void printListInReverse(const QList<double>& data) {
    qDebug() << "--- Printing a const list in reverse ---";
    // const QList の rbegin()/rend() は自動的に const_reverse_iterator を返す
    // あるいは crend() を明示的に使用
    for (auto it = data.crbegin(); it != data.crend(); ++it) {
        qDebug() << *it;
    }
}

int main() {
    QList<double> temperatures;
    temperatures << 25.5 << 26.0 << 24.8 << 27.1;

    printListInReverse(temperatures);

    // const_reverse_iterator を直接使用する例
    qDebug() << "\n--- Direct const_reverse_iterator use ---";
    for (QList<double>::const_reverse_iterator it = temperatures.crbegin(); it != temperatures.crend(); ++it) {
        // *it = 30.0; // コンパイルエラー: 読み取り専用のイテレータなので変更できない
        qDebug() << *it;
    }

    return 0;
}

出力

--- Printing a const list in reverse ---
27.1
24.8
26
25.5

--- Direct const_reverse_iterator use ---
27.1
24.8
26
25.5

const QList オブジェクトに対して rbegin() / rend() を呼び出した場合も、自動的に const_reverse_iterator が返されます。
const_reverse_iterator を使用すると、イテレータが指す要素の値を変更しようとするとコンパイルエラーになるため、誤ってデータを変更するのを防ぐことができます。
data.crbegin() と data.crend() は、const_reverse_iterator を返します。

インデックスベースの逆順ループ (最も一般的で安全)

説明
QList は配列のようなアクセス (operator[] や at()) をサポートしているため、リストの末尾から先頭に向かってインデックスを減らしながらループを回すことができます。

メリット

効率的
QList のランダムアクセスは効率的です。
理解しやすい
C++や他の言語で配列を扱う経験があれば、直感的に理解できます。
最も安全
ループ中に要素の追加や削除を行っても、イテレータの無効化を心配する必要がありません。特に要素の削除は、イテレータベースの方法よりも格段に簡単で安全です。

デメリット

イテレータの抽象化されたインターフェース（++it や *it）を使用しないため、汎用的なアルゴリズムには直接適用しにくい場合があります。

コード例

#include <QList>
#include <QDebug>

int main() {
    QList<int> numbers = {10, 20, 30, 40, 50};

    qDebug() << "--- Index-based reverse loop ---";
    // インデックスは size() - 1 から 0 まで減少させる
    for (int i = numbers.size() - 1; i >= 0; --i) {
        qDebug() << numbers.at(i); // あるいは numbers[i]
    }

    // 削除を含む例 (非常に安全)
    QList<QString> items = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};
    qDebug() << "\nOriginal items:" << items;

    for (int i = items.size() - 1; i >= 0; --i) {
        if (items.at(i).startsWith("B") || items.at(i).startsWith("D")) {
            qDebug() << "Removing:" << items.at(i);
            items.removeAt(i); // 安全に要素を削除
        }
    }
    qDebug() << "Items after removal:" << items;

    return 0;
}

出力

--- Index-based reverse loop ---
50
40
30
20
10

Original items: QList("Apple", "Banana", "Cherry", "Date", "Elderberry")
Removing: Date
Removing: Banana
Items after removal: QList("Apple", "Cherry", "Elderberry")

std::reverse と QList::begin()/end() (STLアルゴリズムの利用)

説明
QList はSTL互換のイテレータ (begin(), end()) を提供しているため、標準C++ライブラリのアルゴリズムを適用できます。std::reverse を使うと、リスト全体の要素をその場で逆順に並べ替えることができます。

メリット

標準的
C++の標準ライブラリの知識が活かせます。
簡潔なコード
リスト全体を逆順にする場合は非常にシンプルです。

デメリット

イテレーションではない
特定の条件で要素を処理しながら逆順に「走査」するのには向いていません。リスト全体を逆転させるためのものです。
インプレース変更
元のリストの順序が変更されます。元の順序を保持したい場合は、先にコピーを作成する必要があります。

コード例

#include <QList>
#include <QDebug>
#include <algorithm> // std::reverse を使うために必要

int main() {
    QList<int> numbers = {1, 2, 3, 4, 5};

    qDebug() << "Original numbers:" << numbers;

    // QList の要素をその場で逆順に並べ替える
    std::reverse(numbers.begin(), numbers.end());

    qDebug() << "Reversed numbers (in-place):" << numbers;

    // 元のリストを保持したい場合は、コピーを作成してから reverse
    QList<double> data = {1.1, 2.2, 3.3};
    QList<double> reversedData = data; // コピーを作成
    std::reverse(reversedData.begin(), reversedData.end());

    qDebug() << "Original data:" << data;
    qDebug() << "Reversed data (copy):" << reversedData;

    return 0;
}

出力

Original numbers: QList(1, 2, 3, 4, 5)
Reversed numbers (in-place): QList(5, 4, 3, 2, 1)
Original data: QList(1.1, 2.2, 3.3)
Reversed data (copy): QList(3.3, 2.2, 1.1)

説明
QListIterator<T> は、Qtが提供する旧来のイテレータクラスで、特に前方走査に特化しています。しかし、逆順イテレーションのためには toBack() と hasPrevious() / previous() を使用できます。

メリット

QtのAPIに統一
Qtらしいイテレータの使い方です。
読み取り専用で安全
リストの内容を変更しない場合に利用します。

デメリット

Qt 6以降では、C++11の範囲ベースforループやSTL互換のイテレータが推奨されており、QListIterator はあまり推奨されません。
reverse_iterator やインデックスベースのループに比べて、逆順イテレーションの表現が若干回りくどいです。
書き込み不可
要素の追加や削除はできません。

コード例

#include <QList>
#include <QDebug>
#include <QListIterator> // QListIterator を使うために必要

int main() {
    QList<char> chars = {'a', 'b', 'c', 'd', 'e'};

    qDebug() << "--- Using QListIterator for reverse iteration ---";
    QListIterator<char> it(chars);

    it.toBack(); // イテレータをリストの末尾の「1つ後」に移動させる
                 // (toBack() は QList::end() と似た位置に移動)

    // hasPrevious() が true の間、previous() で前の要素に進む
    while (it.hasPrevious()) {
        qDebug() << it.previous(); // previous() は要素を返し、イテレータを前に移動
    }

    return 0;
}

--- Using QListIterator for reverse iteration ---
'e'
'd'
'c'
'b'
'a'

読み取り専用で逆順に走査し、reverse_iteratorの概念を避けたい場合
QListIterator の toBack() と previous() を使うことも可能ですが、現在のQtのスタイルとしてはreverse_iterator (rbegin()/rend()) を使うか、インデックスベースのループの方が一般的です。
リスト全体を物理的に逆順にしたい場合
std::reverse(list.begin(), list.end()) が簡潔で効率的です。ただし、元のリストが変更されることに注意してください。
要素の追加・削除を伴う逆順処理の場合
インデックスベースの逆順ループ (for (int i = list.size() - 1; i >= 0; --i)) が最も推奨されます。安全で理解しやすいため、これが第一の選択肢となるでしょう。

QList::back()でクラッシュ回避！Qtプログラミングでのよくあるエラーと解決策

Qtプログラミングにおける QList::back() は、QList コンテナの末尾の要素への参照を返すメソッドです。具体的に <T>::reference QList::back() が意味するところは以下の通りです。QList::back(): QList クラスのメンバー関数 back() を呼び出していることを示します。

【Qtプログラミング】QList::begin()の代替手段と最適なイテレーション方法

Qtプログラミングにおける QList::begin() は、QList コンテナの最初の要素を指すイテレータを返す関数です。もう少し詳しく見ていきましょう。QList<T> はQtが提供するジェネリックコンテナクラスの一つで、リストを表現します。C++の std::vector や std::list のようなもので、動的に要素を追加・削除できるリストです。<T> はテンプレート引数で、リストが格納する要素の型を示します。例えば、QList<int> は整数のリスト、QList<QString> は文字列のリストを表します。

QList::capacity()

もう少し詳しく説明します。QListは、要素が追加されるたびにその都度メモリを確保するのではなく、効率のためにある程度の「余裕」を持ってメモリを確保します。これは、要素が一つ追加されるたびにメモリの再割り当て（再確保）が行われると、パフォーマンスが低下する可能性があるためです。

QList cbegin(): Qtプログラミングにおける定数イテレータの活用法

QList<T>::const_iterator QList::cbegin() は、Qt フレームワークにおける QList クラスの非常に便利なメンバー関数です。これを理解するために、いくつかの要素に分けて説明します。QList<T>: まず、「QList<T>」は、Qt が提供するジェネリックなリストコンテナクラスです。T は型パラメータを表し、リストが保持する要素の型を指定します。例えば、QList<int> は整数のリスト、QList<QString> は文字列のリストを意味します。QList は要素を連続的に格納し、高速なランダムアクセスと前後のイテレーションをサポートします。

<T>::reverse_iterator QList::rend()

QList とイテレータの基本

イテレータの無効化 (Iterator Invalidation)

空の QList でのイテレータ操作

イテレータの範囲外アクセス

Q_FOREACH (Qt 5以前) と reverse_iterator

std::reverse_iterator と QList::reverse_iterator の混同

例1: QList の要素を逆順に表示する基本的な例

例2: QList を逆順にコピーして新しいリストを作成する

例3: QList の要素を逆順で条件付きで変更する（非推奨/注意が必要な方法）

インデックスベースの逆順ループ (最も一般的で安全)

std::reverse と QList::begin()/end() (STLアルゴリズムの利用)

例1: `QList` の要素を逆順に表示する基本的な例

例2: `QList` を逆順にコピーして新しいリストを作成する

例3: `QList` の要素を逆順で条件付きで変更する（非推奨/注意が必要な方法）