Qt QList::fill()徹底解説：基本的な使い方から注意点まで

Qtプログラミングにおける&QList::fill()について

Qtフレームワークにおいて、QList は要素のリストを格納するための汎用コンテナクラスです。QList::fill() は、この QList のインスタンスに特定の値を設定（「埋める」）するためのメソッドです。

&QList::fill() の & は、これがメソッドへのポインタ（または関数ポインタのようなもの）であることを示唆しています。ただし、通常、Qtのコンテキストで&QList::fill()のように単独で記述される場合、それは以下のような状況で使われることが多いです。

1. ドキュメントや説明での言及
   QList クラスが持つ fill() メソッドについて言及する際に、そのクラス名とメソッド名を明示的に示すために使われます。

2. 特定の関数への引数としての指定
   Qtのシグナル＆スロット接続や、より高度なメタプログラミングの文脈で、特定のメソッドを呼び出すための「関数ポインタ」として渡されることがあります。例えば、std::mem_fn や std::bind のようなC++標準ライブラリの機能と組み合わせて、QList のインスタンスに fill() を適用するラムダ関数やファンクタを生成する際などに使われるかもしれません。

3. 誤解の可能性
   もし、QList のオブジェクト名が省略されているのであれば、それは通常、ある特定の QList オブジェクトに対して fill() メソッドを呼び出すことを意図していると解釈されます。

QList::fill() メソッドの実際の使い方

実際のQtコードでは、QList::fill() は以下のように使われます。

#include <QList>
#include <QDebug>

int main() {
    QList<int> myList;

    // リストを10個の要素で初期化し、全て0で埋める
    myList.fill(0, 10); // 10個の0で埋める

    qDebug() << "myList after fill(0, 10):" << myList;
    // 出力例: myList after fill(0, 10): (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

    // 既存のリストの全要素を特定の値で上書きする
    QList<QString> stringList;
    stringList << "apple" << "banana" << "cherry";
    stringList.fill("orange"); // 全ての要素を"orange"で上書き

    qDebug() << "stringList after fill(\"orange\"):" << stringList;
    // 出力例: stringList after fill("orange"): ("orange", "orange", "orange")

    return 0;
}

QList::fill() メソッドのオーバーロード

QList::fill() には複数のオーバーロード（引数の異なる同名の関数）があります。

• void QList::fill(const T &value, int size = -1):
  • value: リストを埋める値。
  • size: リストの新しいサイズ。もしsizeが指定されない（または-1）場合、現在のリストのサイズを保持し、全ての要素をvalueで埋めます。sizeが現在のリストのサイズよりも大きい場合、リストは指定されたサイズにリサイズされ、新しい要素はvalueで初期化されます。sizeが現在のリストのサイズよりも小さい場合、リストは縮小され、残りの要素がvalueで埋められます。

---

Qt QList::fill() に関連する一般的なエラーとトラブルシューティング

QList::fill() は非常に便利なメソッドですが、誤った使い方をすると予期せぬ挙動やエラーにつながることがあります。

ポインタのリストを埋める際の注意点

エラー/問題

QList<MyObject*> のように、オブジェクトへのポインタのリストを fill() で埋める場合、すべてのポインタが同じオブジェクトを指すことになります。これはしばしば意図しない挙動です。

QList<MyObject*> objectPointers;
MyObject* obj = new MyObject();
objectPointers.fill(obj, 5); // 5つの要素がすべて同じ 'obj' を指す
// objectPointers[0] を変更すると、objectPointers[1] なども変更される

トラブルシューティング

リストの各要素が独立した新しいオブジェクトを指すようにしたい場合は、ループを使って明示的に新しいオブジェクトを作成し、リストに追加する必要があります。

QList<MyObject*> objectPointers;
for (int i = 0; i < 5; ++i) {
    objectPointers.append(new MyObject()); // 各要素に新しいMyObjectを割り当てる
}
// または、既存のリストを埋める場合
// objectPointers.resize(5); // 最初にリストのサイズを確保
// for (int i = 0; i < objectPointers.size(); ++i) {
//     objectPointers[i] = new MyObject();
// }

重要な注意
ポインタのリストを扱う場合、メモリリークを防ぐために、リストの要素を使い終えたら delete する責任があります。

コピー可能な型ではないオブジェクト

エラー/問題

QList::fill() は、リストに格納する値がコピー可能 (copy-constructible および assignable) であることを前提としています。QWidget のようなコピーできない、またはコピーが非推奨なオブジェクトを直接 QList に格納しようとすると、コンパイルエラーまたは予期せぬ動作が発生します。

// これはコンパイルエラーになる可能性が高い
// QWidgetはコピーできないため
QList<QWidget> widgetList;
// widgetList.fill(QWidget(), 3); // エラー

トラブルシューティング

このような場合は、オブジェクトへのポインタ (QWidget*) を格納するようにします。

QList<QWidget*> widgetList;
// fill() で直接埋めるのではなく、ループで新しいウィジェットを作成して追加する
for (int i = 0; i < 3; ++i) {
    widgetList.append(new QWidget());
}
// あるいは、既存のウィジェットポインタで埋める
QWidget* myWidget = new QWidget();
widgetList.fill(myWidget, 3); // この場合も、3つの要素が同じmyWidgetを指すことに注意

fill() の size 引数の理解不足

エラー/問題

fill(const T &value, int size = -1) メソッドの size 引数の挙動を誤解すると、リストのサイズが意図しないものになったり、既存のデータが失われたりする可能性があります。

• size を指定した場合: リストのサイズが size に変更され、すべての要素が value で埋められます。
  • size が現在のサイズより大きい場合: リストは拡張され、新しい要素は value で初期化されます。
  • size が現在のサイズより小さい場合: リストは縮小され、size で指定された要素数だけが value で埋められます。
• size を省略した場合 (-1): 現在のリストのすべての要素を value で上書きします。リストのサイズは変更されません。

QList<int> myList;
myList << 1 << 2 << 3;

myList.fill(10);     // sizeを指定しない場合：(10, 10, 10) になる
qDebug() << myList;

myList.clear();
myList << 1 << 2 << 3;
myList.fill(5, 5);   // sizeを5に指定：(5, 5, 5, 5, 5) になる（拡張）
qDebug() << myList;

myList.clear();
myList << 1 << 2 << 3 << 4 << 5;
myList.fill(0, 2);   // sizeを2に指定：(0, 0) になる（縮小）
qDebug() << myList;

トラブルシューティング

• リストのサイズを正確にコントロールしたい場合は、resize() と fill() を組み合わせて使用するか、ループ処理を検討してください。
• fill() を使う前に、リストの既存のデータが失われても問題ないか確認してください。

QList の内部データ型に関する要件

エラー/問題

QList に格納されるカスタム型が、適切なコンストラクタ（デフォルトコンストラクタ、コピーコンストラクタ）や代入演算子 (operator=) を持っていない場合、fill() が期待通りに動作しないか、コンパイルエラーになります。特に、ユーザー定義クラスにこれらの特別なメンバ関数を明示的に定義していない場合、C++コンパイラが自動生成しますが、それが常に QList::fill() の要求を満たすとは限りません。

トラブルシューティング

• カスタムクラスが複雑なリソース管理（動的メモリ割り当てなど）を行っている場合、ディープコピー（deep copy）を適切に実装する必要があります。そうしないと、シャローコピー（shallow copy）による複数のオブジェクトが同じリソースを指してしまう「ダブルフリー」などの問題が発生する可能性があります。
• QList に格納するカスタム型が、コピーセマンティクス（コピーコンストラクタと代入演算子）を正しく実装していることを確認してください。

エラー/問題

QList と QVector はどちらもリストのようなコンテナですが、内部実装が異なります。QList は要素が隣接するメモリ領域に存在することを保証せず、内部的にはポインタの配列とチャンクリストのハイブリッドとして実装されることがあります（Qtのバージョンやプラットフォームによる）。一方、QVector は要素が連続するメモリ領域に格納されます。

QList::fill() の動作自体はこれに直接起因するエラーを引き起こすことは少ないですが、パフォーマンスの期待値が異なる場合があります。大量の要素を fill() で埋める際に、QVector の方がキャッシュ効率が良い場合があります。

• 用途に応じて適切なコンテナを選択することが重要です。
  • QList: リストの先頭・末尾への追加・削除が高速。途中の挿入・削除は比較的低速（要素が移動する可能性があるため）。
  • QVector: ランダムアクセスが高速。途中の挿入・削除は要素の移動が発生するため低速。要素が連続しているため、イテレーションやCPUキャッシュ効率が良い。

---

整数型 (int) のリストを埋める

これは最も基本的な使用例です。リストを指定されたサイズに初期化し、すべての要素に同じ値を設定します。

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

int main() {
    QList<int> intList;

    // 1. リストを5つの要素で初期化し、すべて0で埋める
    qDebug() << "--- 例 1: 初期サイズを指定して埋める ---";
    intList.fill(0, 5); // 5個の要素を作成し、すべて0で埋める
    qDebug() << "intList after fill(0, 5):" << intList;
    // 出力: intList after fill(0, 5): (0, 0, 0, 0, 0)

    // 2. 既存のリストの要素をすべて特定の値で上書きする
    qDebug() << "\n--- 例 2: 既存のリストを上書きする ---";
    intList.clear(); // リストをクリア
    intList << 10 << 20 << 30 << 40; // 既存の要素を追加
    qDebug() << "intList before fill(99):" << intList;
    intList.fill(99); // sizeを省略: 現在のすべての要素を99で上書き
    qDebug() << "intList after fill(99):" << intList;
    // 出力: intList after fill(99): (99, 99, 99, 99)

    // 3. リストのサイズを拡張し、新しい要素を埋める
    qDebug() << "\n--- 例 3: リストを拡張して埋める ---";
    intList.clear();
    intList << 1 << 2;
    qDebug() << "intList before fill(7, 4):" << intList;
    intList.fill(7, 4); // サイズを4に設定。不足分は7で埋まる
    qDebug() << "intList after fill(7, 4):" << intList;
    // 出力: intList after fill(7, 4): (7, 7, 7, 7)

    // 4. リストのサイズを縮小し、残りの要素を埋める
    qDebug() << "\n--- 例 4: リストを縮小して埋める ---";
    intList.clear();
    intList << 100 << 200 << 300 << 400 << 500;
    qDebug() << "intList before fill(50, 3):" << intList;
    intList.fill(50, 3); // サイズを3に設定。残りの要素は破棄され、既存の3つが50で上書き
    qDebug() << "intList after fill(50, 3):" << intList;
    // 出力: intList after fill(50, 3): (50, 50, 50)

    return 0;
}

文字列型 (QString) のリストを埋める

QString もコピー可能な型なので、int と同様に fill() を使用できます。

#include <QList>
#include <QString>
#include <QDebug>

int main() {
    QList<QString> stringList;

    qDebug() << "--- QStringList の例 ---";
    stringList.fill("Hello", 3); // 3つの要素を"Hello"で埋める
    qDebug() << "stringList after fill(\"Hello\", 3):" << stringList;
    // 出力: stringList after fill("Hello", 3): ("Hello", "Hello", "Hello")

    stringList << "World"; // 要素を追加してみる
    qDebug() << "stringList after append(\"World\"):" << stringList;
    // 出力: stringList after append("World"): ("Hello", "Hello", "Hello", "World")

    stringList.fill("Qt"); // 現在のサイズで全てを"Qt"で上書き
    qDebug() << "stringList after fill(\"Qt\"):" << stringList;
    // 出力: stringList after fill("Qt"): ("Qt", "Qt", "Qt", "Qt")

    return 0;
}

カスタムクラスのオブジェクトのリストを埋める

カスタムクラスを QList に格納し、fill() を使用するには、そのクラスがコピーコンストラクタと代入演算子を適切に実装している必要があります。

#include <QList>
#include <QDebug>
#include <QString>

// カスタムクラスの定義
class MyData {
public:
    QString name;
    int value;

    // デフォルトコンストラクタ（QListが要素を初期化する際に必要となる）
    MyData() : name("Default"), value(0) {
        qDebug() << "MyData default constructed.";
    }

    // コンストラクタ
    MyData(const QString& n, int v) : name(n), value(v) {
        qDebug() << "MyData constructed: " << name;
    }

    // コピーコンストラクタ (QList::fillが内部でコピーを作成するために必要)
    MyData(const MyData& other) : name(other.name), value(other.value) {
        qDebug() << "MyData copied: " << name;
    }

    // 代入演算子 (QList::fillが既存の要素を上書きするために必要)
    MyData& operator=(const MyData& other) {
        if (this != &other) { // 自己代入のチェック
            name = other.name;
            value = other.value;
            qDebug() << "MyData assigned: " << name;
        }
        return *this;
    }

    // デストラクタ
    ~MyData() {
        qDebug() << "MyData destructed: " << name;
    }

    // デバッグ出力用のストリーム演算子のオーバーロード
    friend QDebug operator<<(QDebug debug, const MyData& data) {
        QDebugStateSaver saver(debug);
        debug.nospace() << "MyData(" << data.name << ", " << data.value << ")";
        return debug;
    }
};

int main() {
    QList<MyData> dataList;

    qDebug() << "--- カスタムクラスのQList例 ---";

    // MyDataオブジェクトでリストを埋める
    // fill()は、指定された値のコピーを作成し、リストに格納します。
    MyData initialData("Initial", 100);
    qDebug() << "\nFilling list with initialData...";
    dataList.fill(initialData, 3); // 3つの要素をinitialDataのコピーで埋める
    qDebug() << "dataList after fill(initialData, 3):" << dataList;
    // 出力: MyData copied: Initial (x3), MyData(Initial, 100), MyData(Initial, 100), MyData(Initial, 100)

    qDebug() << "\nOverwriting existing elements...";
    MyData newData("New", 200);
    dataList.fill(newData); // 既存の3つの要素をnewDataのコピーで上書き
    qDebug() << "dataList after fill(newData):" << dataList;
    // 出力: MyData assigned: New (x3), MyData(New, 200), MyData(New, 200), MyData(New, 200)

    qDebug() << "\nResizing and filling...";
    dataList.fill(MyData("Resized", 300), 5); // サイズを5にリサイズし、"Resized"で埋める
                                            // 新しい要素は構築され、既存の要素は上書きまたは破棄される
    qDebug() << "dataList after fill(MyData(\"Resized\", 300), 5):" << dataList;
    // 出力: MyData default constructed., MyData constructed: Resized, MyData copied: Resized (x5), MyData assigned: Resized (x3), MyData destructed: New (x3), MyData(Resized, 300), ...

    // プログラム終了時にデストラクタが呼ばれる
    return 0;
}

QList<T*> のようにポインタのリストを fill() で埋める場合、すべてのポインタが同じオブジェクトを指すことに注意してください。これは多くのC++プログラミングの文脈で意図しない挙動につながることがあります。

#include <QList>
#include <QDebug>

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

int main() {
    QList<ExpensiveObject*> ptrList;

    qDebug() << "--- ポインタのQList例 ---";

    // 1. fill() を使って同じポインタで埋める
    // これはよくある間違いです。すべての要素が同じオブジェクトを指します。
    ExpensiveObject* commonObj = new ExpensiveObject(100); // 1つのオブジェクトを生成
    ptrList.fill(commonObj, 3); // 3つの要素すべてがcommonObjを指す
    qDebug() << "ptrList (all pointing to same object):" << ptrList;
    // 出力: ExpensiveObject created with id: 100
    //       ptrList (all pointing to same object): (0x..., 0x..., 0x...) // 同じアドレスが表示される

    // 1つの要素を変更すると、他の要素も影響を受ける
    ptrList.at(0)->id = 200;
    qDebug() << "id of object at ptrList.at(1):" << ptrList.at(1)->id;
    // 出力: id of object at ptrList.at(1): 200 (commonObjのidが変更されたため)

    // メモリリークを避けるために手動でdeleteする必要がある
    delete commonObj;
    ptrList.clear(); // ポインタはクリアされるが、指していたオブジェクトはdeleteされない

    // 2. 独立したオブジェクトでリストを埋める場合 (推奨される方法)
    qDebug() << "\n--- 独立したオブジェクトで埋める (推奨) ---";
    for (int i = 0; i < 3; ++i) {
        ptrList.append(new ExpensiveObject(i + 1)); // 各要素に新しいオブジェクトを生成して追加
    }
    qDebug() << "ptrList (pointing to different objects):" << ptrList;
    // 出力: ExpensiveObject created with id: 1
    //       ExpensiveObject created with id: 2
    //       ExpensiveObject created with id: 3
    //       ptrList (pointing to different objects): (0x..., 0x..., 0x...) // 異なるアドレスが表示される

    // 各要素のidは独立している
    ptrList.at(0)->id = 999;
    qDebug() << "id of object at ptrList.at(1):" << ptrList.at(1)->id;
    // 出力: id of object at ptrList.at(1): 2

    // メモリリークを防ぐため、ループで各オブジェクトを削除する
    qDeleteAll(ptrList); // Qtが提供する便利な関数
    ptrList.clear();

    return 0;
}

---

コンストラクタでの初期化

QList には、サイズと初期値を指定して構築できるコンストラクタがあります。これは、リストを最初から特定の要素で埋めたい場合に最も簡潔な方法です。

使いどころ

• リストを新しく作成し、すべての要素を特定の同じ値で初期化したい場合。

コード例

#include <QList>
#include <QDebug>

int main() {
    // 5つの要素を持つQListを、すべて42で初期化
    QList<int> initialList(5, 42);
    qDebug() << "initialList:" << initialList;
    // 出力: initialList: (42, 42, 42, 42, 42)

    // QStringの例
    QList<QString> defaultNames(3, "Unnamed");
    qDebug() << "defaultNames:" << defaultNames;
    // 出力: defaultNames: ("Unnamed", "Unnamed", "Unnamed")

    return 0;
}

ループを使った要素の追加・設定

各要素に異なる値を設定したい場合や、動的に生成されるオブジェクトをリストに追加したい場合は、ループを使って append() や operator[] (または at()) を使うのが一般的です。

使いどころ

• リストのサイズを動的に変更しながら要素を追加する場合。
• ポインタのリストで、各要素が独立した新しいオブジェクトを指すようにしたい場合（QList::fill() では同じオブジェクトを指してしまうため）。
• 各要素に異なる値を設定する必要がある場合。

コード例

#include <QList>
#include <QDebug>
#include <QString>

class MyObject {
public:
    int id;
    QString name;
    MyObject(int i, const QString& n) : id(i), name(n) {
        qDebug() << "MyObject created: " << name;
    }
    // コピーコンストラクタと代入演算子も必要に応じて定義する
    MyObject(const MyObject& other) : id(other.id), name(other.name) {
        qDebug() << "MyObject copied: " << name;
    }
    MyObject& operator=(const MyObject& other) {
        if (this != &other) {
            id = other.id;
            name = other.name;
            qDebug() << "MyObject assigned: " << name;
        }
        return *this;
    }
    ~MyObject() {
        qDebug() << "MyObject destroyed: " << name;
    }
    friend QDebug operator<<(QDebug debug, const MyObject& obj) {
        QDebugStateSaver saver(debug);
        debug.nospace() << "MyObject(id=" << obj.id << ", name=" << obj.name << ")";
        return debug;
    }
};

int main() {
    QList<int> dynamicList;

    qDebug() << "--- ループでappend() ---";
    for (int i = 0; i < 5; ++i) {
        dynamicList.append(i * 10); // 0, 10, 20, 30, 40 を追加
    }
    qDebug() << "dynamicList:" << dynamicList;
    // 出力: dynamicList: (0, 10, 20, 30, 40)

    qDebug() << "\n--- ループで operator[] を使って既存要素を変更 ---";
    for (int i = 0; i < dynamicList.size(); ++i) {
        dynamicList[i] += 1; // 各要素に1を加算
    }
    qDebug() << "dynamicList after modification:" << dynamicList;
    // 出力: dynamicList after modification: (1, 11, 21, 31, 41)

    // ポインタのリストの例
    QList<MyObject*> objectPointers;
    qDebug() << "\n--- ループで独立したポインタを生成・追加 ---";
    for (int i = 0; i < 3; ++i) {
        objectPointers.append(new MyObject(i, QString("Obj%1").arg(i)));
    }
    qDebug() << "objectPointers:" << objectPointers;
    // 出力: (個別のオブジェクトアドレス)

    // 各オブジェクトのデータは独立している
    objectPointers.at(0)->name = "First";
    qDebug() << "objectPointers.at(1)->name:" << objectPointers.at(1)->name;
    // 出力: objectPointers.at(1)->name: Obj1 (変更されていない)

    // ポインタのリストを扱う場合は、メモリリーク防止のために手動で解放する
    qDeleteAll(objectPointers); // Qtの便利な関数
    objectPointers.clear();

    return 0;
}

C++11 の初期化リスト (std::initializer_list)

C++11以降の機能ですが、QList は初期化リストを使って要素を初期化できます。これは、事前に決まった少数の要素でリストを埋める場合に非常に読みやすい方法です。

使いどころ

• QList::fill() のように全ての要素を同じ値にするのではなく、異なる値で初期化したい場合。
• コンパイル時に要素が固定されており、その場でリストを定義したい場合。

コード例

#include <QList>
#include <QDebug>
#include <QString>

int main() {
    qDebug() << "--- 初期化リスト ---";
    QList<int> predefinedNumbers = {1, 5, 9, 13};
    qDebug() << "predefinedNumbers:" << predefinedNumbers;
    // 出力: predefinedNumbers: (1, 5, 9, 13)

    QList<QString> names = {"Alice", "Bob", "Charlie"};
    qDebug() << "names:" << names;
    // 出力: names: ("Alice", "Bob", "Charlie")

    return 0;
}

挿入演算子 (operator<<)

QList は operator<< をオーバーロードしており、要素を簡潔に追加できます。連続して複数の要素を追加するのに便利です。

使いどころ

• 初期化リストほど厳密に構造化されていなくても、数値を列挙したい場合。
• 少数の要素をリストの末尾に次々と追加したい場合。

コード例

#include <QList>
#include <QDebug>
#include <QString>

int main() {
    QList<double> scores;

    qDebug() << "--- 挿入演算子 (operator<<) ---";
    scores << 85.5 << 92.0 << 78.5 << 95.0;
    qDebug() << "scores:" << scores;
    // 出力: scores: (85.5, 92, 78.5, 95)

    scores << 60.0 << 70.0; // さらに追加
    qDebug() << "scores after more additions:" << scores;
    // 出力: scores after more additions: (85.5, 92, 78.5, 95, 60, 70)

    return 0;
}

std::generate (C++標準ライブラリとの連携)

より複雑なロジックで各要素を生成したい場合、C++標準ライブラリのアルゴリズム (<algorithm>) とQtコンテナを組み合わせることができます。std::generate は、指定された範囲の各要素に、特定の関数（またはラムダ式）の結果を代入します。

使いどころ

• Qt のエコシステムに留まらず、標準C++の強力なアルゴリズムを活用したい場合。
• 各要素を特定のパターンや計算に基づいて生成したい場合。

#include <QList>
#include <QDebug>
#include <algorithm> // std::generate のために必要

int main() {
    QList<int> randomNumbers;
    randomNumbers.resize(10); // 10個の要素分のスペースを確保

    // 各要素をランダムな数値で埋める (C++11のラムダ式を使用)
    // fill() と異なり、各要素は独立した値を持つ
    int seed = 0; // 簡単なシーケンス生成用
    std::generate(randomNumbers.begin(), randomNumbers.end(), [&seed]() {
        return ++seed * 100; // 100, 200, 300... を生成
    });

    qDebug() << "randomNumbers generated with std::generate:" << randomNumbers;
    // 出力例: randomNumbers generated with std::generate: (100, 200, 300, 400, 500, 600, 700, 800, 900, 1000)

    return 0;
}