C++ 小白学习记录16

最新推荐文章于 2022-06-17 22:14:58 发布

yutao1131

最新推荐文章于 2022-06-17 22:14:58 发布

阅读量111

点赞数

分类专栏： c++学习文章标签： c++

本文链接：https://blog.csdn.net/yutao1131/article/details/120311484

版权

c++学习专栏收录该内容

18 篇文章 0 订阅

订阅专栏

第十六章模版与泛型编程

OOP: 能处理类型在程序运行之前都未知的情况

泛型编程: 在编译时就能获知类型

泛型代码的两个重要原则:

模板中的函数参数是const的应用(使用const可以接受更多的类型, 拷贝/不可拷贝/const/非const的)
函数体重的条件判断仅使用<比较运算符(减少对类型的要求, <可以计算出!=, >, ==).

16.1 定义模版

16.1.1 函数模版

代表任意类型. 类型参数

template <typename T, typename W, typename A >  // 指定一个类型为T
int compare(const T& v1, const W& v2) { // 模版中指定的类型
	if (v1 < v2) return -1;
	if (v2 < v1) return 1;
	return 0;
}

模版参数列表的作用很像函数参数列表

类型参数前必须使用class 或 typename, 在模板参数列表中, 这俩没有什么不同.

类型已经指定了, 代表任意值. 非类型参数, 要求必须是常量表达式.

template<unsigned N, unsigned M>
int compare(const char(&p1)[N], const char(&p2)[m]) {
	return strcmp(p1, p2);
}

inline和constexpr 的函数模板:

inline或constexpr放在模板参数之后, 返回类型之前

template <typename T> inline T min(const T&, const T&);

函数模板和类模板成员函数的定义通常放在头文件中.

16.1.2 类模板

编译器不能为类模板推断模板参数类型. 感觉就像需要使用string的地方全部换成T.

template<typename T> 
class Blob {
public:
	typedef T value_type;
	typedef typename std::vector<T>::size_type size_type;

	Blob():data(std::make_shared<std::vector<T>>()) {};
	Blob(std::initializer_list<T> il) :data(std::make_shared<std::vector<T>>(il)) {};
	size_type size() const { return data->size(); }
	bool empty() const { return data->empty(); }
	void push_back(const T& t) { data->push_back(t); }
	void push_back(T&& t) { data->push_back(std::move(t)); }
	void pop_back();
	T& back();
	T& operator[](size_type i);
private:
	std::shared_ptr<std::vector<T>> data;
	Blob check(size_type i, const T& msg) const;
};

模板形成的各个类之间没有任何关系.

当在类外完成内类声明的函数时, 仍然需要使用template<typename T> 声明类型T, 并且需要用到类名的地方, 必须在类名后面增加<T>, 如 check函数的定义为:

template<typename T>
Blob<T> Blob<T>::check(size_type i, const T& msg) const { // 类模板外使用 类模板名时需要带<T>
	// xx
}

使用类模板时:

int main(int argc, char** argv) {
	Blob<int> ia = { 0,1,2,3,4 };
}

模板嵌套, 和在类模板作用域内时可以省略<T>, 在类模板外使用类模板名时需要BlobPtr<T>

template <typename T> class BlobPtr {
public:
	BlobPtr() :curr(0) {}
	BlobPtr(Blob<T> &a, size_t sz=0):wptr(a.data), curr(sz) {} // 使用别的类模板时, 需要Blob<T>
	T& operator*() const {
		auto p = check(curr, "dereference past end");
		return (*p)[curr];
	}
	BlobPtr& operator++(); // 类模板作用域内 不需要使用BlobPtr<T>& operator++()
	BlobPtr& operator--(); // 等同于 BlobPtr<T>& operator--()
private:
	std::shared_ptr<std::vector<T>>check(std::size_t, const std::string&) const;
	std::weak_ptr<std::vector<T>> wptr;
	std::size_t curr;
};

类模板和友元:

类模板包含的非模板友元, 则友元可以访问所有模板实例

类模板包含模板友元, 则所有友元实例可以访问所有模板实例, 也可以只授权特定友元.

一对一友好关系:

template <typename> class BlobPtr; // Blob内定义友元类 使用

template<typename> class Blob; // 用于operator==的函数声明
template<typename T> // 用于operator==的函数声明
bool operator==(const Blob<T>&, const Blob<T>&); // 函数声明

template<typename T> 
class Blob {
public:
	// typedef T value_type;
	typedef typename std::vector<T>::size_type size_type;

	friend class BlobPtr<T>; //友元类
	friend bool operator==<T>(const Blob<T>&, const Blob<T>&); // 友元函数声明
    // xx
}

上述代码中, 友元类的声明中 BlobPtr<T> 和友元函数在Blob中的声明中, 使用的类型都是T, 如此则限定了, BlobPtr, operator= 中使用的类型必须和Blob中的类型一致. 即: 友好关系被限定在所有使用相同类型的Blob, BlobPtr, operator== 中.

通用和特定的模板友好关系:

分为两种, 一种是非模板类对模板类:

template<typename T> class Pal; //类模板的前置声明
class C {
	friend class Pal<C>; // 只用用C实例化的类Pal才是C的一个友元.
	template <typename T> friend class Pal2; // Pal2的所有实例都是C的友元, 此种情况不需要前置声明
};

另一种, 模板类对其他:

template<typename T> class Pal; // 类模板的前置声明
template<typename T> class C2 {
	friend class Pal<T>; // 类型为T的C2的实例和Pal的实例才是友好关系. 一对一
	template <typename X> friend class Pal2; // X可能等于T,也可能不等于T, 所有就是任意类型的C2的实例和Pal2实例都是友元关系, 多对多
	friend class Pal3; // Pal3 不需要前置声明, 所有类型的C2实例都与Pal3 是友元关系, 多对一.

};

上面代码中, 两种情况下都是一对一的需要前置声明, 其余的则不需要.

模板参数也可以声明为友元:

template<typename T> class B {
	friend T;
};

模板类型别名: 因为Blob<T>不是一个确切的类型, 所有不能使用typedef 重命名, 必须是确定的类型才可以重命名; 但是可以这么命名

typedef Blob<T> StrBlob;  // 错误
typedef Blob<string> StrBlob;

template<typename T> using twin = pair<T, T>; // 定义
twin<string>authors; // == pair<string, string>  使用方法

template<typename T> using twin2 = pair<int, T>; // 也可以固定一个类型

类模板的static成员: 所有的类模板实例都共享相同的static成员

template<typename T> class Foo {
public:
	static std::size_t cout() { return ctr; }
private:
	static std::size_t ctr;
};
template<typename T> size_t Foo<T>::ctr = 0; // 定义 跟非static成员定义相似

int main(int argc, char** argv) {
	Foo<int> fi;
	auto ct = Foo<int>::cout();
	ct = fi.cout();
	ct = Foo::cout(); // 错误, 无法确定模板实例, 所以无法使用cout函数
}

static 成员需要在模板外定义初始值

模板外部使用模板名时需要携带类型列表

// 16.16
template <typename T>
class Vec {
public:
	Vec() :elements(nullptr), first_free(nullptr), cap(nullptr) {}
	Vec(const Vec&);
	Vec(const std::initializer_list<T>&);
	Vec& operator=(const Vec&);
	Vec& operator=(Vec&&) noexcept;
	Vec(Vec&&) noexcept;
	~Vec();

	void push_back(const T&);
	void push_back(const T&&);
	size_t size() const { return first_free - elements; }
	size_t capacity() const { return cap - elements; }

	void resize(size_t);
	void resize(size_t, const T&);

	// 若 new_cap 大于当前的 capacity() ，则分配新存储，否则该方法不做任何事。
	void reserve(size_t);  // 增加vector的容量到大于或者等于 指定的值
	T* begin() const { return elements; }
	T* end() const { return first_free; }

private:
	static std::allocator<T> alloc; // 用于分配元素内存
	// 如果没有空间容纳新元素了, 则重新分配内存
	void chk_n_alloc() {
		if (size() == capacity()) reallocate();
	}
	// 用于分配足够的内存保存给定范围的元素, 并将这些元素拷贝到新分配的内存中.返回的pair中的两个指针
	// 分别指向新空间的开始位置和尾后位置.
	std::pair<T*, T*>alloc_n_copy(const T*, const T*);
	void free(); // 销毁元素并释放内存
	void reallocate(size_t); // 获得更多内存并拷贝已有元素
	T* elements; // 指向首元素的指针
	T* first_free; // 指向第一个空闲元素的指针
	T* cap; // 指向尾后位置的指针
};
template<typename T>
std::allocator<T> Vec<T>::alloc = std::allocator<T>();

template<typename T>
void Vec<T>::push_back(const T& s) {
	chk_n_alloc();
	alloc.construct(first_free++, s);
}
template<typename T>
void Vec<T>::push_back(const T&& s) {
	chk_n_alloc();
	alloc.construct(first_free++, std::move(s));
}
template<typename T>
std::pair<T*, T*>Vec<T>::alloc_n_copy(const T* b, const T* e) {
	auto data = alloc.allocate(e - b);
	return { data, uninitialized_copy(b,e, data) };
}
template<typename T>
void Vec<T>::free() {
	// elements 如果为空 说明该vec为空, 则不必释放内存
	if (elements) {
		for_each(elements, first_free, [this](T& s) { alloc.destroy(&s); });
		alloc.deallocate(elements, cap - elements);
	}
}
template<typename T>
Vec<T>::Vec(const Vec<T>& s) {
	auto newData = alloc_n_copy(s.begin(), s.end());
	elements = newData.first;
	first_free = cap = newData.second;
}
template<typename T>
Vec<T>::~Vec() {
	free();
}
template<typename T>
Vec<T>& Vec<T>::operator=(const Vec<T>& rhs) {
	auto data = alloc_n_copy(rhs.begin(), rhs.end());
	free();
	elements = data.first;
	first_free = cap = data.second;
	return *this;
}
template<typename T>
Vec<T>& Vec<T>::operator=(Vec<T>&& rrs) noexcept {
	if (this != &rrs) {
		free();
		elements = rrs.elements;
		first_free = rrs.first_free;
		cap = rrs.cap;
		rrs.elements = rrs.first_free = rrs.cap = nullptr;
	}
	return *this;
};
template<typename T>
void Vec<T>::reallocate(size_t new_size) {
	size_t newcapacity = 0;
	if (new_size == 0) newcapacity = size() ? 2 * size() : 1;
	else newcapacity = new_size;
	auto newdata = alloc.allocate(newcapacity);
	auto dest = newdata;
	auto elem = elements;
	for (size_t i = 0; i != size(); ++i)
		alloc.construct(dest++, std::move(*elem++));
	free();
	elements = newdata;
	first_free = dest;
	cap = elements + newcapacity;
}
template<typename T>
void Vec<T>::reserve(size_t new_cap) {
	if (new_cap > capacity()) {
		reallocate(new_cap);
	}
}
template<typename T>
void Vec<T>::resize(size_t count) { resize(count, T()); }
template<typename T>
void Vec<T>::resize(size_t count, const T& s) {
	if (count > size()) {
		if (count > capacity()) reallocate(2 * count);
		for (size_t t = size(); t != count; ++t) {
			alloc.construct(first_free++, s);
		}
	}
	else if (count < size()) {
		while (first_free != elements + count) alloc.destroy(--first_free);
	}
}
template<typename T>
Vec<T>::Vec(const std::initializer_list<T>& lst) {
	auto newdata = alloc_n_copy(lst.begin(), lst.end());
	elements = newdata.first;
	first_free = cap = newdata.second;
}
template<typename T>
Vec<T>::Vec(Vec<T>&& s) noexcept :elements(s.elements), first_free(s.first_free), cap(s.cap) {
	s.elements = s.first_free = s.cap = nullptr;
}

16.1.3 模板参数

模板参数名的可用范围为其声明之后至模板声明或定义结束之前
模板参数隐藏外层作用域中声明的相同名字
参数名不能被重新定义

模板声明时必须包含模板参数, 声明和定义中使用typename 后的名字可以不同

使用类的类型成员:

默认通过作用域运算符访问的名字不是类型, 是静态成员, 如vec模板中的alloc

template<typename T> std::allocator<T> Vec<T>::alloc = std::allocator<T>();

如果希望使用一个模板类型参数的类型成员, 则必须使用typename 明确

template<typename T>
typename T::value_type top(const T& c) {
	if (!c.empty()) return c.back();
	else return typename T::value_type();
}

当希望通知编译器一个名字表示类型时, 必须使用typename, 而不能使用class.

// 这个需要练习, 琢磨

默认模板实参:

template<typename T, typename F=less<T>()>  // less<T> less<int> 比较函数
bool compare(const T& v1, const T& v2, F f) {
	if (f(v1, v2)) return -1;
	if (f(v2, v1)) return 1;
	return 0;
}

模板默认实参与类模板:

无论何时使用一个类模板(类作用于内可以不用) , 都必须在模板名后接上尖括号.

template<typename T = int> class Numbers { // 默认为int类型  typename 也可以用class
public:
	Numbers(T v = 0) :val(v) {};
private:
	T val;
};

int main(int argc, char** argv) {
	Numbers<long double> lots;
	Numbers<> aaa; // 默认int
}

16.1.4 成员模板

类内是模板的成员函数叫成员模板, 不能是虚函数. 成员模板有自己的参数类型

template<typename T>
class NewCall {
	template<typename TT> void funInC(TT& a) {
		//xx
	}
	template<typename TT> void funInC2(TT&);
};

template<typename T>  // 需要类 类型参数, 同时需要成员模板 类型参数
template<typename WW>  // 此处的类型参数可以与 类内定义的类型参数不同
void NewCall<T>::funInC2(WW& w) {
	//xx
};

实例化与成员模板: 编译器会根据传入的类类型推断模板类的类型, 会根据成员函数传入的参数推断成员模板的类型.

16.1.5 控制实例化

当模板被使用时才会进行实例化. 显式实例化

extern template declaration;  // 实例化声明
template declaration; // 实例化定义
// 如
extern template class Blob<string>; // 声明
template int compare(const int&, const int&); // 定义

当编译器遇到extern声明时, 不会在本文件中实例化代码, 并且承诺在程序其他位置有该实例化的一个非extern声明/定义. 可以有多个extern声明, 必须只有一个定义.

extern 必须出现在任何使用模板之前, 否则会自动实例化.

实例化定义会实例化所有成员.

可能模板会被实例化的几种情况

声明一个类模板的指针和引用，不会引起类模板的实例化，因为没有必要知道该类的定义。
定义一个类类型的对象时需要该类的定义，因此类模板会被实例化。
在使用sizeof()时，因为需要计算对象的大小，编译器必须根据类型将其实例化出来
new 类模板被实例化
引用类模板的成员会导致类模板被编译器实例化。
需要注意的是，类模板的成员函数本身也是一个模板。标准C++要求这样的成员函数只有在被调用或者取地址的时候，才被实例化

16.1.6 效率和灵活性

//16.28 练习题参考 https://github.com/pezy/CppPrimer/tree/master/ch16

16.2 模版实参推断

16.2.1 类型转换与模板类型参数

const转换: 非const的引用/指针可以传递给一个const的

template<typename T> T fobj(T, T);
template<typename T> T fref(const T&, const T&);

string s1("aaaaaa");
const string s2("bbbb");
fobj(s1, s2);  // s2 的const被忽略
fref(s1, s2);  // s1 非const转为const

数组或函数指针: 如果形参不是引用类型, 则数组/函数类型的实参可以应用正常的指针转换, 即数组实参转换为一个指向首元素的指针, 函数实参转换为一个指向该函数类型的指针.

template<typename T> T fobj(T, T);
template<typename T> T fref(const T&, const T&);

int a[10], b[11];
fobj(a, b); // a[10] -> int*, b[11]-> int*  fobj(int*, int*)
fref(a, b); // 错误的 引用类型的形参时, 实参不转换 a[10], b[11],不是一种类型

将实参传递给带模板类型的函数形参时, 只有const转换, 数组和函数到指针的转换.

如果函数参数类型不是模板参数, 则对实参进行正常的类型转换.

// 16.34
template<typename T> int compare2(const T&, const T&);

compare2("hi", "world"); // 不合法, "hi" 转化为const char[3], "world" 转化为const char[6] 两者类型不同
compare2("bye", "daa"); // 合法, 都转化为const char(&)[4]

16.2.2 函数模板显示实参

在函数名的后面跟上<类型> 可以显式声明模板实参如:

template<typename T>
bool compare(const T& v1, const T& v2) {
	if (v1<v2) return -1;
	if (v2<v1) return 1;
	return 0;
}
// 使用
auto a = compare<std::string>("helo", "world");

16.2.3 尾置返回类型与类型转换

当出现需要返回值类型, 但是在没确定参数类型时无法确定返回值类型的情况时, 需要使用尾置指明返回值类型:

template<typename It>
auto fcn(It beg, It end) -> decltype(*beg) {
	return *beg;
}

尾置返回允许我们在参数列表之后声明返回类型.

上面的代码只能返回元素的引用, 如果想返回一个元素的拷贝则需要使用下面的代码

template<typename It>
auto fcn2(It beg, It end) -> typename remove_reference<decltype(*beg)>::type {
	return *beg;
}

remove_reference 为标准库函数, 其作用是脱去引用类型的引用部分, 其中的type 则返回脱去引用部分后剩余的类型.

如: remove_reference<int&>::type 的值为int.

类似remove_reference<T>::type 的函数还有:

16.2.4 函数指针和实参推断

可以通过函数指针实例化函数模板. 重载的函数需要明确究竟是哪个版本的模板.

template<typename T> int compare(const T&, const T&);
// 函数重载
void func(int(*)(const string&, const string&));
void func(int(*)(const int&, const int&));

// 使用
int (*pf1)(const int&, const int&) = compare; // T = int
func(compare<int>); // 调用重载的func, 但是需要指明compare到底是哪个? 是string版本还是int版本

当参数是一个函数模板实例的地址时, 程序必须满足对每个模板参数,能唯一确定其类型或值

16.2.5 模板实参推断和引用

从左值引用函数参数推断类型:

template<typename T> void f1(T&) 需要传入的类型必须是一个左值. 如果传入的const int, 则T就是const int

template<typename T>void f2(const T&) 可以传入任何参数包括一个右值. 此时会忽略掉顶层const. 如f2(ci) 如果ci 是const int的, 则T 仍然是int的

template<typename T>void f3(T&&) 右值推断和左值相同

引用折叠和右值引用参数:

两种列外:

当我们将一个左值(如i)传递给函数的右值引用参数(如f3), 且此右值引用指向模板类型参数(如T&&)时, 编译器推断模板类型参数为实参(i)的左值引用类型. 所以f3(i) 中 T的类型为int&
引用会折叠. 如 X& &, X& &&, X&& & 都会折叠成类型X&, X&& && 折叠成 X&&

引用折叠只能应用于简介创建的引用的引用, 如果类型别名或模板参数.

16.2.6 std::move

static_cast 可以显式的将一个左值转换为一个右值引用.

template<typename T>
typename remove_reference<T>::type&& move(T&& t) {
	return static_cast<typename remove_reference<T>::type&&>(t);
}
// 当move传入的是一个左值时, 就变成string&& move(string &t)
// static_cast<string&&>(t) t的类型为string&, cast 将一个左值引用转化为右值引用

16.2.7 转发

可以利用模板参数是右值引用的特性, 保留函数的参数的所有属性, 即: 如果一个函数参数是指向模板类型参数的右值引用(T&&), 它对应的实参的const属性和左值/右值属性将得到保持. 当用于一个指向模板参数类型的右值引用函数参数(T&&)时, forward 会保持实参类型的所有细节.

template<typename F, typename T1, typename T2>
void flip(F f, T1&& t1, T2&& t2) {
	f(std::forward<T2>(t2), std::forward<T1>(t1));
}
// 此种定义可以完美保存t1, t2的属性, 并实现反转

16.3 重载与模版

函数模板可以被另一个模板或普通非模板函数重载.

重载后的匹配规则:

对于一个调用, 其候选函数包括所有模板参数推断成功的函数模板实例
候选的函数模板总是可行的, 因为模板实参推断会排除任何不可行的模板.
可行函数(模板和非模板)按类型转换来排序
如果有一个函数提供比任何其他函数都更好的匹配, 则选择此函数.如果有多个函数提供同样好的匹配, 则:

如果同样好的函数中只有一个是非模板函数, 则选择此函数.
如果同样好的函数中没有非模板函数, 而有多个函数模板, 且其中一个模板比其他模板更特例化, 则选择此模板
否则, 此调用有歧义

16.4 可变参数模版

可以接收可变数目参数的模板函数或模板类. 可变数目的参数 -- 参数包. 符号 ... 省略号,

typename... T

两种参数包:

模板参数包 -- 零或多个模板参数
函数参数包 -- 零或多个函数参数

template<typename T, typename ... Args>
void foo(const T& t, const Args& ... rest) {}

sizeof... 运算符

当我们需要知道包中有多少元素时, 可以使用sizeof... 运算符

template<typename T, typename ... Args>
void foo(const T& t, const Args& ... rest) {
	cout << sizeof...(Args) << endl;
}

16.4.1 编写可变参数函数模板

可变参数函数通常是递归的. 每次处理包中的第一个实参, 然后用剩余的实参调用自身.

template<typename T>
ostream& print(ostream& os, const T& t) { return os << t; }
template<typename T, typename ... Args>
ostream &print(ostream &os, const T &t, const Args& ... rest) {
	os << t << ", ";
	return print(os, rest...);
// 此处, 每次解析rest中的第一个实参 绑定到t, 剩余的部分 继续作为rest 绑定到形参中的rest上
}

16.4.2 包扩展

即: 模板参数包/模板函数参数包的解开操作, 如上面的print可变参数模板函数, 当传入

print(cout, i, s, 42) 时, 模板函数将会被实例化成:

print(ostream&, const int&, const string&, const int&);

当需要调用函数对包内元素逐个执行函数的操作时, 需要:

template <typename ... Args>
ostream& errorMsg(ostream& os, const Args& ... rest) {
	return print(os, debug_rep(rest)...)
	// debug_rep 也是一个模板函数, 其接受一个参数, 并打印输出参数的内容
}

16.4.3 转发参数包

转发时定义形参为右值版本

template<typename ... Args>
inline void StrVec::emplace_back(Args&& ... args) {
	chk_n_alloc();
	alloc.construct(first_free++, std::forward<Args>(args)...);
}

16.5 模版特性化

当特例化一个函数模板时, 必须为原模板中的每个模板参数提供实参. 还应在template周免跟上<>. 也就是说此处特例化定义时使用的类型必须是前面定义的模板的类型相匹配.

// 特例化一个compare模板
template<>
int compare(const char* const& p1, const char* const& p2) { return strcmp(p1, p2); }

template后面应该跟的typename,用于指定模板中使用的类型, 但是因为是特例化的, 本身指定了模板中使用的类型, 所以, template后面只跟<> 而未定义类型.

const char* const & 一个指向const char的const指针的引用

函数重载与模板特例化:

一个特例化版本本质上是一个实例, 而非函数名的一个重载版本.

模板及其特例化版本应该声明在同一个头文件中, 所有同名模板的声明应该放在前面, 然后是这些模板的特例化版本. 否则编译器很难发现没有特例化声明的错误.

类模板特例化:

类模板部分特例化:

部分特例化的类仍然是模板类

特例化成员而不是类: 只特例化成员函数而非整个模板.

template<typename T> struct Foo2 {
	Foo2(const T &t = T()):mem(t) {}
	void Bar();
	T mem;
};
template<>
void Foo2<int>::Bar(){}  // 特例化Foo<int>的成员Bar
// 特例化以后 当使用int以外的类型实例化Foo时, 跟其他情况一样
// 当使用int类型实例化Foo时, 除了Bar其余跟其他一样

yutao1131

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
C++ 小白学习记录16

第十六章模版与泛型编程OOP: 能处理类型在程序运行之前都未知的情况泛型编程: 在编译时就能获知类型泛型代码的两个重要原则:模板中的函数参数是const的应用(使用const可以接受更多的类型, 拷贝/不可拷贝/const/非const的) 函数体重的条件判断仅使用<比较运算符(减少对类型的要求, <可以计算出!=, >, ==).16.1 定义模版16.1.1 函数模版代表任意类型. 类型参数template <typename T, t.
复制链接

扫一扫