Qt QList::resize()徹底解説：C++でのサイズ変更と注意点

2025-06-06

`void QList::resize(int size)` とは

QList は Qt が提供する汎用コンテナクラスの一つで、要素のリストを管理するために使われます。void QList::resize(int size) は、この QList のサイズを size で指定された新しいサイズに変更するための関数です。

size が現在のリストのサイズより小さい場合
- リストは size で指定された要素数に縮小されます。
- リストの末尾から、余分な要素が削除されます。削除された要素のデストラクタが呼び出されます。
size が現在のリストのサイズより大きい場合
- リストは size で指定された要素数まで拡張されます。
- 新しく追加された要素は、デフォルトコンストラクタで構築された値で初期化されます。
- もし要素の型がデフォルトコンストラクタを持たない場合、この関数は使用できません（Qt 6 からは QList と QVector が統合され、デフォルトコンストラクタの要件が緩和されていますが、古いQtバージョンでは注意が必要です）。

`QList` と `QVector` の `resize()` の違い（特にQt 5以前）

歴史的に、Qt 5 以前の QList と QVector は内部実装が異なり、resize() の振る舞いにも違いがありました。

QList::resize() (Qt 5 以前)
QList は内部的にはポインタの配列（あるいは、より複雑なデータ構造）として実装されており、各要素はヒープ上に個別に割り当てられます。このため、Qt 5 以前の QList には resize() メソッドが直接提供されていませんでした。これは、QList がデフォルトコンストラクタを持たない型を格納できるという特性と関連しています。もし resize() が存在し、新しい要素が自動的に追加される場合、その要素をどのように構築すればよいかという問題が生じるためです。
- Qt 5 以前で QList のサイズを調整したい場合は、append() や removeLast() などを手動で呼び出して要素を追加・削除する必要がありました。
- あるいは、一度 QVector に変換してから resize() し、再度 QList に戻すといった workaround が用いられることもありました。
QVector::resize()
QVector は要素を連続したメモリ領域に格納します。そのため、resize() を呼び出すと、新しいサイズに合わせてメモリの再割り当て（reallocation）が発生する可能性があります。サイズを大きくした場合、新しく追加される要素はデフォルトコンストラクタで初期化されます。

Qt 6 以降の `QList::resize()`

Qt 6 では、QList と QVector が内部的に統合され、両者とも resize() 関数を持つようになりました。 これにより、QList も QVector と同様に、resize() を使って簡単にサイズを変更できるようになりました。新しく追加される要素は、要素の型がデフォルトコンストラクタを持つ必要があります。

#include <QList>
#include <QDebug>

int main() {
    QList<int> myList;

    // リストに要素を追加
    myList << 10 << 20 << 30;
    qDebug() << "初期サイズ:" << myList.size(); // 出力: 初期サイズ: 3
    qDebug() << "初期リスト:" << myList;       // 出力: 初期リスト: (10, 20, 30)

    // サイズを5に拡張
    // 新しい要素はintのデフォルト値である0で初期化される
    myList.resize(5);
    qDebug() << "resize(5)後サイズ:" << myList.size(); // 出力: resize(5)後サイズ: 5
    qDebug() << "resize(5)後リスト:" << myList;       // 出力: resize(5)後リスト: (10, 20, 30, 0, 0)

    // サイズを2に縮小
    // 末尾の3つの要素が削除される
    myList.resize(2);
    qDebug() << "resize(2)後サイズ:" << myList.size(); // 出力: resize(2)後サイズ: 2
    qDebug() << "resize(2)後リスト:" << myList;       // 出力: resize(2)後リスト: (10, 20)

    // サイズを0に縮小（全クリア）
    myList.resize(0);
    qDebug() << "resize(0)後サイズ:" << myList.size(); // 出力: resize(0)後サイズ: 0
    qDebug() << "resize(0)後リスト:" << myList;       // 出力: resize(0)後リスト: ()

    return 0;
}

Qt 5 以前の QList にはこの resize() 関数は直接提供されていませんでしたが、Qt 6 以降では QVector と統合されたことで利用可能になりました。
サイズを小さくすると、余分な要素は末尾から削除されます。
サイズを大きくすると、新しく追加される要素はデフォルトコンストラクタで初期化されます。
QList::resize(int size) は、QList の要素数を指定された size に変更する関数です。

QList::resize() は、特に Qt 5 以前のバージョンと Qt 6 以降のバージョンでその振る舞いや利用可能性が大きく異なるため、この違いを理解することが重要です。

Qt 5 以前のバージョンでの resize() の欠如

エラー/問題
Qt 5 (またはそれ以前) を使用している場合、QList に resize() メソッドが存在しないため、コンパイルエラーになります。

一般的なエラーメッセージ例

error: 'class QList<int>' has no member named 'resize'

トラブルシューティング

手動でのサイズ調整 (Qt 5以前の QList)
QList を使い続けたい場合は、append() や removeLast() をループで回すなどして、手動でサイズを調整する必要があります。これは非効率な場合が多いです。
```
#include <QList>
#include <QDebug>

int main() {
    QList<int> myList;
    myList << 10 << 20 << 30;

    int newSize = 5;
    while (myList.size() < newSize) {
        myList.append(int()); // デフォルト値で追加
    }
    while (myList.size() > newSize) {
        myList.removeLast();
    }
    qDebug() << myList;
    return 0;
}
```
注意点: この方法で追加される要素は、要素の型がデフォルトコンストラクタを持つ必要があります。QList は元々デフォルトコンストラクタを持たない型を格納できることが特徴の一つでしたが、この方法ではそのメリットを活かせません。
QVector の使用を検討
QList::resize() と同等の動作を求めるのであれば、QVector を使うことを検討してください。QVector は元々 resize() を持っており、要素が連続したメモリに格納されるため、インデックスアクセスが高速です。
```
#include <QVector>
#include <QDebug>

int main() {
    QVector<int> myVector;
    myVector << 10 << 20 << 30;
    myVector.resize(5); // QVectorではresizeが利用可能
    qDebug() << myVector; // (10, 20, 30, 0, 0)
    return 0;
}
```
Qt 6 以降へのアップグレード
最も推奨される解決策です。Qt 6 以降では QList と QVector が統合され、QList も resize() をサポートするようになりました。

デフォルトコンストラクタを持たない型での resize() (Qt 6 以降も含む)

エラー/問題
QList::resize() は、リストのサイズを拡張する際に新しく追加される要素をその型のデフォルトコンストラクタで初期化します。もし、格納している型がデフォルトコンストラクタを持たない場合、コンパイルエラーになります。

一般的なエラーメッセージ例

error: no matching function for call to 'MyClass::MyClass()'

または、resize 関数内で暗黙的に呼ばれるコンストラクタに関するエラー。

トラブルシューティング

resize() の使用を避ける
デフォルトコンストラクタを追加できない、または追加したくない場合は、resize() の使用を避け、要素を明示的に構築して append() するなど、他の方法で要素を追加します。

class MyClass {
public:
    int value;
    // デフォルトコンストラクタがない
    MyClass(int val) : value(val) {}
    friend QDebug operator<<(QDebug debug, const MyClass& obj) {
        debug << "MyClass(" << obj.value << ")";
        return debug;
    }
};

QList<MyClass> myList;
myList.append(MyClass(1));
myList.append(MyClass(2));
myList.append(MyClass(3));

// resize(5) は使えない
// 必要な数だけ手動で追加
myList.append(MyClass(0)); // 新しく追加する要素の値を明示的に指定
myList.append(MyClass(0));

デフォルトコンストラクタを追加する
最も直接的な解決策です。

class MyClass {
public:
    int value;
    // デフォルトコンストラクタ
    MyClass() : value(0) {}
    // 他のコンストラクタ
    MyClass(int val) : value(val) {}
    // QDebugで表示するためのオペレータ（デバッグ用）
    friend QDebug operator<<(QDebug debug, const MyClass& obj) {
        debug << "MyClass(" << obj.value << ")";
        return debug;
    }
};

QList<MyClass> myList;
myList.resize(5); // これで動く

不適切なサイズ指定によるロジックエラー

エラー/問題
resize(int size) に負の値や非常に大きな値を渡すと、意図しない動作やメモリ関連の問題を引き起こす可能性があります。負の値は Qt の実装によってはアサーションエラーや未定義の動作につながります。非常に大きな値は、大量のメモリ確保を試み、メモリ不足(OOM: Out Of Memory)を引き起こす可能性があります。

トラブルシューティング

メモリ使用量の監視
特に組み込みシステムやメモリが限られた環境では、大きな QList を resize() する際にメモリ使用量に注意してください。QList (特に Qt 6以降の統合された実装) は QVector と同様に、必要に応じてメモリを再割り当てする可能性があるため、頻繁に大きく resize() するとパフォーマンスに影響を与える可能性もあります。

入力値の検証
resize() に渡す size が常に0以上であることを確認します。ユーザー入力や計算結果を使用する場合は特に重要です。

int desiredSize = getUserInput(); // または計算結果
if (desiredSize >= 0) {
    myList.resize(desiredSize);
} else {
    qWarning() << "Invalid size for resize: " << desiredSize;
    // エラーハンドリング
}

要素のデストラクタの呼び出しタイミング

エラー/問題
resize() でリストのサイズを縮小した場合、削除される要素のデストラクタが呼び出されます。もし、リストが所有するポインタ（例: QList<MyObject*>）を格納していて、それらのオブジェクトがヒープ上に確保されている場合、resize() ではそのポインタが削除されるだけで、指しているオブジェクトは削除されません。これによりメモリリークが発生します。

トラブルシューティング

手動での解放
スマートポインタを使えない、または使いたくない場合は、resize() を呼び出す前に、削除される予定の要素をループなどで回って手動で解放する必要があります。

QList<MyObject*> objectList;
objectList.append(new MyObject(1));
objectList.append(new MyObject(2));
objectList.append(new MyObject(3));

int newSize = 1;
while (objectList.size() > newSize) {
    delete objectList.last(); // 手動でオブジェクトを削除
    objectList.removeLast(); // リストからポインタを削除
}
objectList.resize(newSize); // もしくは単純にサイズを調整

スマートポインタの利用
QSharedPointer や QPointer などのスマートポインタを使用して、オブジェクトのライフサイクルを管理します。これにより、QList から要素が削除されたときに、自動的にオブジェクトが解放されるようになります。

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

class MyObject {
public:
    int id;
    MyObject(int i) : id(i) { qDebug() << "MyObject(" << id << ") created"; }
    ~MyObject() { qDebug() << "MyObject(" << id << ") destroyed"; }
};

int main() {
    QList<QSharedPointer<MyObject>> objectList;
    objectList.append(QSharedPointer<MyObject>(new MyObject(1)));
    objectList.append(QSharedPointer<MyObject>(new MyObject(2)));
    objectList.append(QSharedPointer<MyObject>(new MyObject(3)));

    qDebug() << "リストサイズ変更前:" << objectList.size();
    objectList.resize(1); // サイズを縮小

    qDebug() << "リストサイズ変更後:" << objectList.size();
    // ここでMyObject(2)とMyObject(3)のデストラクタが自動的に呼び出される
    return 0;
}

パフォーマンスに関する考慮事項

問題
resize() は、リストが大きく拡張される場合にメモリの再割り当てを伴うことがあり、これがパフォーマンスのボトルネックになる可能性があります。特に、頻繁に resize() を繰り返す場合や、大量の要素を扱う場合に顕著です。

最適なコンテナの選択
- 頻繁な中央への挿入/削除が必要な場合は QList (ただし、resize() の効率は劣る)。
- 連続したメモリ配置と高速なインデックスアクセスが必要な場合は QVector (特にQt 5以前)。
- Qt 6以降では、QListとQVectorの内部実装が似ているため、以前ほどの厳密な使い分けは不要ですが、インデックスアクセスが主で、大幅なサイズ変更が頻繁でない場合はQVectorの方が依然として適している場合があります。
reserve() の活用
リストの最大サイズがおおよそ分かっている場合、事前に reserve() を呼び出して必要なメモリを確保しておくことで、後続の resize() や append() での再割り当ての回数を減らし、パフォーマンスを向上させることができます。
```
QList<int> myList;
myList.reserve(10000); // 10000個分のメモリを事前に確保
myList.resize(5000);   // その範囲内でresize
```

QList::resize() は、QList の要素数を変更するための非常に便利な関数です。特に Qt 6 以降では QList と QVector が統合されたことで、より直感的に利用できるようになりました。

ここでは、いくつかの具体的な使用例を挙げ、その挙動と注意点を解説します。

例1：基本的な `resize()` の使用

リストのサイズを拡張したり、縮小したりする最も基本的な例です。

#include <QList>
#include <QDebug> // コンソール出力用

int main() {
    QList<int> myList;

    qDebug() << "--- 初期状態 ---";
    qDebug() << "サイズ:" << myList.size(); // 0
    qDebug() << "内容:" << myList;         // ()

    // 1. 要素を追加してサイズを増やす
    myList << 10 << 20 << 30;
    qDebug() << "\n--- 要素追加後 ---";
    qDebug() << "サイズ:" << myList.size(); // 3
    qDebug() << "内容:" << myList;         // (10, 20, 30)

    // 2. resize() でサイズを拡張する
    // 現在のサイズ (3) より大きい 5 に変更
    // 新しい要素 (インデックス 3 と 4) は int のデフォルト値 (0) で初期化される
    myList.resize(5);
    qDebug() << "\n--- resize(5) で拡張後 ---";
    qDebug() << "サイズ:" << myList.size(); // 5
    qDebug() << "内容:" << myList;         // (10, 20, 30, 0, 0)

    // 3. resize() でサイズを縮小する
    // 現在のサイズ (5) より小さい 2 に変更
    // 末尾の要素 (インデックス 2, 3, 4) が削除される
    myList.resize(2);
    qDebug() << "\n--- resize(2) で縮小後 ---";
    qDebug() << "サイズ:" << myList.size(); // 2
    qDebug() << "内容:" << myList;         // (10, 20)

    // 4. resize() でリストをクリアする (サイズを0にする)
    myList.resize(0);
    qDebug() << "\n--- resize(0) でクリア後 ---";
    qDebug() << "サイズ:" << myList.size(); // 0
    qDebug() << "内容:" << myList;         // ()

    return 0;
}

解説

myList.resize(0); はリストを完全にクリアする効果があります。
myList.resize(2); のように現在のサイズより小さい値を指定すると、末尾の要素が削除されます。削除された要素のデストラクタは呼び出されます（ただし、int のようなプリミティブ型にはデストラクタはありません）。
myList.resize(5); のように現在のサイズより大きい値を指定すると、不足分の要素が追加されます。この際、追加される要素は格納されている型（ここでは int）のデフォルトコンストラクタで初期化されます。int のデフォルト値は 0 です。

例2：カスタムクラスと `resize()`

カスタムクラスを QList に格納し、resize() を使う場合の例です。特に、デフォルトコンストラクタの重要性がわかります。

#include <QList>
#include <QDebug>

// カスタムクラスの定義
class MyItem {
public:
    int id;

    // 必須: resize() で拡張する際に必要となるデフォルトコンストラクタ
    MyItem() : id(0) {
        qDebug() << "MyItem::MyItem() - ID:" << id;
    }

    // 通常のコンストラクタ
    MyItem(int val) : id(val) {
        qDebug() << "MyItem::MyItem(int) - ID:" << id;
    }

    // デストラクタ (要素が削除されるときに呼ばれることを確認するため)
    ~MyItem() {
        qDebug() << "MyItem::~MyItem() - ID:" << id;
    }

    // QDebug で出力するためのオーバーロード (オプションだが便利)
    friend QDebug operator<<(QDebug debug, const MyItem& item) {
        QDebugStateSaver saver(debug); // 出力フォーマットを保存・復元
        debug.nospace() << "MyItem(" << item.id << ")";
        return debug;
    }
};

int main() {
    QList<MyItem> myItemList;

    qDebug() << "\n--- 要素追加 ---";
    myItemList.append(MyItem(100));
    myItemList.append(MyItem(200));
    qDebug() << "現在のリスト:" << myItemList; // (MyItem(100), MyItem(200))

    qDebug() << "\n--- resize(4) で拡張 ---";
    // 新しく追加される MyItem (ID 0) のデフォルトコンストラクタが2回呼ばれる
    myItemList.resize(4);
    qDebug() << "拡張後のリスト:" << myItemList; // (MyItem(100), MyItem(200), MyItem(0), MyItem(0))

    qDebug() << "\n--- resize(1) で縮小 ---";
    // MyItem(0) のデストラクタが2回、MyItem(200) のデストラクタが1回呼ばれる
    myItemList.resize(1);
    qDebug() << "縮小後のリスト:" << myItemList; // (MyItem(100))

    qDebug() << "\n--- main関数終了 ---";
    // myItemList がスコープを抜ける際に、残りの MyItem(100) のデストラクタが呼ばれる
    return 0;
}

解説

resize(1) を実行すると、現在のサイズ4から1に縮小されるため、3つの MyItem オブジェクトがリストの末尾から削除されます。この際、それぞれの MyItem オブジェクトのデストラクタ ~MyItem() が呼び出されていることが出力から確認できます。
resize(4) を実行すると、現在のサイズ2から4に拡張されるため、2つの新しい MyItem オブジェクトがリストの末尾に追加されます。これらはデフォルトコンストラクタ MyItem() で id が 0 に初期化されます。
MyItem クラスは、引数なしのデフォルトコンストラクタ MyItem() を持っています。これが無い場合、resize() でリストを拡張しようとするとコンパイルエラーになります。

例3：ポインタ型と `resize()` (メモリリークの危険性)

QList に生のポインタを格納している場合の resize() の挙動と、それに伴うメモリリークの危険性についてです。

#include <QList>
#include <QDebug>

class MyRawItem {
public:
    int id;
    MyRawItem(int val) : id(val) {
        qDebug() << "MyRawItem(" << id << ") created";
    }
    ~MyRawItem() {
        qDebug() << "MyRawItem(" << id << ") destroyed";
    }
};

int main() {
    QList<MyRawItem*> myRawItemList; // 生のポインタのリスト

    qDebug() << "\n--- 要素追加 (生ポインタ) ---";
    myRawItemList.append(new MyRawItem(10)); // ヒープにオブジェクトを確保
    myRawItemList.append(new MyRawItem(20));
    myRawItemList.append(new MyRawItem(30));
    qDebug() << "現在のリストサイズ:" << myRawItemList.size();

    qDebug() << "\n--- resize(1) で縮小 (メモリリークに注意!) ---";
    // ここで MyRawItem(20) と MyRawItem(30) のポインタがリストから削除される
    // しかし、それらのポインタが指していたヒープ上のMyRawItemオブジェクトは解放されない！
    myRawItemList.resize(1);
    qDebug() << "縮小後のリストサイズ:" << myRawItemList.size();

    qDebug() << "\n--- 残りの要素を手動で解放 ---";
    // 残った MyRawItem(10) のポインタがリストに残っているので、これも手動で解放
    for (MyRawItem* item : myRawItemList) {
        delete item; // 残ったオブジェクトを解放
    }
    myRawItemList.clear(); // ポインタをリストから削除 (これは必須ではないが、良い習慣)

    qDebug() << "\n--- main関数終了 ---";
    return 0;
}

解説

解決策
- スマートポインタを使用する (推奨)
  QSharedPointer<MyRawItem> や QScopedPointer<MyRawItem> などのスマートポインタを使用すれば、QList からポインタが削除されるときに、自動的に指しているオブジェクトも解放されます。
- 手動で解放する
  resize() を呼び出す前に、削除されるポインタが指すオブジェクトを delete する必要があります。例では main 関数終了時に残った要素を解放していますが、resize() する直前に行うべきです。
この結果、MyRawItem(20) と MyRawItem(30) はメモリ上に残り続け、アクセスできなくなるためメモリリークが発生します。
myRawItemList.resize(1); を実行すると、リストからポインタ MyRawItem*(20) と MyRawItem*(30) が削除されます。しかし、これらのポインタが指しているヒープ上の MyRawItem オブジェクト自体は削除されません（デストラクタ ~MyRawItem() が呼ばれない）。
QList<MyRawItem*> は、MyRawItem オブジェクトそのものではなく、そのポインタを格納しています。

例4：スマートポインタと `resize()`

メモリリークの問題を解決するために、スマートポインタ (QSharedPointer) を使用する例です。

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

class MySmartItem {
public:
    int id;
    MySmartItem(int val) : id(val) {
        qDebug() << "MySmartItem(" << id << ") created";
    }
    ~MySmartItem() {
        qDebug() << "MySmartItem(" << id << ") destroyed";
    }
};

int main() {
    QList<QSharedPointer<MySmartItem>> mySmartItemList; // スマートポインタのリスト

    qDebug() << "\n--- 要素追加 (スマートポインタ) ---";
    mySmartItemList.append(QSharedPointer<MySmartItem>(new MySmartItem(10)));
    mySmartItemList.append(QSharedPointer<MySmartItem>(new MySmartItem(20)));
    mySmartItemList.append(QSharedPointer<MySmartItem>(new MySmartItem(30)));
    qDebug() << "現在のリストサイズ:" << mySmartItemList.size();

    qDebug() << "\n--- resize(1) で縮小 (メモリ安全) ---";
    // QSharedPointer のデストラクタが呼ばれ、参照カウントが0になるため
    // MySmartItem(20) と MySmartItem(30) のデストラクタが自動的に呼ばれる
    mySmartItemList.resize(1);
    qDebug() << "縮小後のリストサイズ:" << mySmartItemList.size();

    qDebug() << "\n--- main関数終了 ---";
    // 残りの MySmartItem(10) のデストラクタが、mySmartItemList がスコープを抜ける際に呼ばれる
    return 0;
}

解説

これにより、resize() を使ったポインタリストの縮小時に発生するメモリリークの問題が解決されます。
mySmartItemList.resize(1); を実行すると、リストから QSharedPointer オブジェクトが削除されます。この際、QSharedPointer のデストラクタが呼ばれ、それが管理している MySmartItem オブジェクトの参照カウントが0になるため、自動的に MySmartItem(20) と MySmartItem(30) のデストラクタが呼び出され、メモリが解放されます。
QList<QSharedPointer<MySmartItem>> は、MySmartItem のスマートポインタを格納します。

QList::resize() は、QList のサイズを動的に変更するための強力なツールです。

Qtのバージョン
特に Qt 5 以前では QList に resize() が存在しないため、QVector を使うか、手動でサイズ調整を行う必要がありました。Qt 6 以降では QList と QVector が統合され、QList も resize() をサポートします。
ポインタ型
生のポインタを使うとメモリリークの危険性があるため、スマートポインタ (QSharedPointer など) の使用を強く推奨します。
カスタムクラス
拡張時にはデフォルトコンストラクタが必須です。
基本的な振る舞い
サイズを拡張するとデフォルトコンストラクタで初期化され、縮小すると要素が削除されます。

QList::resize() の代替手段は、主に「サイズを拡張するケース」と「サイズを縮小するケース」で異なります。また、Qt のバージョン（特に Qt 5 以前と Qt 6 以降）によっても考慮事項が変わります。

サイズを拡張する代替方法

resize() でサイズを拡張する場合、新しい要素はデフォルトコンストラクタで初期化されます。これを避けたい場合や、特定の値を設定したい場合の代替です。

方法1-1: `append()` をループで使う

新しい要素を個別に構築して追加する場合に最も一般的です。

#include <QList>
#include <QDebug>

int main() {
    QList<int> myList;
    myList << 10 << 20 << 30;

    int targetSize = 5;

    // 現在のサイズが目標サイズより小さい場合、ループで追加
    while (myList.size() < targetSize) {
        myList.append(0); // 例えば、0 を追加
        // または、特定の値を計算して追加することも可能
        // myList.append(myList.size() * 100);
    }

    qDebug() << "拡張後のリスト:" << myList; // (10, 20, 30, 0, 0)
    return 0;
}

利点

Qt のどのバージョンでも利用できます。
デフォルトコンストラクタを持たないカスタム型でも、手動でオブジェクトを構築して追加できます。
追加する各要素の値を明示的に制御できます。

欠点

append() は場合によってはリストの内部構造を再編成するため、頻繁に呼び出すとパフォーマンスが低下する可能性があります（ただし、Qt 6 以降の QList は QVector に似た効率的な実装になっています）。
大量の要素を追加する場合、ループ処理のオーバーヘッドが発生します。

方法1-2: `QVector` を使う (特に Qt 5 以前で `QList` を拡張したい場合)

Qt 5 以前では QList に resize() がなかったため、QVector に変換してから resize() し、必要であれば QList に戻すという方法が使われることがありました。Qt 6 以降では QList も resize() を持つため、この方法は主に古いコードベースでの対応策となります。

#include <QList>
#include <QVector>
#include <QDebug>

int main() {
    QList<int> originalList;
    originalList << 10 << 20 << 30;

    // QList を QVector に変換
    QVector<int> myVector = originalList.toVector();

    // QVector の resize() を使う
    myVector.resize(5); // QList::resize() と同じように、新しく追加された要素はデフォルト値で初期化される

    // 必要であれば QVector から QList に戻す
    QList<int> resizedList = myVector.toList();

    qDebug() << "拡張後のリスト:" << resizedList; // (10, 20, 30, 0, 0)
    return 0;
}

利点

QVector::resize() は通常、append() をループで回すよりも効率的です。
Qt 5 以前で QList を resize() したい場合のワークアラウンドとして機能します。

欠点

データのコピーが発生するため、非常に大きなリストではパフォーマンスが低下する可能性があります。
QList と QVector の間で変換するオーバーヘッドが発生します。

サイズを縮小する代替方法

resize() でサイズを縮小する場合、末尾の要素が削除されます。これを他の方法で行う代替策です。

方法2-1: `removeLast()` または `takeLast()` をループで使う

リストの末尾から要素を削除する場合に、最も直接的な方法です。takeLast() は削除された要素を返し、removeLast() は返しません。

#include <QList>
#include <QDebug>

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

    int targetSize = 2;

    // 現在のサイズが目標サイズより大きい場合、ループで削除
    while (myList.size() > targetSize) {
        myList.removeLast(); // または int lastValue = myList.takeLast();
    }

    qDebug() << "縮小後のリスト:" << myList; // (10, 20)
    return 0;
}

利点

生のポインタを格納しているリストの場合、removeLast() や takeLast() の前に手動で delete を呼び出すことでメモリリークを防げます。

QList<MyObject*> objectList;
// ... 要素を追加 ...
while (objectList.size() > targetSize) {
    delete objectList.last(); // まずオブジェクトを解放
    objectList.removeLast();  // 次にリストからポインタを削除
}

削除される要素を明示的に確認したい場合は takeLast() が便利です。
どの Qt バージョンでも利用できます。

欠点

ループ処理のオーバーヘッドがあります。

方法2-2: `clear()` と `append()` の組み合わせ (完全にクリアする場合)

リストを完全に空にしたい場合は、resize(0) と同じく clear() を使うのが最も簡単です。

#include <QList>
#include <QDebug>

int main() {
    QList<int> myList;
    myList << 10 << 20 << 30;

    // resize(0) と同じ効果
    myList.clear();

    qDebug() << "クリア後のリスト:" << myList; // ()
    return 0;
}

利点

QList の全要素を効率的に削除します。
コードが非常に簡潔です。

欠点

部分的に縮小する用途には使えません。

拡張の場合と同様に、QVector を経由する方法です。

#include <QList>
#include <QVector>
#include <QDebug>

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

    // QList を QVector に変換
    QVector<int> myVector = originalList.toVector();

    // QVector の resize() を使う
    myVector.resize(2);

    // 必要であれば QVector から QList に戻す
    QList<int> resizedList = myVector.toList();

    qDebug() << "縮小後のリスト:" << resizedList; // (10, 20)
    return 0;
}

利点

Qt 5 以前で QList を resize() したい場合のワークアラウンドとして機能します。

欠点

変換のオーバーヘッドが発生します。

3-1: `QVector` を直接使用する

もし、QList の「高速な中央挿入/削除」という特性が必要ないのであれば、最初から QVector を使用することを検討してください。QVector は要素を連続したメモリ領域に格納するため、インデックスアクセスが高速で、resize() の効率も良いです（特に Qt 5 以前では QList の resize() の代替として推奨されました）。Qt 6 以降では両者の実装が統合され、機能的な差は小さくなりましたが、依然としてQVectorの方が特定のユースケースで適している場合があります。

3-2: `reserve()` と `append()` の組み合わせ (初期容量の確保)

将来的に多くの要素を追加することがわかっているが、初期段階で全ての要素をデフォルト値で初期化したくない場合、QList::reserve() を使って事前にメモリを確保し、その後 append() で必要なだけ要素を追加していくことができます。

#include <QList>
#include <QDebug>

int main() {
    QList<QString> myStringList;
    myStringList.reserve(100); // 100個分のメモリを事前に確保（再割り当てを防ぐ）

    // 後から必要な数だけ要素を追加
    myStringList.append("Apple");
    myStringList.append("Banana");
    // ...
    // この場合、resize() とは異なり、初期は空のままでメモリだけ確保される
    qDebug() << "サイズ:" << myStringList.size(); // 2
    qDebug() << "容量:" << myStringList.capacity(); // 少なくとも100
    return 0;
}

利点

初期段階で要素をデフォルト初期化したくない場合に有効です。
大量の要素を追加する際の再割り当てによるパフォーマンス劣化を抑えられます。

resize() のように一括で要素を初期化しながら追加することはできません。

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 は要素を連続的に格納し、高速なランダムアクセスと前後のイテレーションをサポートします。

Qt QList::resize()徹底解説：C++でのサイズ変更と注意点

void QList::resize(int size) とは

QList と QVector の resize() の違い（特にQt 5以前）

Qt 6 以降の QList::resize()

Qt 5 以前のバージョンでの resize() の欠如

デフォルトコンストラクタを持たない型での resize() (Qt 6 以降も含む)

不適切なサイズ指定によるロジックエラー

要素のデストラクタの呼び出しタイミング

パフォーマンスに関する考慮事項

例1：基本的な resize() の使用

例2：カスタムクラスと resize()

例3：ポインタ型と resize() (メモリリークの危険性)

例4：スマートポインタと resize()

サイズを拡張する代替方法

方法1-1: append() をループで使う

方法1-2: QVector を使う (特に Qt 5 以前で QList を拡張したい場合)

サイズを縮小する代替方法

方法2-1: removeLast() または takeLast() をループで使う

方法2-2: clear() と append() の組み合わせ (完全にクリアする場合)

3-1: QVector を直接使用する

3-2: reserve() と append() の組み合わせ (初期容量の確保)

`void QList::resize(int size)` とは

`QList` と `QVector` の `resize()` の違い（特にQt 5以前）

Qt 6 以降の `QList::resize()`

例1：基本的な `resize()` の使用

例2：カスタムクラスと `resize()`

例3：ポインタ型と `resize()` (メモリリークの危険性)

例4：スマートポインタと `resize()`

方法1-1: `append()` をループで使う

方法1-2: `QVector` を使う (特に Qt 5 以前で `QList` を拡張したい場合)

方法2-1: `removeLast()` または `takeLast()` をループで使う

方法2-2: `clear()` と `append()` の組み合わせ (完全にクリアする場合)

3-1: `QVector` を直接使用する

3-2: `reserve()` と `append()` の組み合わせ (初期容量の確保)