C++: テンプレートの拡張と継承

テンプレートの詳細

1. 非型テンプレートパラメータ

テンプレート パラメータ: 型パラメータと非型パラメータ。

型パラメータ: テンプレート パラメータ リストに表示され、クラス名または型名に従いますパラメータの型名。

非型パラメータ: クラス (関数) テンプレートのパラメータとして定数を使用します。クラス (関数) で使用できます。テンプレート< a i=7>このパラメータを定数として使用します。

// 定义一个模板类型的静态数组
template<class T, size_t N = 10>
class array
{
    
    
public:
	T& operator[](size_t index) {
    
     return _array[index]; }
	const T& operator[](size_t index)const {
    
     return _array[index]; }

	size_t size()const {
    
     return _size; }
	bool empty()const {
    
     return 0 == _size; }

private:
	T _array[N];
	size_t _size;
};

知らせ：

1. 型以外のパラメータはほとんど使用されません。 は整数 にのみ指定でき、double または double に指定した場合はエラーが報告されます。一連のカスタム タイプ。
2. 型以外のテンプレート パラメータはコンパイル中に結果を決定する必要があるため、 定数を指定する必要があります。

2.テンプレートの特化

2.1 専門化の概念

通常、テンプレートを使用すると型に依存しないコードを実装できますが、一部の特殊な型では、間違った結果が得られ、特殊な処理が必要になる場合があります。、次のような状況:

//拿日期类举例，我们比较日期类大小要比的是内容
//指针的比较是没有意义的！！！
template<class T>
bool Less(T left, T right)
{
    
    
	return left < right;
}
int main()
{
    
    
	cout << Less(1, 2) << endl; // 可以比较，结果正确
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 8);
	cout << Less(d1, d2) << endl; // 可以比较，结果正确
	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl; // 可以比较，结果不确定
	return 0;
}

2.2 関数テンプレートの特殊化

関数テンプレートの特殊化の要件:

1. まず基本的な関数テンプレートを用意する必要があります。
2. キーワード template の後には、山かっこ <> のペアが続きます。テンプレート パラメーターを内部に追加することもでき、部分的な特殊化に使用できます。
3. 関数名の後には 1 対の山括弧が続きます。山括弧は特殊化する必要がある型を指定します。
4. 関数パラメータ リストは、テンプレート関数の基本パラメータ タイプとまったく同じである必要があります。パラメータを追加したり、パラメータの位置を変更したりすることはできません。

// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{
    
    
	return left < right;
}
// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
    
    
	return *left < *right;
}
int main()
{
    
    
	cout << Less(1, 2) << endl;
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 8);
	cout << Less(d1, d2) << endl;
	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl; // 这里调用的就是特化的版本，不是指针而是内容比较
	return 0;
}

2.3 クラステンプレートの特殊化

//类模板特化和函数模板相似，只是加<>的位置变成了类名后面加
template<class T1, class T2>
class Data
{
    
    
public:
	Data() {
    
     cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

template<>
class Data<int, char>  //特化版本
{
    
    
public:
	Data() {
    
     cout << "Data<int, char>" << endl; }
private:
	int _d1;
	char _d2;
};
void TestVector()
{
    
    
	Data<int, int> d1;  //这个会通过模板生成更加合适的
	Data<int, char> d2;  //这个特化版本最合适
}

2.4 完全特化と部分特化

2.4.1全特化

完全特殊化は、テンプレート パラメータ リスト内のすべてのパラメータを決定することです。前に書いたのは完全特殊化です。

2.4.2 部分的な専門化

部分特殊化には次の 2 つの式があります。

• 部分的な特殊化: テンプレート パラメータ クラス テーブル内のパラメータの 1 つの一部を特殊化します。

template<class T1, class T2>
class Data
{
    
    
public:
	Data() {
    
     cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

// 对模板参数列表的一部分特化，这个还是比较好理解的
// 将第二个参数特化为int，注意特化必须保证有一个基础的函数模板
template <class T1>
class Data<T1, int>
{
    
    
public:
	Data() {
    
     cout << "Data<T1, int>" << endl; }
private:
	T1 _d1;
	int _d2;
};

• パラメータの制限: テンプレートの制限パラメータのタイプ

template<class T1, class T2>
class Data
{
    
    
public:
	Data() {
    
     cout << "Data<T1, T2>" << endl; }
};

//只要是指针，不管你指向什么类型你都匹配我
//两个参数偏特化为指针类型
template <class T1, class T2>
class Data <T1*, T2*>
{
    
    
public:
	Data() {
    
     cout << "Data<T1*, T2*>" << endl; }
};


//只要是引用，不管你引用什么类型你都匹配我
//不过其实和指针是一回事，引用底层就是指针
template <class T1, class T2>
class Data <T1&, T2&>
{
    
    
public:
	Data() {
    
     cout << "Data<T1&, T2&>" << endl; }
};

// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
    
    
public:
	Data() {
    
     cout << "Data<T1, int>" << endl; }
};

int main()
{
    
    
	Data<double, int> d1; // 调用特化的int版本
	Data<int, double> d2; // 调用基础的模板生成合适的 
	Data<int*, int*> d3; // 调用特化的指针版本
	Data<int&, int&> d4; // 调用特化的引用版本
	return 0;
}

3. テンプレートの個別コンパイル

結論から始めましょう: 一般的に、 テンプレート では、宣言と定義を分離することは推奨されません。必要に応じて、 同時に分割してみてください。ファイル内で分割してください。

3.1 ファイルの分離

namespace My
{
    
    
	template<class T>
	class A
	{
    
    
	public:
		typedef T* ptr;  //T类型指针
		ptr operator&();  //取到T类型指针

		T get();
	private:
		T _a;
	};
}

//写简单一点，就分离两个函数好了
//分离编译的时候A<T>还没有完全实例化
//不知道ptr是类型还是静态成员，所以需要加typename指定它是类型
//另外需要用类域限定符指定该函数（类型）属于那个空间中的那个类
template<class T>
typename My::A<T>::ptr My::A<T>::operator&()  //取到T类型指针
{
    
    
	return &_a;
}

template<class T>
T My::A<T>::get()
{
    
    
	return _a;
}

3.2 別ファイルでの分割

C/C++ プログラムでは、各ソース ファイルはリンク前に互いに独立しており、テンプレートではコンパイル前にテンプレート パラメータのタイプを決定する必要があります。< a i= 2> では、テンプレートがインスタンス化されます。分割されたファイルの最大の問題は、 分割された部分ではパラメータの型 (T) を決定できない ことです。インスタンス化できません。

//a.h,这里写一起是方便看，实际在不同文件
namespace My
{
    
    
	template<class T>
	class A
	{
    
    
	public:
		typedef T* ptr;  //T类型指针
		ptr operator&();  //取到T类型指针

		T get();
	private:
		T _a;
	};
}

//a.cpp
#include "a.h"
//这里因为A<T>还没有完全实例化，可以理解为实例化过程中分离的部分和内部是隔离的
//也就是说不知道指定的内容是类型还是静态变量，需要加typename指定它是类型
template<class T>
typename My::A<T>::ptr My::A<T>::operator&()  //取到T类型指针
{
    
    
	return &_a;
}

template<class T>
T My::A<T>::get()
{
    
    
	return _a;
}

//test.cpp
#include "a.h"
int main()
{
    
    
	My::A<int> a;
	a.get();  //调了一下这个分离的函数
	return 0;
}

実行結果を見てみましょう:

ここで報告されるエラーはリンク エラーであり、実際には get 関数です。関数はそうではありません。まったくインスタンス化されていません出てきました。インスタンス化を表示することでこの問題を解決できます。

//a.cpp
template<class T>
typename My::A<T>::ptr My::A<T>::operator&()  //取到T类型指针
{
    
    
	return &_a;
}

template<class T>
T My::A<T>::get()
{
    
    
	return _a;
}

template
My::A<int>;  //告诉了T类型，你去实例化

ただし、表示のインスタンス化には非常に制限があり、異なる型を一度に記述する必要があるため、分離したい場合は、やはり最初の書き方をお勧めします。

継承する

1. 継承の概念と定義

1.1 継承の概念

継承メカニズムは、コードの再利用を可能にするオブジェクト指向プログラミングの最も重要な手段です。これにより、プログラマーは /span>を表し、単純なものから複雑なものまでの認知プロセスを具体化します。これまで私たちが接してきた再利用は関数の再利用であり、継承はクラス設計レベルでの再利用でした。 は、 オブジェクト指向プログラミングの階層構造し、機能を追加して新しいクラスを生成します。これを派生クラスと呼びます。継承元のクラスの特徴を維持したまま拡張

1.2 継承の定義

1.2.1 フォーマットの定義

1.2.2 継承関係とアクセス修飾子

ここで話しましょうほとんどの継承はパブリック継承です、C++ では保護されています このアクセス修飾子は相続の準備。

これら 9 つの状況を表で示しますが、 全員がこの表を覚える必要はありません。概要 1 と 2 を見てください。

概要:

1. 基本クラスのプライベート メンバー は、派生クラスには表示されません (非表示: ① クラス外からアクセスできません。 ② 非表示、 は派生クラス内ではアクセスできないため、継承されます)。
2. 基本クラスの他のメンバー派生クラスのアクセス モード == Min (基本クラスのアクセス修飾子のメンバー> 、継承メソッド)、つまり、最も小さい権限を持つ人がそれを取得し、パブリック > 保護 > プライベートと見なされます。
3. 派生クラスをほとんどのクラスと同じようにしたい場合は、他のユーザーが public でアクセスできるようにする基本クラスのメンバーと、公開しないメンバーを変更できます。他の人が保護された状態でアクセスすることは望ましくありません。最後にパブリック継承を使用してください。
4. 継承メソッドを記述する必要はありません。キーワード class を使用する場合、デフォルトの継承メソッドはプライベートであり、構造体を使用する場合、デフォルトの継承メソッドはパブリックです。ただし明示的に記述することをお勧めします。継承モード。

2. 基底クラスと派生クラスのオブジェクト代入変換

• 派生クラス オブジェクトは、①基本クラスオブジェクト ②基本クラスポインタに代入できます。 > ③基底クラスの参照。ここにはスライスまたは切断と呼ばれる生き生きとした格言があります。これは、派生クラスの親クラス部分を切り取って に割り当てることを意味します。
• 基本クラス オブジェクトを派生クラス オブジェクトに割り当てることはできません (派生クラスには基本クラス部分がありますが、基本クラスには派生クラス部分がありません)。
  

class Person
{
    
    
protected:
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};
class Student : public Person
{
    
    
public:
	int _No; // 学号
};
void Test()
{
    
    
	Student sobj;
	// 1.子类对象可以赋值给父类对象/指针/引用
	Person pobj = sobj;
	Person* pp = &sobj;
	Person& rp = sobj;

	//2.基类对象不能赋值给派生类对象
	sobj = pobj;

	// 3.基类的指针可以通过强制类型转换赋值给派生类的指针
	pp = &sobj;
	Student * ps1 = (Student*)pp; // 这种情况转换时可以的。
	ps1->_No = 10;

	pp = &pobj;
	Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问
	ps2->_No = 10;
}

3. 継承の範囲

1. 継承システム内基本クラスと派生クラスすべてに独立したスコープがあります。
2. 派生クラスと基本クラスに同じ名前のメンバーがあり、派生クラスのメンバーは 親クラスからシールドされている 同じ名前のメンバーへの直接アクセス、この状況は非表示と呼ばれ、再定義とも呼ばれます。 (派生クラスのメンバー関数では、明示的なアクセスに基本クラス::基本クラスのメンバーを使用できます)
3. メンバー関数の非表示の場合、関数名が同じであるだけで非表示が構成されることに注意してください。
4. 実際には、継承システムで同じ名前のメンバーを定義しないことが最善であることに注意してください。

クラスのメンバー変数は同じ名前を持ちます。

// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
    
    
protected:
	string _name = "小李子"; // 姓名
	int _num = 111;  //身份证号
};

class Student : public Person
{
    
    
public:
	void Print()
	{
    
    
		cout << " 姓名:" << _name << endl;
		cout << " 身份证号:" << Person::_num << endl; // 类名::成员显示访问
		cout << " 学号:" << _num << endl;
	}
protected:
	int _num = 999; // 学号
};
void Test()
{
    
    
	Student s1;
	s1.Print();
};

クラス命名関数には同じ名前があります。

//这里要重点区分一下函数重载，首先重载是对同一域中才有的概念，这里肯定不构成重载
//其次隐藏的要求也和重载不同，只要和基类成员函数同名就构造隐藏
class A
{
    
    
public:
	void fun()
	{
    
    
		cout << "func()" << endl;
	}
};
class B : public A
{
    
    
public:
	void fun(int i)
	{
    
    
		A::fun();  //类名::成员 还是可以访问的
		cout << "func(int i)->" << i << endl;
	}
};

void Test()
{
    
    
	B b;
	b.fun(10);
};

4.派生クラスのデフォルトメンバ関数

ここでは主に構築、=オーバーロード、破壊について説明します。残りのオーバーロードについてはほとんど意味がありません。サブクラスのこれらの関数を扱うときは原則があります。親クラスの一部を全体として扱い、親クラスの関数を呼び出してそれらを処理し、サブクラスの一部をサブクラスとして処理します。 。

4.1 構築とコピー構築

1. 初期化リストが存在するため、サブクラス コンストラクターを作成するときに親クラス コンストラクターを明示的に呼び出さなくても、親クラス コンストラクターはそれ自体を呼び出して、初期化。
2. 初期化された親クラスの内容を指定する必要がある場合は、親クラスの構造を表示できます。

class Person
{
    
    
public:
	Person(const char* name = "peter")
		: _name(name)
	{
    
    
		cout << "Person()" << endl;
	}

	Person(const Person& p)
		: _name(p._name)
	{
    
    
		cout << "Person(const Person& p)" << endl;
	}

protected:
	string _name; // 姓名
};
class Student : public Person
{
    
    
public:
	Student(const char* name, int num)
		: Person(name)
		, _num(num)
	{
    
    
		cout << "Student()" << endl;
	}

	Student(const Student& s)
		: Person(s)
		, _num(s._num)
	{
    
    
		cout << "Student(const Student& s)" << endl;
	}

protected:
	int _num; //学号
};
void Test()
{
    
    
	Student s1("jack", 18);
	Student s2(s1);
	Student s3("rose", 17);
}

4.2演算子 = ()

1. ヒープ上にリソースを持つオブジェクトに遭遇した場合、複数のリリースを避けるために、operator= を自分で記述する必要がある場合があります。
2. 構築とは異なり、サブクラスにoperator=を明示的に記述する場合、親クラスのoperator=は自動的には呼び出されず、明示的に呼び出す必要があります。< i=2>。

class Person
{
    
    
public:
	Person& operator=(const Person& p)
	{
    
    
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}
protected:
	string _name; // 姓名
};
class Student : public Person
{
    
    
public:
	Student& operator = (const Student& s)
	{
    
    
		cout << "Student& operator= (const Student& s)" << endl;
		Person::operator =(s);  //不会自动调用，必须显示调用
		_num = s._num;
		return *this;
	}
protected:
	int _num; //学号
};

4.3 デストラクタ

1. 破壊は特殊であるため、積極的に呼び出すことはできません。 はコンパイラによって自動的に呼び出される必要があります。 はサブクラス デストラクタの後に呼び出される必要があります。自分で調整してもエラーは出ませんが、反映されません。
2. なぜこのように設計されているのでしょうか？ ①後から定義する場合は破棄の順序を先にする ②子は親を利用できる 親を先に破棄すると子が親のメンバにアクセスする可能性があり、ワイルドポインタアクセスが発生する
3. したがってサブクラスの破棄を設計するときは、独自のリソースが正しく解放されることを確認するだけで済みます。

5. 継承におけるフレンドと静的メンバー

• フレンド関係は継承できません。つまり、基本クラスのフレンドはサブクラスのプライベート メンバーや保護されたメンバーにアクセスできません

class Student;
class Person
{
    
    
public:
	friend void Display(const Person& p, const Student& s);  //声明该函数是基类的友元
protected:
	string _name; // 姓名
};
class Student : public Person
{
    
    
protected:
	int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
    
    
	cout << p._name << endl;    //你是基类的友元，访问基类对象是可以的
	cout << s._stuNum << endl;  //友元不继承你不能访问派生类对象，这里会报错，显示不可访问
}

int main()
{
    
    
	Person p;
	Student s;
	Display(p, s);
	return 0;
}

• 基本クラスは静的メンバーを定義しており、そのようなメンバーは継承システム全体で 1 つだけ存在します。サブクラスがいくつ派生しても、存在する静的メンバー インスタンスは 1 つだけです。

//无论继承多少层，大家用的始终是同一个变量
class Person
{
    
    
public:
	Person() {
    
     ++_count; }
protected:
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};
int Person::_count = 0;

class Student : public Person
{
    
    
protected:
	int _stuNum; // 学号
};

class Graduate : public Student
{
    
    
protected:
	string _seminarCourse; // 研究科目
};
void TestPerson()
{
    
    
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << " 人数 :" << Person::_count << endl;
	Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl;
}

6. ダイヤモンドの継承

6.1 ダイヤモンド継承の概念

• 単一継承: サブクラス直接の親クラスが 1 つだけある場合、この継承関係は単一継承と呼ばれます
  
• 多重継承: サブクラスに 2 つ以上の直接の親クラスがある場合、この継承関係は多重継承と呼ばれます。

• ダイヤモンドの継承: ダイヤモンドの継承は多重継承の特殊なケースです。
  

6.2 ダイヤモンドの相続の危険性

ダイヤモンド継承の問題: 以下のオブジェクト メンバー モデルの構造から、ダイヤモンド継承にはデータの冗長性と曖昧さの問題があることがわかります。アシスタント オブジェクトには、個人メンバーのコピーが 2 つあります。

class Person
{
    
    
public:
	string _name; // 姓名
};

class Student : public Person
{
    
    
protected:
	int _num; //学号
};

class Teacher : public Person
{
    
    
protected:
	int _id; // 职工编号
};

class Assistant : public Student, public Teacher
{
    
    
protected:
	int _score; // 主修课程
};
void Test()
{
    
    
	// 这样会有二义性无法明确知道访问的是哪一个
	Assistant a;
	a._name = "peter";   //这个地方会报错，编译器不知道访问那个
	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
}

6.3 ダイヤモンド継承の解決策

1. 仮想継承は、ダイヤモンド継承のあいまいさとデータの冗長性の問題を解決できます。上記の継承関係で示したように、学生と教師が人を継承するときに仮想継承を使用すると、問題を解決できます。仮想継承は他の場所では使用しないでください。
2. 仮想継承のキーワードは仮想です。

class Person
{
    
    
public:
	string _name; // 姓名
};

class Student : virtual public Person
{
    
    
protected:
	int _num = 0; //学号
};

class Teacher : virtual public Person
{
    
    
protected:
	int _id = 1; // 职工编号
};

class Assistant : public Student, public Teacher
{
    
    
protected:
	int _score = 60; // 主修课程
};
void Test()
{
    
    
	Assistant a;
	a._name = "peter";   //这个时候_name其实只有一个
	a.Student::_name = "xxx";  //这里的两个显示访问其实访问的都是一个变量
	a.Teacher::_name = "yyy";
}

6.4 ダイヤモンド仮想継承の実装原理

追記: 以下の説明は上記のコードに基づいており、プログラムは 32 ビット プログラムです (便宜上)。

ただし、生徒には追加の 0x00cf5dd8 があり、教師には追加の 0x00cf5de4 があります。これら 2 つの変数は実際には 2 つのテーブルを指すポインタです。オフセットはテーブルに記録されます。このオフセットを通じて、データは生徒 (教師) の位置から _name の検索を開始します。この 2 つの ポインタは仮想実表ポインタと呼ばれ、これら 2 つのテーブルは仮想実表 と呼ばれます。

6.5 ダイヤモンドバーチャルの概要

1. 実際にはダイアモンド継承の記述は避けるようにしてください。オブジェクトが複雑でポリモーフィズムが導入されると、非常に複雑になります。
2. 第 2 に、ダイヤモンドの継承には時間がかかりますが、すべてのサブクラス オブジェクトが仮想ベース テーブルを共有するため、スペースの消費は悪くありません。

7. 継承と合成

継承関係：

class Car {
    
    
protected:
	string _colour ; // 颜色
	string _num; // 车牌号
};

class BMW : public Car {
    
    
public:
	void Drive() {
    
     cout << "好开-操控" << endl; }
};

class Benz : public Car {
    
    
public:
	void Drive() {
    
     cout << "好坐-舒适" << endl; }
};

組み合わせ関係：

class Tire {
    
    
protected:
	string _brand = "Michelin"; //品牌
	size_t _size = 17; // 尺寸

};

class Car {
    
    
protected:
	string _colour; // 颜色
	string _num; // 车牌号
	Tire _t; // 轮胎
};

• パブリック継承は is-a (B is A) 関係です。つまり、すべての派生クラス オブジェクトは基本クラス オブジェクトです。
• 組み合わせは has-a (B has A) の関係です。 B が A を結合し、すべての B オブジェクトの中に A オブジェクトが存在すると仮定します。
• 実際には、継承関係よりも組み合わせ関係が優先されます。
• 継承関係は一種の「ホワイト ボックスの再利用」です。基本クラスの内部詳細は派生クラスから見えるため、カプセル化がある程度破壊されます。派生クラスと基底クラス間の依存関係は非常に強く、結合度は高くなります。
• 組み合わせ関係は一種の「ブラック ボックスの再利用」です。オブジェクトの内部の詳細は表示されず、対応するインターフェイスのみが外部に提供されます。結合されたクラス間には強い依存関係はなく、結合度は低いです。オブジェクトの構成を優先すると、各クラスをカプセル化した状態に保つことができます。
• ただし、継承には独特の利点もあります。シナリオによっては、継承の方がセマンティックであり、ポリモーフィズムを実現するには継承が必要です。