當前位置:網站首頁>函數 / 類模板--模板2

函數 / 類模板--模板2

2022-01-27 16:33:28 入木

在這裏插入圖片描述
在這裏插入圖片描述

這樣N開20000滿足st2但是對st1太大,st1只需要100則st1會浪費很多空間

#include <iostream>
#include <array>
#include <vector>
#include <queue>
#include <functional>
using namespace std;
// 靜態的棧--不需要capacity
#define N 20000
template<class T>
class Stack
{
    
private:
	T _a[N];
	size_t _top;
};
int main()
{
    
	Stack<int> st1;  // 100
	Stack<int> st2;  // 20000
	return 0;
}

解决:使用非類型模板參數

// T是類型模板參數
// N是非類型模板參數,N是一個常量
template<class T, size_t N>
class Stack
{
    
private:
	T _a[N];
	size_t _top;
};
template<class T, size_t N>
class Array
{
    
private:
	T _a[N];
};
int main()
{
    
	Stack<int, 100> st1;  // 100
	Stack<int, 20000> st2;  // 20000
  //err下面三行
	//static int n;
	//cin >> n;
	//Stack<int, n> st2; // 20000

	// 不建議用它,因為如果數據量大,可能會引發棧不够用--一般情况下不在棧上開過大的空間
	array<int, 100000> a1; // 400000byte都在棧上

	// 建議用vector
	vector<int> v;        // 12byte在棧上
	v.resize(100000);      // 400000byte都在堆上
	return 0;
}

模板參數可以給缺省值

  • 模板參數給缺省值跟函數參數給缺省值是完全類似的
  • 可以給全缺省、 半缺省 – 必須從右往左連續缺省
template<class T = int, size_t N = 10>
class Array
{
    
private:
	T _a[N];
};
//deque做它的默認容器
template <class T, class Container = deque<T> >
class stack;
int main()
{
    
	Array<> a0;//全缺省
	Array<int> a1;
	Array<int, 100> a2;
	priority_queue<int, vector<int>, greater<int>> pq;
	return 0;
}

在這裏插入圖片描述

函數模板的特化

匹配類型可以使用特化和匹配原則
1
在這裏插入圖片描述

//模板匹配
// 模板的特化,針對某些類型進行特殊化處理
template<class T>
bool IsEqual(const T& left, const T& right)
{
    
	return left == right;
}
//left是p1的別名,前面的const是修飾*left,因為p1是const類型,所以left不能擴大功能必須為const類型,在&前又加了一個const來修飾left
bool IsEqual(const char* const & left, const char* const & right)
{
    
	return strcmp(left, right) == 0;
}
//p1直接拷貝值給left,因為不是別名所以left的改變不會影響p1所以不需要加left不需要const
//bool IsEqual(const char* left, const char* right)
//{
    
// return strcmp(left, right) == 0;
//}
int main()
{
    
	cout << IsEqual(1, 2) << endl;
	char p1[] = "hello";//數組名不允許修改,p1、p2為const的屬性
	char p2[] = "hello";
	cout << IsEqual(p1, p2) << endl;;
	return 0;
}

在這裏插入圖片描述
2


template<class T>
void Swap(T& a, T& b)
{
    
	T tmp = a;
	a = b;
	b = tmp;
}
// 模板匹配原則--進行特殊化處理--推薦這種
void Swap(vector<int>& a, vector<int>& b)
{
    
	a.swap(b);//交換vector裏的三個指針(start、finish、endofstorage)
}
// 函數模板的特化
//template<>
//void Swap<vector<int>>(vector<int>& a, vector<int>& b)
//{
    
// a.swap(b);
//}
//不支持下面這樣任意的類型,必須給出具體的類型
//template<class T>
//void Swap<vector>(vector<T>& a, vector<T>& b)
//{
    
// a.swap(b);
//}
int main()
{
    
	int x = 1, y = 2;
	Swap(x, y);
	vector<int> v1 = {
     1, 2, 3, 4 };
	vector<int> v2 = {
     10, 20, 30};
	Swap(v1, v2);
	return 0;
}

在這裏插入圖片描述

類模板的特化

匹配類型只能使用特化不能寫匹配類型

template<class T1, class T2>
class Data
{
    
public:
	//原類型
	Data() {
     cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};
// 全特化
template<>
class Data<double, double>
{
    
public:
	Data() {
     cout << "Data<double, double>" << endl; }
private:
};
// 偏特化/半特化
template<class T1>
class Data <T1, char>
{
    
public:
	Data() {
     cout << "Data<T1, char>" << endl; }
private:
};
// 偏特化/半特化:不一定是特化部分參數,而是對模板參數類型的進一步限制
template<class T1, class T2>
class Data <T1*, T2*>
{
    
public:
	Data() {
     cout << "Data<T1*, T2*>" << endl; }
private:
};
template<class T1, class T2>
class Data < T1&, T2&>
{
    
public:
	Data() {
     cout << "Data<T1&, T2&>" << endl; }
private:
};
template<class T1, class T2>
class Data < T1&, T2* >
{
    
public:
	Data() {
     cout << "Data<T1&, T2*>" << endl; }
private:
};
int main()
{
    
	Data<int, int> d1;//沒有特化走原類型
	Data<double,double> d2;//有特化走特化
	Data<double,char> d3;
	Data<int, char> d4;
	Data<int*, char*> d5;
	Data<int*, int*> d6;
	Data<int&, int&> d7;
	Data<int&, char&> d8;
	Data<int&, char*> d9;
	return 0;
}

在這裏插入圖片描述

模板不支持分離編譯

分離:在.h中放聲明,在.cpp中放定義
在這裏插入圖片描述
解决分離出現問題(F)方法

  • 方法1
    在這裏插入圖片描述
  • 方法2
    在這裏插入圖片描述

棧–模板不能分離編譯

1、棧實例化方法
test.c

#include "Func.hpp"
#include "Func.h"
int main()
{
    
	Stack<int> st1;
	Stack<double> st2;
	return 0;
}

Func.cpp

#include "Func.h"
template<class T>
Stack<T>::Stack()
{
    
	_a = new T[10];
	_top = 0;
	_capacity = 10;
}
template<class T>
Stack<T>::~Stack()
{
    
	delete[] _a;
	_a = nullptr;
}
// 解决方案一:
// 顯示指定實例化,缺陷:用一個類型就得顯示實例化一個,非常麻煩
template
class Stack < int > ;
template
class Stack < double > ;

Func.h

#pragma once
#include <iostream>
using namespace std;
template<class T>
class Stack
{
    
public:
	Stack();
	~Stack();
	void Push(const T& x);
private:
	T* _a;
	int _top;
	int _capacity;
};

2、棧部分編譯方法
test.c

#include "Func.hpp"
#include "Func.h"
int main()
{
    
	F(1);
	F(1.11);
	Print();
	Stack<int> st1;
	Stack<double> st2;
	st1.Push(1);
	return 0;
}

Func.h

#pragma once
#include <iostream>
using namespace std;
// 解决方案2:不分離編譯。聲明和定義或者直接定義在.h中
template<class T>
class Stack
{
    
public:
	Stack();
	~Stack();
	void Push(const T& x);
private:
	T* _a;
	int _top;
	int _capacity;
};
template<class T>
Stack<T>::Stack()
{
    
	_a = new T[10];
	_top = 0;
	_capacity = 10;
}
template<class T>
Stack<T>::~Stack()
{
    
	delete[] _a;
	_a = nullptr;
}
// Push有語法問題,沒有被檢查出來,編譯不報錯
// 原因,模板如果沒有實例化,編譯器不會去檢查模板內部語法錯誤
// 我們實例化了棧這個類,對類模板是按需實例化,調用了哪個成員函數就實例化誰
template<class T>
void Stack<T>::Push(const T& x)
{
    
	_a[_top] = x
		++_top;
}

模板的優缺點

在這裏插入圖片描述

版權聲明
本文為[入木]所創,轉載請帶上原文鏈接,感謝
https://cht.chowdera.com/2022/01/202201271633274184.html

隨機推薦