【Qtプログラミング】QList::mid() 完全ガイド：コード例で学ぶ正しい使い方

QList::mid() とは

QList::mid() は、Qt のコンテナクラスである QList のメンバー関数で、既存のリストから指定された範囲の要素を含む新しいリストを作成して返します。元のリストは変更されません。

これは、C++ の標準ライブラリの std::vector などには直接的な同等のものがないため、QList を使う上で非常に便利な機能の一つです。

構文

QList::mid() には主に2つのオーバーロードがあります。

1. QList<T> QList::mid(int pos = 0, int length = -1) const

   • pos: 新しいリストの開始位置を示すインデックスです。
     • デフォルト値は 0 で、リストの先頭から開始します。
     • pos がリストのサイズを超える場合、空のリストが返されます。
   • length: 新しいリストに含める要素の数です。
     • デフォルト値は -1 で、この場合、pos からリストの最後まで全ての要素が含まれます。
     • length が指定された場合でも、リストの末尾を超えて要素が取得されることはありません。実際に取得される要素数は、qMin(length, size() - pos) となります。
   • 戻り値: 指定された範囲の要素を含む新しい QList オブジェクト。

動作の例

例えば、QList が [10, 20, 30, 40, 50] という要素を持っているとします。

• list.mid(2, 100): [30, 40, 50] を返します。（length がリストの残り要素数を超えるため、リストの最後まで）
• list.mid(10): [] を返します。（pos がリストのサイズを超えるため空のリスト）
• list.mid(1, 2): [20, 30] を返します。（インデックス1から2つの要素）
• list.mid(2): [30, 40, 50] を返します。（インデックス2からリストの最後まで）
• list.mid(0, 3): [10, 20, 30] を返します。（インデックス0から3つの要素）

使用場面

QList::mid() は、以下のような場面で特に役立ちます。

• サブリストの作成: 元のリストを変更せずに、その一部を使って別の処理を行いたい場合。
• データのページング: 大量のデータを扱う際に、一度に表示するデータ量を制限し、ページごとにデータを抽出する際に便利です。
• リストの一部を抽出する: 特定の範囲のデータのみを処理したい場合に、新しいリストとして簡単に取り出すことができます。

• 元のリストは変更されません。
• QList::mid() は新しいリストを生成するため、大量の要素を持つリストに対して頻繁に呼び出すと、パフォーマンスに影響を与える可能性があります。要素のコピーが発生するためです。

---

インデックスの範囲外アクセス (Out-of-Bounds Access)

エラーの症状
アプリケーションのクラッシュ、予期しない動作、または ASSERT failure in QList<T>::at: "index out of range" のようなメッセージが表示されることがあります。これは QList::mid() 自体が直接このエラーを出すことは稀ですが、mid() の結果として得られたリストを後続で処理する際に発生する可能性があります。

原因
QList::mid(pos, length) を呼び出す際に、pos や pos + length が元のリストの有効なインデックス範囲 (0 から size() - 1) を超えている場合に発生します。QList::mid() は、範囲外の指定があっても空のリストを返したり、可能な限りの要素を返したりするため、直接エラーにはなりにくいですが、その結果のリストを期待どおりに処理しようとすると問題が顕在化します。

例

QList<int> originalList = {10, 20, 30};
QList<int> subList = originalList.mid(5); // posが範囲外 (5 > 2)
// subList は空のリストになる
// その後、subList.at(0) などにアクセスしようとするとクラッシュする可能性がある

トラブルシューティング

• デバッガーの使用
  クラッシュが発生した場合、デバッガーを使ってコールスタックを確認し、どの行でインデックスの問題が発生しているかを特定します。
• 返り値の確認
  mid() が返したリストが空でないか、または期待するサイズを持っているかを確認してから、その要素にアクセスします。

  QList<int> subList = originalList.mid(pos, length);
  if (!subList.isEmpty()) {
      // subList の要素にアクセス
  } else {
      // 空のリストだった場合の処理
  }
  

• 入力値の検証
  mid() を呼び出す前に、pos と length が元のリストのサイズに対して妥当な範囲内にあるかを確認します。

  int pos = ...;
  int length = ...;
  if (pos >= 0 && pos < originalList.size()) {
      QList<int> subList = originalList.mid(pos, length);
      // subList を安全に処理
  } else {
      // エラーハンドリングまたは空のリストとして処理
  }
  

意図しない要素のコピーによるパフォーマンス問題

エラーの症状
アプリケーションの動作が遅くなる、メモリ使用量が増加する、特に大きなリストを繰り返し mid() で処理している場合に顕著です。

原因
QList::mid() は、新しいリストを生成し、元のリストから指定された要素をコピーします。Qt の QList は Implicit Sharing (暗黙的共有) を持っていますが、mid() のような操作は、共有されたデータを「変更」と見なし、完全なディープコピーをトリガーします。つまり、mid() が呼ばれるたびに、指定範囲の要素が新しくメモリに割り当てられ、コピーされるため、オーバーヘッドが発生します。

トラブルシューティング

• 処理の最適化
  
  • 同じ mid() の呼び出しが何度も繰り返される場合、一度だけ mid() で新しいリストを作成し、それを使い回すことを検討します。
  • 必要最小限の要素のみを mid() で取得するように length を適切に設定します。
• データの構造の見直し
  
  • リストの一部への参照（QList<T*> や QVector<T*> など）で十分な場合は、QList にポインタを格納することを検討します。ただし、メモリ管理に注意が必要です。
  • Qt 6 以降では QList と QVector が統合され、QVector が内部実装として推奨されるようになりました。パフォーマンスを重視するなら QVector の使用も検討しましょう。QVector は要素が連続したメモリ領域に配置されるため、特定の操作でより高速になることがあります。
• 本当に新しいリストが必要か再検討
  
  • 単にリストの一部を読み取りたいだけであれば、mid() で新しいリストを作成する代わりに、元のリストのイテレータやインデックスを使って直接アクセスすることを検討します。
  • 例: for (int i = pos; i < pos + length && i < originalList.size(); ++i) { originalList.at(i); }

不適切なメモリ管理 (特にポインタのリストの場合)

エラーの症状
メモリリーク、二重解放 (double free)、または解放済みメモリへのアクセス (use-after-free) によるクラッシュ。

原因
QList<T*> のようにポインタのリストを使用している場合、QList::mid() はポインタ自体をコピーするだけで、ポインタが指すオブジェクトはコピーしません。そのため、複数のリストが同じオブジェクトのポインタを指すことになり、オブジェクトの解放責任が曖昧になります。どちらかのリストが先にオブジェクトを解放してしまうと、もう一方のリストのポインタは無効になり、そのポインタにアクセスすると未定義動作を引き起こします。

例

QList<MyObject*> originalList;
originalList.append(new MyObject()); // オブジェクトをヒープに作成
QList<MyObject*> subList = originalList.mid(0, 1);

// originalList を破棄すると MyObject が解放される
// その後 subList の要素にアクセスしようとするとクラッシュ

トラブルシューティング

• 値セマンティクス
  可能であれば、ポインタのリストではなく、オブジェクト自体を QList に格納することを検討します（例: QList<MyObject>）。QList が自動的にオブジェクトのコピーと破棄を処理してくれます。ただし、これも大きなオブジェクトの場合はコピーのオーバーヘッドに注意が必要です。
• 所有権の明確化
  ポインタを扱う場合、どのリスト（またはどのコード部分）がオブジェクトの所有権を持ち、解放責任を負うのかを明確にします。
• スマートポインタの使用
  QSharedPointer<T> や QScopedPointer<T> などのスマートポインタを QList の要素型として使用することで、オブジェクトのライフサイクル管理を自動化し、メモリリークや二重解放を防ぎます。

  QList<QSharedPointer<MyObject>> originalList;
  originalList.append(QSharedPointer<MyObject>(new MyObject()));
  QList<QSharedPointer<MyObject>> subList = originalList.mid(0, 1);
  // これでオブジェクトは参照カウントで管理される
  

暗黙的共有と予期しないコピー (Copy-on-Write)

エラーの症状
QList::mid() 自体が直接エラーとなるわけではありませんが、mid() から得られたリストと元のリストが予期せず連動して変更されてしまう、またはその逆で、片方を変更してももう片方に影響がない（コピーが発生している）ことで、期待する結果が得られない場合があります。

原因
QList は Implicit Sharing (暗黙的共有、または Copy-on-Write: 書き込み時コピー) という最適化機構を持っています。リストをコピー（例: QList<int> list2 = list1;）しても、最初は内部データが共有されます。しかし、いずれかのリストが非constな操作（要素の追加、削除、変更など）を行うと、その時点でデータの完全なコピーが発生し、共有が解除されます。QList::mid() は常に新しいリストを返すため、元のリストとは独立したデータを持ちます。この挙動が、開発者の期待と異なる場合に混乱を招くことがあります。

• 変更の意図の明確化
  
  • もし、mid() で得られたリストの変更が元のリストにも反映されることを期待しているなら、mid() は不適切です。元のリストの要素を直接操作するか、ポインタ（QList<T*> など）を共有する方法を検討する必要があります（ただし、前述のメモリ管理問題に注意）。
  • 逆に、mid() の結果を操作しても元のリストに影響がないことを期待しているなら、それが正しい挙動です。
• mid() の動作理解
  mid() は常に新しい独立したリストを返すことを理解しておくことが重要です。元のリストと mid() が返したリストは、生成後は互いに影響し合いません。

---

QList::mid() は、既存の QList から指定された範囲の要素を抽出し、新しい QList を作成するのに使われます。元のリストは変更されません。

例 1: 基本的な使い方 - リストの途中から指定数の要素を抽出

この例では、整数のリストから、特定の開始位置から指定された数の要素を抽出します。

#include <QCoreApplication>
#include <QList>
#include <QDebug> // デバッグ出力用

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

    // 元のリストを作成
    QList<int> originalList;
    originalList << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80;

    qDebug() << "元のリスト:" << originalList; // 出力: 元のリスト: QList(10, 20, 30, 40, 50, 60, 70, 80)

    // 例 1.1: インデックス 2 から 3 つの要素を抽出
    // 要素: 30, 40, 50
    QList<int> subList1 = originalList.mid(2, 3);
    qDebug() << "subList1 (pos=2, length=3):" << subList1; // 出力: subList1 (pos=2, length=3): QList(30, 40, 50)

    // 例 1.2: インデックス 5 から 2 つの要素を抽出
    // 要素: 60, 70
    QList<int> subList2 = originalList.mid(5, 2);
    qDebug() << "subList2 (pos=5, length=2):" << subList2; // 出力: subList2 (pos=5, length=2): QList(60, 70)

    // 例 1.3: インデックス 0 (デフォルト) から 4 つの要素を抽出
    // 要素: 10, 20, 30, 40
    QList<int> subList3 = originalList.mid(0, 4);
    qDebug() << "subList3 (pos=0, length=4):" << subList3; // 出力: subList3 (pos=0, length=4): QList(10, 20, 30, 40)

    return a.exec();
}

解説
originalList.mid(pos, length) の形式で呼び出しています。pos は開始インデックス（0から始まる）、length は抽出する要素の数です。

例 2: length パラメータを省略した場合 (残りの要素を全て抽出)

length パラメータを省略すると、pos からリストの最後まで全ての要素が抽出されます。

#include <QCoreApplication>
#include <QList>
#include <QDebug>

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

    QList<QString> fruits;
    fruits << "Apple" << "Banana" << "Cherry" << "Date" << "Elderberry" << "Fig";

    qDebug() << "元のリスト:" << fruits; // 出力: 元のリスト: QList("Apple", "Banana", "Cherry", "Date", "Elderberry", "Fig")

    // 例 2.1: インデックス 3 からリストの最後まで抽出
    // 要素: Date, Elderberry, Fig
    QList<QString> remainingFruits = fruits.mid(3);
    qDebug() << "remainingFruits (pos=3, length=省略):" << remainingFruits; // 出力: remainingFruits (pos=3, length=省略): QList("Date", "Elderberry", "Fig")

    // 例 2.2: インデックス 0 (デフォルト) からリストの最後まで抽出 (リスト全体のコピー)
    // 要素: Apple, Banana, Cherry, Date, Elderberry, Fig
    QList<QString> entireListCopy = fruits.mid();
    qDebug() << "entireListCopy (pos=省略, length=省略):" << entireListCopy; // 出力: entireListCopy (pos=省略, length=省略): QList("Apple", "Banana", "Cherry", "Date", "Elderberry", "Fig")

    return a.exec();
}

解説
fruits.mid(3) のように length を省略すると、インデックス 3 の "Date" からリストの最後の "Fig" までが抽出されます。 fruits.mid() のように pos と length の両方を省略すると、リスト全体のコピーが作成されます。

例 3: 範囲外のインデックス指定と空のリスト

pos がリストのサイズを超えている場合や、length が 0 または負の値で、結果として有効な要素が一つも含まれない場合、mid() は空のリストを返します。

#include <QCoreApplication>
#include <QList>
#include <QDebug>

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

    QList<char> alphabet;
    alphabet << 'a' << 'b' << 'c' << 'd' << 'e';

    qDebug() << "元のリスト:" << alphabet; // 出力: 元のリスト: QList('a', 'b', 'c', 'd', 'e')

    // 例 3.1: pos が範囲外 (サイズ 5 のリストでインデックス 10 は存在しない)
    QList<char> emptyList1 = alphabet.mid(10);
    qDebug() << "emptyList1 (pos=10):" << emptyList1 << ", is empty:" << emptyList1.isEmpty();
    // 出力: emptyList1 (pos=10): QList() , is empty: true

    // 例 3.2: length が 0
    QList<char> emptyList2 = alphabet.mid(1, 0);
    qDebug() << "emptyList2 (pos=1, length=0):" << emptyList2 << ", is empty:" << emptyList2.isEmpty();
    // 出力: emptyList2 (pos=1, length=0): QList() , is empty: true

    // 例 3.3: 指定された length が残りの要素数を超える場合
    // インデックス 2 から 100 個の要素を抽出しようとするが、実際には 'c', 'd', 'e' の 3 つしか存在しない
    QList<char> actualSubList = alphabet.mid(2, 100);
    qDebug() << "actualSubList (pos=2, length=100):" << actualSubList;
    // 出力: actualSubList (pos=2, length=100): QList('c', 'd', 'e')

    return a.exec();
}

解説
mid() は柔軟に動作し、無効なインデックスや長さを指定してもクラッシュせず、可能な限りの結果（多くの場合、空のリスト）を返します。このため、mid() の結果を使用する前に、isEmpty() や size() を確認することが重要です。

例 4: スマートポインタと QList::mid()

QList<T*> のような生ポインタのリストで mid() を使うと、ポインタ自体がコピーされるだけで、指し示すオブジェクトはコピーされないため、メモリ管理に注意が必要です。QSharedPointer を使うと、この問題を回避しやすくなります。

#include <QCoreApplication>
#include <QList>
#include <QDebug>
#include <QSharedPointer> // スマートポインタ用

// 適当なクラス
class MyObject
{
public:
    MyObject(int id) : m_id(id) { qDebug() << "MyObject" << m_id << "が作成されました。"; }
    ~MyObject() { qDebug() << "MyObject" << m_id << "が破棄されました。"; }
    int id() const { return m_id; }
private:
    int m_id;
};

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

    // スマートポインタのリストを作成
    QList<QSharedPointer<MyObject>> originalObjects;
    originalObjects.append(QSharedPointer<MyObject>(new MyObject(1)));
    originalObjects.append(QSharedPointer<MyObject>(new MyObject(2)));
    originalObjects.append(QSharedPointer<MyObject>(new MyObject(3)));
    originalObjects.append(QSharedPointer<MyObject>(new MyObject(4)));

    qDebug() << "元のオブジェクトリストのID:";
    for (const auto& obj : originalObjects) {
        qDebug() << obj->id();
    }

    // mid() で新しいスマートポインタのリストを作成
    // この時、QSharedPointer は参照カウントを増やすだけで、MyObject のインスタンスはコピーされない
    QList<QSharedPointer<MyObject>> subObjects = originalObjects.mid(1, 2);

    qDebug() << "サブオブジェクトリストのID:";
    for (const auto& obj : subObjects) {
        qDebug() << obj->id();
    }

    // 元のリストの要素をクリアしてみる
    // MyObject(1) の参照カウントが 0 になり、破棄される
    // MyObject(2), MyObject(3) は subObjects がまだ参照しているため破棄されない
    // MyObject(4) は originalObjects が唯一の参照なので破棄される
    originalObjects.clear();
    qDebug() << "originalObjects.clear() 後:";

    // subObjects はまだ有効
    qDebug() << "subObjects の要素 (originalObjects.clear() 後):";
    for (const auto& obj : subObjects) {
        qDebug() << obj->id();
    }

    // main 関数終了時、subObjects がスコープを抜ける際に残りのMyObject(2), MyObject(3) が破棄される
    return a.exec();
}

出力例

MyObject 1 が作成されました。
MyObject 2 が作成されました。
MyObject 3 が作成されました。
MyObject 4 が作成されました。
元のオブジェクトリストのID:
1
2
3
4
サブオブジェクトリストのID:
2
3
MyObject 1 が破棄されました。
MyObject 4 が破棄されました。
originalObjects.clear() 後:
subObjects の要素 (originalObjects.clear() 後):
2
3
MyObject 2 が破棄されました。
MyObject 3 が破棄されました。

解説
QSharedPointer を使うことで、QList::mid() で新しいリストを作成しても、MyObject の実体は一つだけで共有され、参照カウントによって適切に管理されることがわかります。これにより、メモリリークや二重解放のリスクを低減できます。

---

QList::mid() は新しい QList オブジェクトを生成し、要素をコピーすることでサブリストを作成します。この「コピー」の動作が、大量のデータを扱う場合や頻繁な呼び出しが必要な場合にパフォーマンスのボトルネックになることがあります。

イテレータを使用する (ループ処理)

いつ使うか

• メモリ割り当てや要素のコピーを避けたい場合。
• サブリストを作成するのではなく、元のリストの特定の部分を読み取り専用で処理したい場合。

説明
QList のイテレータ (QList::const_iterator または QList::iterator) を使用して、指定された範囲の要素を直接ループ処理します。これにより、新しいリストを作成するためのオーバーヘッドがなくなります。

例

#include <QCoreApplication>
#include <QList>
#include <QDebug>

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

    QList<int> originalList = {10, 20, 30, 40, 50, 60, 70, 80};
    qDebug() << "元のリスト:" << originalList;

    int startIndex = 2; // インデックス 2 から開始
    int count = 3;      // 3つの要素を処理

    qDebug() << "イテレータで要素を処理 (インデックス 2 から 3つ):";
    // 開始イテレータを取得
    QList<int>::const_iterator it = originalList.constBegin() + startIndex;
    // 終了インデックスを計算
    QList<int>::const_iterator endIt = originalList.constBegin() + qMin(startIndex + count, originalList.size());

    while (it != endIt) {
        qDebug() << *it; // 要素にアクセス
        ++it;
    }
    // 出力:
    // 30
    // 40
    // 50

    return a.exec();
}

利点

• 大規模なリストの部分的な読み取りに最適です。
• メモリのコピーが発生しないため、非常に効率的です。

欠点

• ループ処理の記述が mid() よりも少し複雑になります。
• 新しい独立したリストが生成されないため、mid() のようにサブリストとして別の関数に渡す場合は不向きです。

QVector と std::copy または QVector::mid() (Qt 6以降)

いつ使うか

• Qt 6以降で、QList の代わりに QVector をメインのコンテナとして使用している場合。
• リストの要素が連続したメモリに配置されていることが重要で、QList の内部構造（ノードベース）がパフォーマンスのボトルネックになる場合。

説明
QVector は要素を連続したメモリブロックに格納するため、アクセス速度が一般的に速く、std::copy との相性が良いです。Qt 6以降では、QList と QVector の内部実装が統合され、QList もほとんどの場合 QVector と同じ連続メモリレイアウトを持つようになりましたが、QVector は依然として多くのシナリオで推奨されます。Qt 6の QVector には mid() メソッドが追加されました。

例 (Qt 6以降の QVector::mid())

#include <QCoreApplication>
#include <QVector>
#include <QDebug>

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

    QVector<double> data = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6};
    qDebug() << "元のQVector:" << data;

    // QVector::mid() は QList::mid() と同様に機能する
    QVector<double> subVector = data.mid(1, 3); // インデックス 1 から 3つの要素
    qDebug() << "subVector (QVector::mid()):" << subVector;
    // 出力: subVector (QVector::mid()): QVector(2.2, 3.3, 4.4)

    return a.exec();
}

例 (std::copy を使用して QList または QVector からサブリストを作成)

#include <QCoreApplication>
#include <QList> // または QVector
#include <QDebug>
#include <algorithm> // std::copy 用
#include <vector>    // 一時的な std::vector 用 (または別の QList/QVector)

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

    QList<QString> names = {"Alice", "Bob", "Charlie", "David", "Eve"};
    qDebug() << "元のリスト:" << names;

    int startIndex = 1;
    int count = 2;
    int actualCount = qMin(count, names.size() - startIndex);

    // 新しい QList を事前に適切なサイズで確保 (オプションだが推奨)
    QList<QString> subNames;
    if (actualCount > 0) {
        subNames.reserve(actualCount); // パフォーマンス最適化
        // std::copy を使用して要素をコピー
        std::copy(names.constBegin() + startIndex,
                  names.constBegin() + startIndex + actualCount,
                  std::back_inserter(subNames)); // QList の場合は back_inserter
    }
    qDebug() << "subNames (std::copy):" << subNames;
    // 出力: subNames (std::copy): QList("Bob", "Charlie")

    return a.exec();
}

利点

• Qt 6の QVector::mid() は QList::mid() と同じ使いやすさを提供します。
• std::copy は非常に効率的なコピー操作を提供します。
• QVector を使用する場合、連続したメモリレイアウトによりキャッシュ効率が向上する可能性があります。

欠点

• QList::mid() と同様に、要素のコピーが発生します。
• std::copy を使用する場合、コピー先のコンテナを事前に確保する必要があります。

部分的なコンテナへの参照 (ポインタやスマートポインタ)

いつ使うか

• 複雑なメモリ管理のリスクを理解している場合。
• 元のリストが変更されない（または変更が適切に同期される）ことが保証される場合。
• 要素のコピーを完全に避けたいが、個々の要素へのランダムアクセスが必要な場合。

説明
新しいリストに、元のリストの要素へのポインタまたはスマートポインタを格納します。これにより、要素自体はコピーされず、ポインタ（参照）のみがコピーされます。これにより、QList::mid() が提供するサブリストの機能に近いものを、コピーオーバーヘッドなしで実現できます。

例 (QSharedPointer を使用)

#include <QCoreApplication>
#include <QList>
#include <QDebug>
#include <QSharedPointer>

class MyData {
public:
    MyData(int val) : value(val) { qDebug() << "MyData" << value << "created."; }
    ~MyData() { qDebug() << "MyData" << value << "destroyed."; }
    int value;
};

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

    // 元のリスト（MyDataオブジェクトへのQSharedPointerを格納）
    QList<QSharedPointer<MyData>> originalData;
    originalData.append(QSharedPointer<MyData>(new MyData(100)));
    originalData.append(QSharedPointer<MyData>(new MyData(200)));
    originalData.append(QSharedPointer<MyData>(new MyData(300)));
    originalData.append(QSharedPointer<MyData>(new MyData(400)));

    qDebug() << "元のリストのデータ:";
    for (const auto& d : originalData) {
        qDebug() << d->value;
    }

    // mid() の代わりに、部分的なスマートポインタリストを作成
    // ポインタのみがコピーされ、MyDataオブジェクト自体はコピーされない
    QList<QSharedPointer<MyData>> subData;
    int startIndex = 1;
    int count = 2;
    int actualCount = qMin(count, originalData.size() - startIndex);

    for (int i = 0; i < actualCount; ++i) {
        subData.append(originalData.at(startIndex + i));
    }

    qDebug() << "サブデータリストのデータ:";
    for (const auto& d : subData) {
        qDebug() << d->value;
    }

    // originalData をクリアしても、subData が参照している MyData オブジェクトは破棄されない
    originalData.clear();
    qDebug() << "originalDataクリア後、subDataのデータ:";
    for (const auto& d : subData) {
        qDebug() << d->value; // まだアクセス可能
    }
    // 出力:
    // MyData 100 destroyed.
    // MyData 400 destroyed.

    // subData がスコープを抜ける時に、MyData 200, MyData 300 が破棄される

    return a.exec();
}

利点

• 元のオブジェクトへの参照を共有するため、一方のリストでオブジェクトが変更されると、もう一方のリストからも変更が反映されます（これは意図しない副作用にもなり得ます）。
• メモリ使用量が削減されます。
• 要素のコピーが発生しないため、非常に高速です。

欠点

• QList や QVector の要素に直接オブジェクトを格納する「値セマンティクス」とは異なる「参照セマンティクス」になります。
• 元のオブジェクトのライフサイクルとサブリストのライフサイクルが密接に結合します。元のオブジェクトが破棄されると、サブリストのポインタは無効になります。
• **メモリ管理が複雑になります。**特に生ポインタを使用する場合、誰がオブジェクトの所有権を持ち、いつ解放すべきかを明確にする必要があります。QSharedPointer などのスマートポインタの使用を強く推奨します。

QList::const_iterator を引数に取る関数

いつ使うか

• QList::mid() で新しいリストを作成して渡すのではなく、イテレータの範囲を直接渡したい場合。
• 特定のアルゴリズムや関数が、リスト全体ではなく、その一部に対してのみ動作する必要がある場合。

説明
関数が QList::const_iterator begin, QList::const_iterator end のペアを引数として受け取るように設計します。これにより、呼び出し側はリストのどの部分を処理したいかを柔軟に指定でき、不必要なコピーを避けることができます。

例

#include <QCoreApplication>
#include <QList>
#include <QDebug>

// リストの指定された範囲の合計を計算する関数
template <typename T>
T calculateSum(typename QList<T>::const_iterator begin,
               typename QList<T>::const_iterator end)
{
    T sum = T(); // 0で初期化
    while (begin != end) {
        sum += *begin;
        ++begin;
    }
    return sum;
}

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

    QList<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    qDebug() << "元のリスト:" << numbers;

    // リストの途中の要素の合計を計算 (例: 3, 4, 5)
    int startIndex = 2;
    int count = 3;
    int actualCount = qMin(count, numbers.size() - startIndex);

    int partialSum = calculateSum(
        numbers.constBegin() + startIndex,
        numbers.constBegin() + startIndex + actualCount
    );
    qDebug() << "インデックス" << startIndex << "から" << actualCount << "個の要素の合計:" << partialSum;
    // 出力: インデックス 2 から 3 個の要素の合計: 12 (3+4+5)

    // リスト全体の合計を計算
    int totalSum = calculateSum(numbers.constBegin(), numbers.constEnd());
    qDebug() << "リスト全体の合計:" << totalSum;
    // 出力: リスト全体の合計: 55

    return a.exec();
}

利点

• 関数のインターフェースがクリーンです。
• コピーオーバーヘッドがありません。
• 非常に汎用性が高く、様々なデータ構造（イテレータをサポートするもの）に対して再利用可能です。

• mid() のように新しいリストを返すわけではないため、ユースケースが限定されます。