Qt開発者必見！QList::push_back()を使った効率的なデータ操作術

2025-06-06

`QList::push_back()` とは？

QList::push_back() は、Qt のコンテナクラスの一つである QList に要素を追加するための関数です。具体的には、リストの末尾に新しい要素を追加します。

この関数は、C++ 標準ライブラリの std::vector などにも存在する push_back() と同じように、既存の要素の末尾に新しい要素を効率的に追加するために提供されています。

基本的な使い方

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

int main() {
    QList<QString> myList;

    myList.push_back("Apple");
    myList.push_back("Banana");
    myList.push_back("Cherry");

    // リストの内容を出力
    for (const QString& item : myList) {
        qDebug() << item;
    }
    // 出力:
    // Apple
    // Banana
    // Cherry

    return 0;
}

`QList::append()` との違い

Qt の QList には、push_back() と非常によく似た機能を持つ append() という関数も存在します。

QList::push_back(const T &value): リストの末尾に value を追加します。
QList::append(const T &value): リストの末尾に value を追加します。

これら二つの関数は、機能的には全く同じです。つまり、どちらを使っても結果は同じになります。

では、なぜ2つの関数があるのでしょうか？

push_back() は、Qt が C++ 標準ライブラリ (STL) との互換性を提供するために用意されているものです。STL のコンテナでは push_back() が広く使われているため、Qt でも同様の関数を提供することで、STL に慣れている開発者がQtのコンテナをより自然に使えるように配慮されています。

QList::push_back() (および append()) は、ほとんどの場合で非常に高速な操作（定数時間：O(1)）です。これは、QList が内部的にバッファの前後に追加の領域を事前に割り当てることで、リストの末尾に要素を追加する際のメモリ再割り当てのコストを最小限に抑えているためです。

ただし、QList の内部実装は T の型によって異なります。T がポインタ型、ポインタと同じサイズの基本型、または Qt の暗黙的共有クラスの場合、QList はアイテムを直接ポインタとして保存します。それ以外の場合は、アイテムへのポインタの配列として表現されます。このため、非常に大きなオブジェクトを QList に追加する場合、個々のオブジェクトのヒープ割り当てによるオーバーヘッドが発生する可能性があります。このようなケースでは、連続したメモリにアイテムを格納する QVector の方が適している場合があります。

多くの場合、末尾への追加は高速に行われます。
通常、Qt プログラミングでは append() を使うのが一般的ですが、push_back() を使っても問題ありません。
push_back() は STL との互換性のために提供されています。
機能的には QList::append() と同じです。
QList::push_back() は QList の末尾に要素を追加するための関数です。

QList::push_back() は比較的シンプルな操作ですが、C++ の基本的なルールや Qt のオブジェクトモデルに関連する点で、いくつかの落とし穴があります。

型の不一致 (Type Mismatch)

最も一般的なエラーは、QList が想定している型と異なる型の要素を push_back() しようとすることです。

エラー例

QList<QString> stringList;
int number = 123;
stringList.push_back(number); // コンパイルエラー！

理由
stringList は QString 型の要素のみを格納するように宣言されています。int 型を直接 QString のリストに追加することはできません。

トラブルシューティング
QList に追加しようとしている要素の型が、QList のテンプレート引数で指定された型と一致していることを確認してください。必要に応じて、型変換を行います。

QList<QString> stringList;
int number = 123;
stringList.push_back(QString::number(number)); // OK

または、QVariant を使用して異なる型のデータを扱うこともできます。

QList<QVariant> variantList;
int number = 123;
QString text = "Hello";
variantList.push_back(number); // OK
variantList.push_back(text);    // OK

const メソッド内での変更 (Modifying in a const Method)

const 修飾されたメンバー関数内で QList::push_back() を呼び出すと、コンパイルエラーになります。const メソッドはオブジェクトの状態を変更しないことを保証するためです。

エラー例

class MyClass {
public:
    void addToList(const QString& item) const { // const メソッド
        myList.push_back(item); // コンパイルエラー！
    }
private:
    QList<QString> myList;
};

理由
push_back() は myList の状態を変更するため、const メソッド内で呼び出すことはできません。

トラブルシューティング
リストに要素を追加するメソッドが、オブジェクトの状態を変更する必要がある場合は、const 修飾子を外す必要があります。

class MyClass {
public:
    void addToList(const QString& item) { // const を削除
        myList.push_back(item); // OK
    }
private:
    QList<QString> myList;
};

もし、const メソッド内でリストを「一時的に」変更したいが、オブジェクトの論理的な状態は変更しない、という状況であれば、mutable キーワードを使用することも考えられます。ただし、これは慎重に使うべきであり、通常は避けられます。

class MyClass {
public:
    void addToList(const QString& item) const {
        myList.push_back(item); // OK, myListはmutable
    }
private:
    mutable QList<QString> myList; // myList を mutable にする
};

QObject派生クラスのインスタンスの追加 (Adding QObject-derived Instances)

QList は値ベースのコンテナであるため、QObject を継承したクラスのインスタンスを直接格納しようとすると問題が発生することがあります。QObject はコピーコンストラクタや代入演算子を持たないため、QList が内部でコピーを作成しようとするとコンパイルエラーになります。

エラー例

// MyWidgetはQWidget (QObjectを継承)
QList<MyWidget> widgetList;
MyWidget myWidget;
widgetList.push_back(myWidget); // コンパイルエラー！

理由
QObject はコピー禁止 (non-copyable) です。QList は内部的に要素のコピーを作成しようとするため、この操作は許可されません。

トラブルシューティング
QObject を継承するオブジェクトを QList に格納する場合は、ポインタで格納する必要があります。

QList<MyWidget*> widgetList; // ポインタのリストにする
MyWidget* myWidget = new MyWidget(); // ヒープに作成
widgetList.push_back(myWidget); // OK

// 使用後はメモリの解放を忘れないように
// qDeleteAll(widgetList); // 全て削除
// widgetList.clear();

スマートポインタ (QSharedPointer, QScopedPointer など) を使用すると、メモリ管理がより安全になります。

#include <QList>
#include <QSharedPointer>
#include <QWidget> // 例としてQWidgetを使用

class MyWidget : public QWidget {
    Q_OBJECT
public:
    MyWidget(QWidget* parent = nullptr) : QWidget(parent) {}
};

int main() {
    QList<QSharedPointer<MyWidget>> widgetList;
    widgetList.push_back(QSharedPointer<MyWidget>(new MyWidget())); // スマートポインタで追加
    // スマートポインタがスコープを抜けるときに自動で解放される
    return 0;
}

不適切なオブジェクトのライフサイクル管理 (Improper Object Lifecycle Management)

ポインタを QList に追加する場合、そのポインタが指すオブジェクトのライフサイクルを適切に管理する必要があります。リストから削除されたり、プログラムの終了時にメモリリークが発生したりする可能性があります。

エラー例 (ポインタの場合)

QList<MyObject*> objectList;
// ...
MyObject* obj = new MyObject();
objectList.push_back(obj);
// ...
// obj が他の場所で delete された後も、objectList には古いポインタが残っている
// または、objectList がクリアされたり破棄されたりしても、obj が delete されない

トラブルシューティング

リストが要素の所有権を持つ場合
QList が破棄される際に、内部の要素も自動的に破棄されるように設計する必要があります。
生ポインタを使用する場合
qDeleteAll() を使用して、リスト内のすべてのオブジェクトを削除してから clear() するか、スマートポインタ (QSharedPointer など) を使用して自動管理を検討します。
QObject 派生クラスの場合
親子関係 (QObject の parent 引数) を適切に設定することで、親オブジェクトが子オブジェクトのメモリ管理を自動的に行うことができます。

QList への大量の要素の追加によるパフォーマンス問題 (Performance Issues with Large Additions)

push_back() は通常 O(1) で高速ですが、非常に大量の要素を一度に追加する場合や、リストのキャパシティが頻繁に再割り当てされる場合、パフォーマンスが低下する可能性があります。

トラブルシューティング

事前にサイズを予約する
reserve() 関数を使って、事前に必要なメモリを確保することで、再割り当ての回数を減らし、パフォーマンスを向上させることができます。

QList<int> largeList;
largeList.reserve(100000); // 10万個の要素を格納するメモリを事前に確保
for (int i = 0; i < 100000; ++i) {
    largeList.push_back(i);
}

QVector の検討
多くの要素を連続的に追加し、ランダムアクセスが頻繁に行われる場合は、QVector の方が QList よりもパフォーマンスが良い場合があります。QVector は内部的に連続したメモリを使用するため、キャッシュ効率が高い傾向があります。QList は内部的にポインタの配列を持つため、要素が離れたメモリ位置に存在し得ます。

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

QList に要素を追加すると、既存のイテレータが無効になる可能性があります。無効化されたイテレータを使用しようとすると、未定義の動作やクラッシュを引き起こすことがあります。

トラブルシューティング
push_back() の後でイテレータを使用する場合は、操作後にイテレータを再取得することを検討してください。特にループ内で要素を追加しながらイテレータを保持している場合は注意が必要です。

QList::push_back() はリストの末尾に要素を追加する非常に一般的な操作です。QList::append() と機能的に同じなので、ここでは両方の関数を例に含めます。

基本的な型の追加

最もシンプルな例として、整数や文字列などの基本的な型の要素を QList に追加する方法です。

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

int main() {
    // 1. int型のQListに要素を追加
    QList<int> intList;
    intList.push_back(10);
    intList.append(20); // appendも同様に動作
    intList.push_back(30);

    qDebug() << "Int List:";
    for (int value : intList) {
        qDebug() << value;
    }
    // 出力:
    // Int List:
    // 10
    // 20
    // 30

    // 2. QString型のQListに要素を追加
    QList<QString> stringList;
    stringList.push_back("Apple");
    stringList.append("Banana");
    stringList.push_back("Cherry");

    qDebug() << "\nString List:";
    for (const QString& s : stringList) {
        qDebug() << s;
    }
    // 出力:
    // String List:
    // Apple
    // Banana
    // Cherry

    // 3. Qt の << 演算子 (operator<<) を使用する
    // これは push_back() と同じ効果があります
    QList<double> doubleList;
    doubleList << 1.1 << 2.2 << 3.3;

    qDebug() << "\nDouble List (using operator<<):";
    for (double d : doubleList) {
        qDebug() << d;
    }
    // 出力:
    // Double List (using operator<<):
    // 1.1
    // 2.2
    // 3.3

    return 0;
}

カスタムクラスのインスタンスの追加

独自のクラスを QList に格納することもできます。ただし、そのクラスがコピー可能 (copyable) である必要があります。

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

// カスタムクラスの定義
class Product {
public:
    Product(const QString& name = "", double price = 0.0)
        : m_name(name), m_price(price) {}

    QString name() const { return m_name; }
    double price() const { return m_price; }

    void print() const {
        qDebug() << "Product: " << m_name << ", Price: " << m_price;
    }

private:
    QString m_name;
    double m_price;
};

int main() {
    QList<Product> products;

    // Productオブジェクトを作成して追加
    products.push_back(Product("Laptop", 1200.00));
    products.append(Product("Mouse", 25.50));
    products.push_back(Product("Keyboard", 75.00));

    qDebug() << "Products in List:";
    for (const Product& p : products) {
        p.print();
    }
    // 出力:
    // Products in List:
    // Product: "Laptop" , Price: 1200
    // Product: "Mouse" , Price: 25.5
    // Product: "Keyboard" , Price: 75

    return 0;
}

QObject 派生クラスのポインタの追加 (推奨される方法)

前述の通り、QObject を継承するクラス（QWidget など）はコピーできないため、QList に直接格納することはできません。代わりに、ポインタを格納します。スマートポインタを使用すると、メモリ管理がより安全になります。

#include <QList>
#include <QPushButton> // QWidgetを継承したクラスの例
#include <QDebug>
#include <QCoreApplication> // イベントループが必要な場合
#include <QSharedPointer> // スマートポインタ

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv); // QtアプリケーションにはQCoreApplicationが必要

    // 生ポインタのQList (メモリ管理に注意が必要)
    QList<QPushButton*> buttonPointers;
    QPushButton* btn1 = new QPushButton("Button 1");
    QPushButton* btn2 = new QPushButton("Button 2");
    buttonPointers.push_back(btn1);
    buttonPointers.append(btn2);

    qDebug() << "Raw Pointers List:";
    for (QPushButton* btn : buttonPointers) {
        qDebug() << "Button text:" << btn->text();
    }

    // 適切なメモリ解放
    qDeleteAll(buttonPointers); // リスト内のすべてのQPushButtonオブジェクトを削除
    buttonPointers.clear();      // リストをクリア (ポインタをnullptrにする)

    // QSharedPointer (推奨される方法)
    QList<QSharedPointer<QPushButton>> sharedButtonList;
    sharedButtonList.push_back(QSharedPointer<QPushButton>(new QPushButton("Shared Button A")));
    sharedButtonList.append(QSharedPointer<QPushButton>(new QPushButton("Shared Button B")));

    qDebug() << "\nShared Pointers List:";
    for (const QSharedPointer<QPushButton>& btn : sharedButtonList) {
        qDebug() << "Shared Button text:" << btn->text();
    }
    // sharedButtonList がスコープを抜けるときに、ボタンオブジェクトは自動的に解放されます

    return 0; // a.exec(); // GUIアプリケーションの場合はイベントループを開始
}

ネストされた QList への追加

QList の要素として別の QList を格納することもできます。これは、多次元のデータ構造を作成するのに役立ちます。

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

int main() {
    // 文字列のリストのリスト
    QList<QList<QString>> listOfLists;

    // 最初の内部リストを作成し、要素を追加して、外側のリストに追加
    QList<QString> innerList1;
    innerList1.push_back("Row1_Col1");
    innerList1.append("Row1_Col2");
    listOfLists.push_back(innerList1);

    // 別の方法で内部リストを直接作成して追加
    listOfLists.push_back(QList<QString>() << "Row2_Col1" << "Row2_Col2" << "Row2_Col3");

    qDebug() << "Nested List:";
    for (int i = 0; i < listOfLists.size(); ++i) {
        qDebug() << "Row" << i << ":";
        for (const QString& item : listOfLists[i]) {
            qDebug() << "  " << item;
        }
    }
    // 出力:
    // Nested List:
    // Row 0 :
    //   Row1_Col1
    //   Row1_Col2
    // Row 1 :
    //   Row2_Col1
    //   Row2_Col2
    //   Row2_Col3

    return 0;
}

既存の QList 全体を追加する

push_back() (または append()) は、単一の要素だけでなく、同じ型の別の QList 全体を結合することもできます。

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

int main() {
    QList<int> list1;
    list1.push_back(1);
    list1.append(2);

    QList<int> list2;
    list2.push_back(3);
    list2.append(4);

    // list1 に list2 の全ての要素を追加
    list1.push_back(list2); // または list1.append(list2);
    // または list1 += list2; (これも同じ効果)

    qDebug() << "Combined List:";
    for (int value : list1) {
        qDebug() << value;
    }
    // 出力:
    // Combined List:
    // 1
    // 2
    // 3
    // 4

    return 0;
}

QList::push_back() は QList の末尾に要素を追加する一般的な方法ですが、Qt には他にもいくつかの方法があり、状況に応じて使い分けることでコードの可読性や効率を向上させることができます。

QList::append()

これは push_back() の最も直接的な代替です。機能的には全く同じであり、どちらを使用しても結果は同じです。Qt のドキュメントや慣例では append() がより頻繁に見られます。

例

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

int main() {
    QList<QString> myList;

    myList.append("Apple");      // push_back() と同じ効果
    myList.append("Banana");
    myList.append("Cherry");

    qDebug() << "List using append():" << myList;
    // 出力: List using append(): ("Apple", "Banana", "Cherry")

    return 0;
}

使い分け
機能的には同じなので、好みの問題です。Qt の標準的なスタイルに合わせるなら append() を使うのが一般的です。STL との互換性を意識するなら push_back() を使うこともできます。

QList::operator<< (ストリーム演算子)

Qt のコンテナクラスでは、C++ のストリーム演算子 operator<< をオーバーロードしており、これを使って要素をリストに簡単に追加できます。非常に簡潔に記述できます。

例

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

int main() {
    QList<QString> myList;

    myList << "Apple" << "Banana" << "Cherry"; // 複数の要素を一度に追加

    qDebug() << "List using operator<<:" << myList;
    // 出力: List using operator<<: ("Apple", "Banana", "Cherry")

    return 0;
}

利点

特に初期化時に多くの要素を追加する場合に便利です。
複数の要素を一行でチェーンして追加できるため、非常に簡潔に書けます。

使い分け
簡潔さを求める場合や、初期化時に固定の要素を追加する場合に非常に有効です。ループ内で動的に追加する場合は append() や push_back() の方が適しているかもしれません。

QList::insert()

insert() は、リストの特定のインデックス位置に要素を挿入します。これは push_back() のように常に末尾に追加するのではなく、任意の場所に要素を挿入したい場合に用います。

オーバーロードの例

iterator QList::insert(iterator before, const T &value): before イテレータが指す要素の前に value を挿入します。
void QList::insert(int i, const T &value): インデックス i の位置に value を挿入します。既存の要素は後方に移動します。

例

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

int main() {
    QList<QString> myList;
    myList << "Apple" << "Banana" << "Grape";

    myList.insert(2, "Cherry"); // インデックス2 (3番目) の位置に "Cherry" を挿入
                               // 元の "Grape" は後ろにずれる

    qDebug() << "List after insert(2, \"Cherry\"):" << myList;
    // 出力: List after insert(2, "Cherry"): ("Apple", "Banana", "Cherry", "Grape")

    // イテレータを使った挿入
    QList<QString>::iterator it = myList.begin();
    it++; // "Banana" を指す

    myList.insert(it, "Orange"); // "Banana" の前に "Orange" を挿入

    qDebug() << "List after insert(it, \"Orange\"):" << myList;
    // 出力: List after insert(it, "Orange"): ("Apple", "Orange", "Banana", "Cherry", "Grape")

    return 0;
}

利点
リストの任意の場所に要素を追加できます。

注意点
insert() は push_back() や append() よりもコストがかかる場合があります。特にリストの先頭や途中に挿入する場合、既存の要素を移動させる必要があるため、要素数が多いほどパフォーマンスが低下します（平均して O(n)）。末尾への追加だけを目的とする場合は push_back()/append() が常に推奨されます。

QList::prepend()

prepend() は、リストの先頭に要素を追加します。これは push_back() の反対の操作です。

例

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

int main() {
    QList<QString> myList;
    myList.append("Banana");
    myList.append("Cherry");

    myList.prepend("Apple"); // リストの先頭に "Apple" を追加

    qDebug() << "List after prepend():" << myList;
    // 出力: List after prepend(): ("Apple", "Banana", "Cherry")

    return 0;
}

注意点
prepend() も insert(0, value) と同じように、リストの先頭に要素を挿入するため、内部的には既存の要素をすべて移動させる必要があります。そのため、大量の要素を先頭に追加する場合には、push_back()/append() よりもパフォーマンスが低下します（平均して O(n)）。

初期化リスト (C++11 以降)

C++11 以降のコンパイラを使用している場合、初期化リスト構文を使って QList を初期化し、同時に要素を追加できます。これは、リストが固定の要素を持つ場合に非常に便利です。

例

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

int main() {
    // 初期化リストを使ってQListを宣言と同時に初期化
    QList<QString> myList = {"Apple", "Banana", "Cherry"};

    qDebug() << "List initialized with initializer list:" << myList;
    // 出力: List initialized with initializer list: ("Apple", "Banana", "Cherry")

    // 空のリストを宣言した後でも、別のリストの要素をまとめて追加できる
    QList<int> numbers;
    numbers.append({10, 20, 30}); // append() に初期化リストを渡すことも可能

    qDebug() << "Numbers list:" << numbers;
    // 出力: Numbers list: (10, 20, 30)

    return 0;
}

利点
宣言と初期化を同時に行えるため、コードが非常に読みやすくなります。

使い分け
コンパイル時に要素が既知である場合に最適です。動的に要素を追加する場合は、やはり append() や push_back() が必要になります。

他のコンテナの要素を一括で追加

QList は、別の QList や QVector などのコンテナのすべての要素を一度に追加するためのオーバーロードも提供しています。

QList<T> &operator+=(const QList<T> &other): += 演算子も利用可能
void QList::append(const QVector<T> &vector): QVector の全要素を追加
void QList::append(const QList<T> &list): 別の QList の全要素を追加

例

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

int main() {
    QList<QString> fruits1;
    fruits1.append("Apple");
    fruits1.append("Banana");

    QList<QString> fruits2;
    fruits2.append("Cherry");
    fruits2.append("Date");

    fruits1.append(fruits2); // fruits2 の全要素を fruits1 の末尾に追加
    // または fruits1 += fruits2;

    qDebug() << "Combined fruits list:" << fruits1;
    // 出力: Combined fruits list: ("Apple", "Banana", "Cherry", "Date")

    return 0;
}

QList::push_back() は QList::append() と機能的に同じであり、リストの末尾に要素を追加する標準的な方法です。しかし、それ以外にも以下のような代替手段があり、それぞれの状況に応じて最適な方法を選択できます。

他のコンテナの一括追加: append() や += 演算子で別のリストの全要素を追加。
初期化リスト: C++11 以降で、宣言時に固定要素を初期化。
QList::prepend(): リストの先頭に要素を追加（パフォーマンスに注意）。
QList::insert(): 任意のインデックスに要素を挿入（パフォーマンスに注意）。
QList::operator<<: 複数の要素を簡潔にチェーンして追加。
QList::append(): push_back() と同じく末尾に追加。Qt 慣例。

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::push_back()を使った効率的なデータ操作術

QList::push_back() とは？

QList::append() との違い

型の不一致 (Type Mismatch)

const メソッド内での変更 (Modifying in a const Method)

QObject派生クラスのインスタンスの追加 (Adding QObject-derived Instances)

不適切なオブジェクトのライフサイクル管理 (Improper Object Lifecycle Management)

QList への大量の要素の追加によるパフォーマンス問題 (Performance Issues with Large Additions)

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

基本的な型の追加

カスタムクラスのインスタンスの追加

QObject 派生クラスのポインタの追加 (推奨される方法)

ネストされた QList への追加

既存の QList 全体を追加する

QList::append()

QList::operator<< (ストリーム演算子)

QList::insert()

QList::prepend()

初期化リスト (C++11 以降)

他のコンテナの要素を一括で追加

`QList::push_back()` とは？

`QList::append()` との違い