[Dark Horse Programmer C++ チュートリアル 0 から 1 プログラミング入門] [注 8] ジェネリックプログラミング - テンプレート

https://www.bilibili.com/video/BV1et411b73Z?p=167

C++ ジェネリックプログラミングは、コードをさまざまなデータ型に適用できるようにジェネリックコードを記述することを中心的な考え方とするプログラミングパラダイムです。
テンプレートは、C++ でジェネリックプログラミングを実装するためのメカニズムです。これにより、一般的なコードテンプレートを記述し、特定のコードを生成する必要があるときに、特定のデータ型に従ってインスタンス化することができます。
したがって、テンプレートは C++ でのジェネリックプログラミングの基礎であると言えます。テンプレートを使用することで、汎用性と再利用性の高いコードを記述できるため、コードの効率と保守性が向上します。

記事ディレクトリ

- 1 テンプレート

1 テンプレート

1.1 テンプレートの概念

テンプレートは一般的な金型を作成するためのもので、再利用性が大幅に向上します

たとえば、人生のテンプレート

1 インチの写真テンプレート:

ここに画像の説明を挿入
PPT テンプレート:

ここに画像の説明を挿入
テンプレートの機能:

テンプレートを直接使用することはできません。これは単なるフレームワークです。
テンプレートの汎用性は万能薬ではありません

1.2 関数テンプレート

C++ の別のプログラミング思想が呼び出されます。汎用プログラミング、使用される主なテクノロジーはテンプレートです
C++ には、関数テンプレートとクラステンプレートの2 つのテンプレートメカニズムが用意されています。

1.2.1 関数テンプレートの構文

関数テンプレートの役割:

一般的な関数を作成するには、その関数の戻り値の型と仮パラメーターの型を指定することはできませんが、仮想型で表すことができます。

文法

template<typename T>
函数声明或定义

説明

template — 作成するテンプレートを宣言します

typename — その後ろのシンボルがデータ型であることを示します。これはクラスに置き換えることができます (他の名前は使用できないようで、使用できるのは typename または class のみです)

T — 汎用データ型、名前は通常大文字で置き換えることができます

知らせ

template <typename T>次のコードと接続するためにvoid mySwap(T &a, T &b)、途中でコメントを追加できますが、無関係なコードを追加することはできません

template <typename T> void mySwap(T &a, T &b)

例: 自動型推論、明示的型付け

（test.cpp）

#include <iostream>
#include <cstdlib>
#include <limits>
using namespace std;

// 交换整型函数
void swapInt(int &a, int &b)
{
    
    
    int temp = a;
    a = b;
    b = temp;
}

// 交换浮点型函数
void swapDouble(double &a, double &b)
{
    
    
    double temp = a;
    a = b;
    b = temp;
}

// 利用模板提供通用的交换函数
template <typename T>
void mySwap(T &a, T &b)
{
    
    
    T temp = a;
    a = b;
    b = temp;
}

void test01()
{
    
    
    int a = 10;
    int b = 20;

    // swapInt(a, b);

    // 利用模板实现交换
    // 1、自动类型推导
    mySwap(a, b);
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    double c = 1.2;
    double d = 2.3;
    mySwap(c, d);
    cout << "c = " << c << endl;
    cout << "d = " << d << endl;

    // 3、显示指定类型
    int e=3;
    int f=4;
    mySwap<int>(e, f);
    cout << "e = " << e << endl;
    cout << "f = " << f << endl;
}

int main()
{
    
    

    test01();

    // system("pause");
    // return 0;

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

コンパイル：

g++ test.cpp

操作結果:

ここに画像の説明を挿入
要約:

関数テンプレートはキーワードテンプレートを使用します
関数テンプレートを使用するには、自動型推定と明示的な型指定の 2 つの方法があります。
テンプレートの目的は、再利用性を向上させ、型をパラメータ化することです

1.2.2 関数テンプレートに関する考慮事項

予防：

自動型推定。使用前に一貫したデータ型 T を推定する必要があります
テンプレートは、使用する前に T のデータ型を決定する必要があります

例: テンプレートは、使用する前に T のデータ型を決定する必要があります。

#include <iostream>
#include <cstdlib>
#include <limits>
using namespace std;

// 利用模板提供通用的交换函数
template <typename T>
void mySwap(T &a, T &b)
{
    
    
    T temp = a;
    a = b;
    b = temp;
}

// 1、自动类型推导，必须推导出一致的数据类型T,才可以使用
void test01()
{
    
    
    int a = 10;
    int b = 20;
    char c = 'c';

    mySwap(a, b); // 正确，可以推导出一致的T
                  // mySwap(a, c); // 错误，推导不出一致的T类型
}

// 2、模板必须要确定出T的数据类型，才可以使用
template <class T>
void func()
{
    
    
    cout << "func 调用" << endl;
}

void test02()
{
    
    
    // func(); //错误，模板不能独立使用，必须确定出T的类型
    func<int>(); // 利用显示指定类型的方式，给T一个类型，才可以使用该模板
}

int main()
{
    
    

    test01();
    test02();

    // system("pause");
    // return 0;

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

要約:

テンプレートを使用する場合、一般的なデータ型 T を決定する必要があり、一貫した型を推測できます

例: 複数のタイプパラメータテンプレート

#include <iostream>
#include <cstdlib>
#include <limits>
using namespace std;

// 利用模板提供通用的交换函数
template <typename T1, typename T2>
void mySwap(T1 &a, T2 &b)
{
    
    
    T1 temp = a;
    a = b;
    b = temp;
}

// 1、自动类型推导，必须推导出一致的数据类型T,才可以使用
void test01()
{
    
    
    int a = 10;
    double b = 20.1;
    char c = 'c';

    mySwap(a, b); // 正确，可以推导出一致的T
                  // mySwap(a, c); // 错误，推导不出一致的T类型
}


int main()
{
    
    

    test01();

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

1.2.3 関数テンプレートのケース (異なるデータ型の配列のソート)

ケースの説明:

関数テンプレートを使用して、さまざまなデータ型の配列を並べ替えることができる並べ替え関数をカプセル化します
ソート規則は大きいものから小さいものへ、ソートアルゴリズムは選択ソートです。
それぞれchar配列とint配列でテストします

例：

#include <iostream>
#include <cstdlib>
#include <limits>
using namespace std;

// 交换的函数模板
template <typename T>
void mySwap(T &a, T &b)
{
    
    
    T temp = a;
    a = b;
    b = temp;
}

template <class T> // 也可以替换成typename
// 利用选择排序，进行对数组从大到小的排序
void mySort(T arr[], int len)
{
    
    
    for (int i = 0; i < len; i++)
    {
    
    
        int max = i; // 最大数的下标
        for (int j = i + 1; j < len; j++)
        {
    
    
            if (arr[max] < arr[j])
            {
    
    
                max = j;
            }
        }
        if (max != i) // 如果最大数的下标不是i，交换两者
        {
    
    
            mySwap(arr[max], arr[i]);
        }
    }
}

template <typename T>
void printArray(T arr[], int len)
{
    
    

    for (int i = 0; i < len; i++)
    {
    
    
        cout << arr[i] << " ";
    }
    cout << endl;
}

void test01()
{
    
    
    // 测试char数组
    char charArr[] = "bdcfeagh";
    int num = sizeof(charArr) / sizeof(char);
    mySort(charArr, num);
    printArray(charArr, num);
}

void test02()
{
    
    
    // 测试int数组
    int intArr[] = {
    
    7, 5, 8, 1, 3, 9, 2, 4, 6};
    int num = sizeof(intArr) / sizeof(int);
    mySort(intArr, num);
    printArray(intArr, num);
}

int main()
{
    
    
    test01();
    test02();

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

操作結果:

ここに画像の説明を挿入

1.2.4 通常の関数と関数テンプレートの違い

通常の関数と関数テンプレートの違い:

通常の関数呼び出し時に自動型変換（暗黙の型変換）が発生する場合がある
関数テンプレートが呼び出されるときに、自動型推定が使用されている場合、暗黙的な型変換は発生しません
明示的な型が指定されている場合、暗黙的な型変換が発生する可能性があります

例：テンプレート関数の呼び出し時に型を明示的に指定する方法がエラーになりにくいのでおすすめ

#include <iostream>
#include <cstdlib>
#include <limits>
using namespace std;

// 普通函数
int myAdd01(int a, int b)
{
    
    
    return a + b;
}

// 函数模板
template <typename T> 
T myAdd02(T a, T b) //这个表示返回类型也自动推导为 T
{
    
    
    return a + b;
}

// 使用函数模板时，如果用自动类型推导，不会发生自动类型转换,即隐式类型转换
void test01()
{
    
    
    int a = 10;
    int b = 20;
    char c = 'c';

    cout << "myAdd01(a, c): " << myAdd01(a, c) << endl; // 正确，将char类型的'c'隐式转换为int类型  'c' 对应 ASCII码 99

    // myAdd02(a, c); // 报错，使用自动类型推导时，不会发生隐式类型转换

    cout << "myAdd02<int>(a, c): " << myAdd02<int>(a, c) << endl; // 正确，如果用显式指定类型，可以发生隐式类型转换
}

int main()
{
    
    
    test01();

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

ここに画像の説明を挿入

まとめ：一般的な型 T は自分で決めることができるので、指定型を表示して関数テンプレートを呼び出す方法を使うことをお勧めします

1.2.5 通常の関数と関数テンプレートの呼び出し規則

呼び出しルールは次のとおりです。

関数テンプレートと通常の関数の両方を実装できる場合、通常の関数が最初に呼び出されます
関数テンプレートは、空のテンプレートパラメーターリストで強制的に呼び出すことができます
関数テンプレートもオーバーロードできます
関数テンプレートがより適切な一致を生成できる場合、関数テンプレートが最初に呼び出されます (通常の関数が暗黙の変換を必要とする場合など)。

例: 通常の関数とテンプレートが競合する場合、関数テンプレートの方が一致する場合は、関数テンプレートが最初に呼び出されます (通常の関数の暗黙的な変換の存在を考慮する)。

#include <iostream>
#include <cstdlib>
#include <limits>
using namespace std;

// 普通函数与函数模板调用规则
void myPrint(int a, int b)
{
    
    
    cout << "调用的普通函数" << endl;
}

template <typename T>
void myPrint(T a, T b)
{
    
    
    cout << "调用的模板" << endl;
}

template <typename T>
void myPrint(T a, T b, T c)
{
    
    
    cout << "调用重载的模板" << endl;
}

void test01()
{
    
    
    // 1、如果函数模板和普通函数都可以实现，优先调用普通函数
    //  注意 如果告诉编译器  普通函数是有的，但只是声明没有实现，或者不在当前文件内实现，就会报错找不到
    int a = 10;
    int b = 20;
    myPrint(a, b); // 调用普通函数

    // 2、可以通过空模板参数列表来强制调用函数模板
    myPrint<>(a, b); // 调用函数模板

    // 3、函数模板也可以发生重载
    int c = 30;
    myPrint(a, b, c); // 调用重载的函数模板

    // 4、 如果函数模板可以产生更好的匹配,优先调用函数模板
    char c1 = 'a';
    char c2 = 'b';
    myPrint(c1, c2); // 调用函数模板
}

int main()
{
    
    
    test01();

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

ここに画像の説明を挿入

まとめ: 関数テンプレートが提供されているので、通常の関数は提供しない方がよい、そうしないとあいまいさが生じやすい

1.2.6 テンプレートの制限

制限：

テンプレートの多様性がすべてではない

例えば：

template<class T>
void f(T a, T b)
{
    
     
   	a = b;
}

渡された a と b が配列の場合、上記のコードで提供されている代入演算は実現できません。

もう一つの例：

template<class T>
void f(T a, T b)
{
    
     
   	if(a > b) {
    
     ... }
}

上記のコードで、T のデータ型が Person のようなカスタムデータ型で渡されると、正しく動作しません。

したがって、この問題を解決するために、C++ はこれらの特定の型に特定のテンプレートを提供できるテンプレートのオーバーロードを提供します。

特化テンプレート機能

template <>
bool myCompare(Person &p1, Person &p2){
    
    }

特殊化とは、特定の型に対して特別な実装方法を提供することを指します。この例では、テンプレート関数 myCompare を特殊化して、Person 型のパラメーターに特別な実装を提供します。

この特殊なテンプレート関数では、template <>構文を使用して、これが特殊なテンプレート関数であることを示します。存在角括弧すでに特定の型に特化しているため、でテンプレートパラメータを指定する必要はありません。関数パラメーターリストでは、Person &p1andを使用して、Person &p2これら 2 つのパラメーターが Person 型の参照であることを示します。関数本体では、Person 型の特性に応じて特定の比較ロジックを実装できます。

この特殊なテンプレート関数は空です。この関数の実装は、テンプレートパラメーターではなく、Person 型の特性に基づいているためです。したがって、この特殊なテンプレート関数では、テンプレートパラメーターを再度定義する必要はありません。

特殊なテンプレート関数の役割

特殊化テンプレート関数の機能は、いくつかの特定の型に対して特別な実装方法を提供することです。通常、テンプレート関数は、汎用的で複数の型に適用される方法で実装されます。ただし、一部の型は特別な処理が必要な場合があります。この場合、特別なテンプレート関数を使用して特別な実装を提供できます。

特殊なテンプレート関数には、次のような多くの使用シナリオがあります。

一部の型では、ジェネリック実装が十分に効率的でなく、型固有の最適化が必要になる場合があります。
型によっては、一般的な実装が十分に正確でなく、特定の型に対して特別な処理が必要になる場合があります。
一部のタイプでは、一般的な実装が利用できない場合があり、タイプ固有の実装が必要になります。

たとえば、std::string文字列を比較する型に特化したテンプレート関数を提供できます。

template <>
bool myCompare(std::string &s1, std::string &s2) {
    
    
    return s1.length() < s2.length();
}

この特殊なテンプレート関数では、template <>構文を使用して、これが特殊なテンプレート関数であることを示します。特定のタイプに特化しているため、山かっこでテンプレートパラメーターを指定する必要はありません。関数パラメーターリストでは、std::string &s1andを使用して、std::string &s2これら 2 つのパラメーターが std::string 型の参照であることを示します。関数本体では、文字列の長さに基づいて比較ロジックを実装します。

特殊なテンプレート関数を使用すると、コードの効率と可読性が向上し、コードがより柔軟になり、保守が容易になります。

特殊なテンプレート関数、通常のテンプレート関数、通常の関数の優先順位 (通常の関数 > 特殊なテンプレート関数 > テンプレート関数)

C++ では、関数テンプレート、特殊なテンプレート関数、および通常の関数の優先順位は次のとおりです。

通常の関数 (非テンプレート関数)
特化したテンプレート機能
通常のテンプレート機能

コンパイラが一致する関数を探す場合、最初に通常の関数を探し、次に特殊なテンプレート関数を探し、最後に通常のテンプレート関数を探します。この順序により、候補関数が複数ある場合に、最も適切な関数が選択されます。以下に例を示します。

#include <iostream>

// 常规模板函数
template <typename T>
void foo(T t) {
    
    
    std::cout << "常规模板函数" << std::endl;
}

// 特化模板函数
template <>
void foo<int>(int t) {
    
    
    std::cout << "特化模板函数" << std::endl;
}

// 普通函数
void foo(int t) {
    
    
    std::cout << "普通函数" << std::endl;
}

int main() {
    
    
    int a = 1;
    foo(a); // 输出：普通函数
    return 0;
}

この例では、通常のテンプレート関数、特殊なテンプレート関数、および通常の関数があります。foo(a) を呼び出すと、コンパイラは最初に通常の関数を探し、次に特殊なテンプレート関数を探し、最後に一般的なテンプレート関数を探します。したがって、出力は「通常の関数」です。

テストするには、コンパイルして実行し、通常の関数をコメントアウトし、コンパイルして再度実行すると、実行結果は次のようになります。

ここに画像の説明を挿入

通常の関数が最も優先度が高く、次に特殊なテンプレート関数が続き、通常のテンプレート関数が最も低いことがわかります。

例: 特殊なテンプレート関数の例

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;

class Person
{
    
    
public:
    Person(string name, int age)
    {
    
    
        this->m_Name = name;
        this->m_Age = age;
    }
    string m_Name;
    int m_Age;
};

// 普通函数模板
template <class T>
bool myCompare(T &a, T &b)
{
    
    
    cout << "普通函数模板" << endl;
    if (a == b)
    {
    
    
        return true;
    }
    else
    {
    
    
        return false;
    }
}

// 具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
// 具体化优先于常规模板
template <>
bool myCompare(Person &p1, Person &p2)
{
    
    
    cout << "特化函数模板" << endl;
    if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
    {
    
    
        return true;
    }
    else
    {
    
    
        return false;
    }
}

void test01()
{
    
    
    int a = 10;
    int b = 20;
    // 内置数据类型可以直接使用通用的函数模板
    bool ret = myCompare(a, b);
    if (ret)
    {
    
    
        cout << "a == b " << endl;
    }
    else
    {
    
    
        cout << "a != b " << endl;
    }
}

void test02()
{
    
    
    Person p1("Tom", 10);
    Person p2("Tom", 10);
    // 自定义数据类型，不会调用普通的函数模板
    // 可以创建具体化的Person数据类型的模板，用于特殊处理这个类型
    bool ret = myCompare(p1, p2);
    if (ret)
    {
    
    
        cout << "p1 == p2 " << endl;
    }
    else
    {
    
    
        cout << "p1 != p2 " << endl;
    }
}

int main()
{
    
    

    test01();

    test02();

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

ここに画像の説明を挿入

要約する

カスタム型の一般化は、具体的なテンプレートを使用して解決できます
テンプレートを学習することは、テンプレートを書くことではなく、システムが提供するテンプレートを STL で使用することです。

1.3 クラステンプレート

1.3.1 クラステンプレートの構文

クラステンプレートの役割:

一般的なクラスを作成すると、クラス内のメンバーのデータ型は、指定せずに仮想型で表すことができます。

C++ クラステンプレートは、さまざまな種類のデータを処理できる汎用クラスを作成できる汎用プログラミングツールです。クラステンプレートを使用すると、コードを 1 回記述すれば、それを使用してさまざまな種類の複数のクラスを作成できます。これにより、コードの重複が大幅に削減され、コードの再利用性と保守性が向上します。
クラステンプレートを使用して、ベクター、リスト、マップなどのコンテナークラスを実装できます。これらのコンテナークラスは、さまざまな種類のデータを格納でき、要素を動的に追加または削除できます。クラステンプレートを使用して、さまざまな種類のデータを処理するために使用できる並べ替え、検索などのアルゴリズムクラスを実装することもできます。
つまり、C++ クラステンプレートは非常に強力なプログラミングツールであり、一般的なコードを記述し、コードの再利用性と保守性を向上させ、プログラムをより効率的に記述できるようにします。

文法：

template <typename T>
类

または：

template <class T>
类

説明：

template — 作成するテンプレートを宣言します
typename — その後ろの記号はデータ型で、クラスに置き換えることができます
T — 一般的なデータ型。名前は置き換えることができます。通常は大文字です (これは、構築クラスのパラメーターであるクラステンプレートに反映されます)。

例

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;

// 类模板
template <typename NameType, typename AgeType>
class Person
{
    
    
public:
    Person(NameType name, AgeType age)
    {
    
    
        this->mName = name;
        this->mAge = age;
    }
    void showPerson()
    {
    
    
        cout << "name: " << this->mName << " age: " << this->mAge << endl;
    }

public:
    NameType mName;
    AgeType mAge;
};

void test01()
{
    
    
    // 指定NameType 为string类型，AgeType 为 int类型
    Person<string, int> P1("孙悟空", 999);
    P1.showPerson();

    // 指定NameType 为string类型，AgeType 为 int类型
    Person<int, string> P2(5000, "999");
    P2.showPerson();
}

int main()
{
    
    

    test01();

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

ここに画像の説明を挿入

まとめ: クラステンプレートと関数テンプレートは構文が似ているので、クラステンプレートと呼ばれる宣言テンプレートテンプレートの後にクラスを追加します

1.3.2 クラステンプレートと関数テンプレートの違い (クラステンプレートのインスタンス化はコンパイル時に完了し、関数テンプレートのインスタンス化は呼び出し時に完了します)

クラステンプレートと関数テンプレートには、主に次の 2 つの違いがあります。

自動型推定なしのクラステンプレートの使用
クラステンプレートは、テンプレートパラメーターリストに既定のパラメーターを含めることができます。

クラステンプレートと関数テンプレートはどちらも C++ のテンプレートですが、その機能と使用法は異なります。
クラステンプレートは、クラスを生成するために使用されるテンプレートであり、さまざまな種類のデータを処理するために使用できる一般的なクラスを定義できます。クラステンプレートには、メンバー関数、メンバー変数、静的メンバーなどを含めることができ、通常のクラスと同様に使用できます。クラステンプレートのインスタンス化はコンパイル時に行われます。つまり、具体的なクラスは、使用時にテンプレートパラメータに基づいて生成されます。
関数テンプレートは、関数を生成するために使用されるテンプレートであり、さまざまな種類のデータを処理するために使用できる一般的な関数を定義できます。関数テンプレートには、関数のパラメーター、戻り値、ローカル変数などを含めることができ、通常の関数のように使用できます。関数テンプレートのインスタンス化は、呼び出された時点で完了します。つまり、特定の関数は、使用時にテンプレートパラメーターに従って生成されます。
したがって、クラステンプレートと関数テンプレートの違いは、クラステンプレートはクラスの生成に使用され、関数テンプレートは関数の生成に使用されることです。クラステンプレートのインスタンス化はコンパイル時に行われ、関数テンプレートのインスタンス化は呼び出し時に行われます。

「クラステンプレートのインスタンス化はコンパイル時に行う」について

クラステンプレートは、さまざまな種類のデータを処理するために使用できる汎用クラスです。クラステンプレートを使用する場合、特定の型パラメーターを指定する必要があります。その後、コンパイラーはこれらの型パラメーターに基づいて特定のクラスを生成します。このプロセスは、クラステンプレートのインスタンス化と呼ばれます。

クラステンプレートのインスタンス化はコンパイル時に行われます。つまり、コンパイラがソースコードをコンパイルすると、テンプレートパラメーターに従って特定のクラスコードが生成され、実行可能ファイルにコンパイルされます。このようにして、プログラムの実行中に、これらの生成された具象クラスをインスタンス化せずに直接使用できます。

たとえば、ジェネリッククラステンプレートを定義します。

template<typename T>
class MyVector {
    
    
    // ...
};

このクラステンプレートを使用する場合、次のような特定の型パラメーターを指定する必要があります。

MyVector<int> v1;
MyVector<double> v2;

コンパイル時に、コンパイラはこれらの型パラメーターに基づいて特定のクラスコードを生成します。次に例を示します。

class MyVector_int {
    
    
    // ...
};

class MyVector_double {
    
    
    // ...
};

その後、実行可能ファイルにコンパイルされます。このようにして、プログラムの実行中に、これらの生成された具象クラスをインスタンス化せずに直接使用できます。

「自動型推論なしでクラステンプレートを利用する」について

C++11 では、変数の初期化式に従ってコンパイラが変数の型を自動的に推定できるようにする、自動型推定の機能が導入されています。ただし、クラステンプレートは自動型推論の使用をサポートしていません。

クラステンプレートの型パラメーターはコンパイル時に決定する必要がありますが、自動型推定は実行時に決定されます。したがって、クラステンプレートは自動型推定の使用をサポートしていません。

たとえば、次のコードは間違っています。

template<typename T>
class MyVector {
    
    
    // ...
};

auto v = MyVector{
    
    1, 2, 3}; // 错误：类模板不支持自动类型推导的使用方式
MyVector v{
    
    1, 2, 3}; 		// 错误：类模板不支持自动类型推导的使用方式

この例では、自動型推定を使用して変数 v を定義していますが、MyVector はクラステンプレートであるため、コンパイラは初期化式に従って MyVector の型パラメーターを推定できず、エラーが報告されます。

クラステンプレートを使用する場合は、型パラメーターを明示的に指定する必要があります。次に例を示します。

MyVector<int> v{
    
    1, 2, 3}; 						// 正确：显式指定了类型参数
MyVector< int > v = MyVector< int >{
    
    1, 2, 3};	// 正确：显式指定了类型参数

この例では、MyVector の型パラメーターを int として明示的に指定したため、クラステンプレートを正しく使用できます。

例

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;

// 类模板
template <class NameType, class AgeType = int>
class Person
{
    
    
public:
    Person(NameType name, AgeType age)
    {
    
    
        this->mName = name;
        this->mAge = age;
    }
    void showPerson()
    {
    
    
        cout << "name: " << this->mName << " age: " << this->mAge << endl;
    }

public:
    NameType mName;
    AgeType mAge;
};

// 1、类模板没有自动类型推导的使用方式
void test01()
{
    
    
    // Person p("孙悟空", 1000); // 错误 类模板使用时候，不可以用自动类型推导
    Person<string, int> p("孙悟空", 1000); // 必须使用显示指定类型的方式，使用类模板
    p.showPerson();
}

// 2、类模板在模板参数列表中可以有默认参数
void test02()
{
    
    
    Person<string> p("猪八戒", 999); // 类模板中的模板参数列表 可以指定默认参数
    p.showPerson();
}

int main()
{
    
    

    test01();

    test02();

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

操作結果:

ここに画像の説明を挿入

要約:

クラステンプレートは、型を明示的に指定する場合にのみ使用できます
クラステンプレートのテンプレートパラメーターリストには、既定のパラメーターを含めることができます

1.3.3 クラステンプレートにメンバー関数を作成するタイミング（通常のクラスのメンバー関数は最初に作成でき、クラステンプレートのメンバー関数は呼び出し時に作成されます）

クラステンプレートのメンバー関数と通常のクラスのメンバー関数の作成タイミングに違いがあります。

通常のクラスのメンバー関数は最初から作成可能
クラステンプレートのメンバー関数は、呼び出されたときに作成されます。

例

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;

class Person1
{
    
    
public:
    void showPerson1()
    {
    
    
        cout << "Person1 show" << endl;
    }
};

class Person2
{
    
    
public:
    void showPerson2()
    {
    
    
        cout << "Person2 show" << endl;
    }
};

template <class T>
class MyClass
{
    
    
public:
    T obj;

    // 类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成

    void fun1() {
    
     obj.showPerson1(); }
    void fun2() {
    
     obj.showPerson2(); }
};

void test01()
{
    
    
    MyClass<Person1> m;

    m.fun1();

    // m.fun2();//编译会出错，说明函数调用才会去创建成员函数
}

int main()
{
    
    

    test01();

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

操作結果:

ここに画像の説明を挿入

クラステンプレートの静的メンバー関数に加えて、通常のメンバー関数は、テンプレートがインスタンス化されるときに、この関数が使用時にテンプレートパラメーターの型に依存しない場合でも、新しい関数を生成します。

クラステンプレートのメンバー関数が通常のメンバー関数である場合、テンプレートがインスタンス化されるときに新しい関数が生成されます。

例えば：

template<typename T>
class MyClass {
public:
    void print() {
        std::cout << "Hello, world!" << std::endl;
    }
};

この例では、print関数はテンプレートパラメーターの型に依存しなくなりましたが、通常のメンバー関数であるため、テンプレートがインスタンス化されると新しい関数が生成されます。MyClass<int>またはを使用するかどうかで、MyClass<double>さまざまな関数が生成されます。

MyClass<int> myInt;
myInt.print();    // 生成一个函数 void MyClass<int>::print()

MyClass<double> myDouble;
myDouble.print(); // 生成一个函数 void MyClass<double>::print()

したがって、クラステンプレート内のメンバー関数が通常のメンバー関数である場合、テンプレートがインスタンス化されるときに新しい関数が生成されます。

1.3.4 関数パラメーターとしてのクラステンプレートオブジェクト (`类模板对象`これらの言葉に注意してください。オブジェクトは通常のオブジェクトではありませんが、`类模板对象`)

学習目標:

クラステンプレートからインスタンス化されたオブジェクト、関数にパラメーターを渡す方法

次の 3 つの入力方法があります。

入力タイプを指定 — オブジェクトのデータタイプを直接表示
パラメータテンプレート — オブジェクト内のパラメータをテンプレートに変換して渡す
テンプレート化されたクラス全体 — このオブジェクトタイプを渡すためのテンプレート

パラメーターを渡す 3 つの方法の例: 受信型の指定、パラメーターのテンプレート化、およびクラス全体のテンプレート化 (以下のコードでは、 Person is one `类模板对象`)

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;

// 类模板
template <class NameType, class AgeType = int>
class Person
{
    
    
public:
    Person(NameType name, AgeType age)
    {
    
    
        this->mName = name;
        this->mAge = age;
    }
    void showPerson()
    {
    
    
        cout << "name: " << this->mName << " age: " << this->mAge << endl;
    }

public:
    NameType mName;
    AgeType mAge;
};

// 1、指定传入的类型
void printPerson1(Person<string, int> &p)
{
    
    
    p.showPerson();
}
void test01()
{
    
    
    Person<string, int> p("孙悟空", 100);
    printPerson1(p);
}

// 2、参数模板化
template <class T1, class T2>
void printPerson2(Person<T1, T2> &p)
{
    
    
    p.showPerson();
    cout << "T1的类型为： " << typeid(T1).name() << endl;
    cout << "T2的类型为： " << typeid(T2).name() << endl;
}
void test02()
{
    
    
    Person<string, int> p("猪八戒", 90);
    printPerson2(p);
}

// 3、整个类模板化
template <class T>
void printPerson3(T &p)
{
    
    
    cout << "T的类型为： " << typeid(T).name() << endl;
    p.showPerson();
}
void test03()
{
    
    
    Person<string, int> p("唐僧", 30);
    printPerson3(p);
}

int main()
{
    
    
    test01();
    test02();
    test03();

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

操作結果:

ここに画像の説明を挿入

1.3.5 クラステンプレートと継承（サブクラスが継承する親クラスがクラステンプレートの場合、サブクラスを宣言する際、親クラスに T の型を指定する必要がある; の型を柔軟に指定したい場合）親クラスのT、サブクラスもクラステンプレートになる必要があります)

クラステンプレートで継承が発生した場合は、次の点に注意する必要があります。

サブクラスによって継承された親クラスがクラステンプレートの場合、サブクラスは宣言時に親クラスの T の型を指定する必要があります。指定されていない場合、コンパイラはサブクラスにメモリを割り当てることができません。
親クラスでTの型を柔軟に指定したい場合は、サブクラスもクラステンプレートになる必要がある

例

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;

template <class T>
class Base
{
    
    
    T m;
};

// class Son:public Base  //错误，c++编译需要给子类分配内存，必须知道父类中T的类型才可以向下继承
class Son : public Base<int> // 必须指定一个类型
{
    
    
};
void test01()
{
    
    
    Son c;
}

// 类模板继承类模板 ,可以用T2指定父类中的T类型
template <class T1, class T2>
class Son2 : public Base<T2>
{
    
    
public:
    Son2()
    {
    
    
        cout << typeid(T1).name() << endl;
        cout << typeid(T2).name() << endl;
    }
};

void test02()
{
    
    
    Son2<int, char> child1;
}

int main()
{
    
    
    test01();

    test02();

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

操作結果:

ここに画像の説明を挿入

1.3.6 クラステンプレートのメンバー関数のクラス外実装 (テンプレートを追加する必要があります...)

学習目標: クラス外のクラステンプレートでメンバー関数の実装をマスターできるようになること

例

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;

// 类模板中成员函数类外实现
template <class T1, class T2>
class Person
{
    
    
public:
    // 成员函数类内声明
    Person(T1 name, T2 age);
    void showPerson();

public:
    T1 m_Name;
    T2 m_Age;
};

// 构造函数 类外实现
template <class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
    
    
    this->m_Name = name;
    this->m_Age = age;
}

// 成员函数 类外实现
template <class T1, class T2>
void Person<T1, T2>::showPerson()
{
    
    
    cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}

void test01()
{
    
    
    Person<string, int> p("Tom", 20);
    p.showPerson();
}

int main()
{
    
    
    test01();

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

操作結果:

ここに画像の説明を挿入

1.3.7 クラステンプレートがファイルに分割されている (`类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到`問題に注意)

学習目標:

ファイルをクラステンプレートのメンバー関数に分割することによって生じる問題と解決策をマスターする

問題の原因

質問：

クラステンプレートのメンバー関数の作成時が呼び出しフェーズにあるため、サブファイルの書き込み時にリンクに失敗する

この問題は、C++ クラステンプレートのメンバー関数が、コンパイル段階ではなく、呼び出し段階で作成されるために発生します。これは、1 つのソースファイルでクラステンプレートを定義し、別のソースファイルでこのクラステンプレートのメンバー関数を使用する場合、コンパイラは 2 番目のソースファイルの関数定義をコンパイルするときにそれらのメンバーを見つけられず、リンクエラーが発生することを意味します。
この問題を解決するには、クラステンプレートの定義と実装をヘッダーファイルに配置し、このヘッダーファイルを、このクラステンプレートを使用する必要があるソースファイルに含める必要があります。このようにして、コンパイラは各ソースファイルをコンパイルするときにクラステンプレートの定義と実装を確認できるため、リンクエラーを回避できます。

例 (cg3.5 を参照):

動的配列を表すクラステンプレート MyVector があるとします。その定義と実装は、それぞれ MyVector.h と MyVector.cpp にあります。

MyVector.h：

#ifndef MYVECTOR_H
#define MYVECTOR_H

template<typename T>
class MyVector {
    
    
public:
    MyVector();
    void push_back(const T& value);
private:
    T* data;
    int size;
    int capacity;
};

#endif

MyVector.cpp：

#include "MyVector.h"

template<typename T>
MyVector<T>::MyVector() {
    
    
    data = nullptr;
    size = 0;
    capacity = 0;
}

template<typename T>
void MyVector<T>::push_back(const T& value) {
    
    
    // ...
}

次に、別のソースファイル main.cpp で MyVector のメンバー関数を使用します。

#include "MyVector.h"

int main() {
    
    
    MyVector<int> vec;
    vec.push_back(1);
    return 0;
}

main.cpp をコンパイルすると、コンパイラMyVector<T>::MyVector()はMyVector<T>::push_back()との定義を見つけることができず、リンクエラーが発生します。

ここに画像の説明を挿入

これを修正するには、クラステンプレートの定義と MyVector.h からの実装の両方をヘッダーファイルに配置する必要があります。

MyVector.h：

#ifndef MYVECTOR_H
#define MYVECTOR_H

template<typename T>
class MyVector {
    
    
public:
    MyVector() {
    
    
        data = nullptr;
        size = 0;
        capacity = 0;
    }
    void push_back(const T& value) {
    
    
        // ...
    }
private:
    T* data;
    int size;
    int capacity;
};

#endif

したがって、main.cpp に MyVector.h を含めるとうまくいきます。

#include "MyVector.h"

int main() {
    
    
    MyVector<int> vec;
    vec.push_back(1);
    return 0;
}

コンパイルして実行します。

ここに画像の説明を挿入

解決

解決：

解決策 1: .cpp ソースファイルを直接インクルードする
解決策 2: 宣言と実装を同じファイルに書き込み、接尾辞を .hpp に変更します。hpp は合意された名前であり、必須ではありません (主流の解決策)

例

person.hpp のコード:

#pragma once
#include <iostream>
using namespace std;
#include <string>

template<class T1, class T2>
class Person {
    
    
public:
	Person(T1 name, T2 age);
	void showPerson();
public:
	T1 m_Name;
	T2 m_Age;
};

//构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {
    
    
	this->m_Name = name;
	this->m_Age = age;
}

//成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson() {
    
    
	cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}

クラステンプレートファイルのコードを classTemplateSubFile.cpp に記述します。

#include<iostream>
using namespace std;

//#include "person.h"
#include "person.cpp" //解决方式1，包含cpp源文件

//解决方式2，将声明和实现写到一起，文件后缀名改为.hpp
#include "person.hpp"
void test01()
{
    
    
	Person<string, int> p("Tom", 10);
	p.showPerson();
}

int main() {
    
    

	test01();

	system("pause");

	return 0;
}

コンパイルして実行します。

ここに画像の説明を挿入

1.3.8 クラステンプレートとフレンド (1. フレンドグローバル関数のクラス内実装 2. フレンドグローバル関数のクラス外実装)

Youyuan について、わからない場合は、以前のノートを参照してください。 [Dark Horse Programmer C++ チュートリアル 0 から 1 プログラミング入門] [ノート 4] C++ コアプログラミング (クラスとオブジェクト - カプセル化、アクセス許可、オブジェクトの初期化)およびクリーンアップ、構築関数、デストラクタ、ディープコピー、シャローコピー、イニシャライザリスト、フレンド、演算子のオーバーロード)

学習目標:

クラステンプレートとフレンド関数のクラス内およびクラス外の実装をマスターする

クラス内でのグローバル関数の実装 - クラス内でフレンドを直接宣言するだけです

グローバル関数のクラス外実装 - グローバル関数の存在を事前にコンパイラに知らせる必要がある

例

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;

// 2、全局函数配合友元  类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元
template <class T1, class T2>
class Person;

// 如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
// template<class T1, class T2> void printPerson2(Person<T1, T2> & p);

template <class T1, class T2>
void printPerson2(Person<T1, T2> &p)
{
    
    
    cout << "类外实现 ---- 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
}

template <class T1, class T2>
class Person
{
    
    
    // 1、全局函数配合友元   类内实现
    friend void printPerson(Person<T1, T2> &p)
    {
    
    
        cout << "类内实现 ---- 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
    }

    // 全局函数配合友元  类外实现
    friend void printPerson2<>(Person<T1, T2> &p);

public:
    Person(T1 name, T2 age)
    {
    
    
        this->m_Name = name;
        this->m_Age = age;
    }

private:
    T1 m_Name;
    T2 m_Age;
};

// 1、全局函数在类内实现
void test01()
{
    
    
    Person<string, int> p("Tom", 20);
    printPerson(p);
}

// 2、全局函数在类外实现
void test02()
{
    
    
    Person<string, int> p("Jerry", 30);
    printPerson2(p);
}

int main()
{
    
    

    test01();

    test02();

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

操作結果:

ここに画像の説明を挿入

1.3.9 クラステンプレートケース (クラステンプレートを使用してジェネリック配列を構築する)

ケースの説明: 一般的な配列クラスを実装するための要件は次のとおりです。

組み込みデータ型とカスタムデータ型のデータを格納できます
配列内のデータをヒープに格納する
コンストラクターに渡すことができる配列の容量
浅いコピーの問題を防ぐために、対応するコピーコンストラクターと operator= を提供します。
配列内のデータを追加および削除する末尾挿入および末尾削除メソッドを提供する
配列内の要素には、添え字を付けてアクセスできます
配列内の現在の要素数と配列の容量を取得できます

例

myArray.hpp

#pragma once
#include <iostream>
using namespace std;

template <class T>
class MyArray
{
    
    
public:
	// 构造函数
	MyArray(int capacity)
	{
    
    
		this->m_Capacity = capacity;
		this->m_Size = 0;
		pAddress = new T[this->m_Capacity]; // pAddress = new T[this->m_Capacity]; 是在堆内存中分配了一块大小为 m_Capacity * sizeof(T) 的连续内存空间，并将其首地址赋值给指针 pAddress。这里使用了 new 运算符来动态分配内存，T 是模板参数，可以是任意类型。
	}

	// 拷贝构造
	MyArray(const MyArray &arr)
	{
    
    
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < this->m_Size; i++)
		{
    
    
			// 如果T为对象，而且还包含指针，必须需要重载 = 操作符，因为这个等号不是 构造 而是赋值，
			//  普通类型可以直接= 但是指针类型需要深拷贝
			this->pAddress[i] = arr.pAddress[i];
		}
	}

	// 重载= 操作符  防止浅拷贝问题
	MyArray &operator=(const MyArray &myarray)
	{
    
    

		if (this->pAddress != NULL)
		{
    
    
			delete[] this->pAddress;	// 在 C++ 中，使用 new 运算符动态分配数组内存空间时，编译器会在分配内存空间时，额外存储一个整数，用于记录数组的大小。这个整数通常被称为“数组长度”，它存储在数组内存空间的前面，占用 4 个字节（32 位系统）或 8 个字节（64 位系统）的空间。当我们使用 delete[] 运算符释放动态分配的数组内存空间时，编译器会自动读取数组长度，并根据数组长度计算出整个数组所占用的内存空间的大小，然后释放该内存空间。因此，我们不需要手动计算数组的大小，也不需要手动释放数组内存空间，编译器会自动完成这些工作。
										// 这里的 delete[] this->pAddress; 是用来释放 this->pAddress 所指向的动态数组内存空间的语句。delete[] 是 C++ 中用来释放动态分配的数组内存空间的运算符，它会调用数组元素的析构函数，并释放数组所占用的内存空间。在这个代码中，this->pAddress 指向的是一个动态分配的数组，通过 delete[] this->pAddress; 释放该数组所占用的内存空间，避免了内存泄漏的问题。
			this->m_Capacity = 0;
			this->m_Size = 0;
		}

		this->m_Capacity = myarray.m_Capacity;
		this->m_Size = myarray.m_Size;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < this->m_Size; i++)
		{
    
    
			this->pAddress[i] = myarray[i];
		}
		return *this;
	}

	// 重载[] 操作符  arr[0]
	T &operator[](int index)
	{
    
    
		return this->pAddress[index]; // 不考虑越界，用户自己去处理
	}

	// 尾插法
	void Push_back(const T &val)
	{
    
    
		if (this->m_Capacity == this->m_Size)
		{
    
    
			return;
		}
		this->pAddress[this->m_Size] = val;
		this->m_Size++;
	}

	// 尾删法
	void Pop_back()
	{
    
    
		if (this->m_Size == 0)
		{
    
    
			return;
		}
		this->m_Size--;
	}

	// 获取数组容量
	int getCapacity()
	{
    
    
		return this->m_Capacity;
	}

	// 获取数组大小
	int getSize()
	{
    
    
		return this->m_Size;
	}

	// 析构
	~MyArray()
	{
    
    
		if (this->pAddress != NULL)
		{
    
    
			delete[] this->pAddress;
			this->pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}
	}

private:
	T *pAddress;	// 指向一个堆空间，这个空间存储真正的数据
	int m_Capacity; // 容量
	int m_Size;		// 大小
};

arrayClassEncapsulation.cpp

#include "myArray.hpp"
#include <string>
#include <limits>

void printIntArray(MyArray<int> &arr)
{
    
    
    for (int i = 0; i < arr.getSize(); i++)
    {
    
    
        cout << arr[i] << " ";
    }
    cout << endl;
}

// 测试内置数据类型
void test01()
{
    
    
    MyArray<int> array1(10);
    for (int i = 0; i < 10; i++)
    {
    
    
        array1.Push_back(i);
    }
    cout << "array1打印输出：" << endl;
    printIntArray(array1);
    cout << "array1的大小：" << array1.getSize() << endl;
    cout << "array1的容量：" << array1.getCapacity() << endl;

    cout << "--------------------------" << endl;

    MyArray<int> array2(array1);
    array2.Pop_back();
    cout << "array2打印输出：" << endl;
    printIntArray(array2);
    cout << "array2的大小：" << array2.getSize() << endl;
    cout << "array2的容量：" << array2.getCapacity() << endl;

    cout << "--------------------------" << endl;
}

// 测试自定义数据类型
class Person
{
    
    
public:
    Person() {
    
    }
    Person(string name, int age)
    {
    
    
        this->m_Name = name;
        this->m_Age = age;
    }

public:
    string m_Name;
    int m_Age;
};

void printPersonArray(MyArray<Person> &personArr)
{
    
    
    for (int i = 0; i < personArr.getSize(); i++)
    {
    
    
        cout << "姓名：" << personArr[i].m_Name << " 年龄： " << personArr[i].m_Age << endl;
    }
}

void test02()
{
    
    
    // 创建数组
    MyArray<Person> pArray(10);
    Person p1("孙悟空", 30);
    Person p2("韩信", 20);
    Person p3("妲己", 18);
    Person p4("王昭君", 15);
    Person p5("赵云", 24);

    // 插入数据
    pArray.Push_back(p1);
    pArray.Push_back(p2);
    pArray.Push_back(p3);
    pArray.Push_back(p4);
    pArray.Push_back(p5);

    printPersonArray(pArray);

    cout << "pArray的大小：" << pArray.getSize() << endl;
    cout << "pArray的容量：" << pArray.getCapacity() << endl;

    cout << "--------------------------" << endl;
}

int main()
{
    
    

    test01();

    test02();

    std::cout << "Press ENTER to continue...";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键
    return EXIT_SUCCESS;
}

操作結果:

ここに画像の説明を挿入