C++ Primer: Chapter 16 Template

已于 2024-05-20 21:11:03 修改
阅读量1.2k 收藏 18
点赞数 40
分类专栏： C++ Primer 文章标签： c++ 开发语言
于 2024-05-20 21:10:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cjlcjlyoo/article/details/139075038
版权

Contents

Chapter 16 Template

homework

Test 16.1

template<typename T>
int compare(const T& v1, const T& v2)
{
    if (v1 < v2) return -1;
    if (v2 < v1) return 1;
    return 0;
}

Test 16.3

错误C2676二进制“<”:“const T”不定义该运算符或到预定义运算符可接收的类型的转换

Test 16.4

template<typename T, typename U>
T find2(const T& it1, const T& it2, const U& value)
{
    for (; it1 != it2; ++it1)
        if (*it1 == value)
            return it1;
    return it2;
}

int main()
{
    vector<int> ivec{ 1, 2, 3, 4, 5, 6 };
    list<string> slst{ "aaa", "bbb", "ccc", "ddd" };

    auto it = find2(ivec.begin(), ivec.end(), 3);
    auto it2 = find2(slst.begin(), slst.end(), "ccc");

    cout << *it << " " << *it2;
}

Test 16.5

template<unsigned N>
void print(int(&arr)[N])
{
    for (auto elem : arr)
        cout << elem << endl;
}

int main()
{
    int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };

    print(arr);
}

Test 16.6

template<unsigned N, typename T>
T* my_begin(T(&arr)[N])
{
    return arr;
}

template<unsigned N, typename T>
T* my_end(T(&arr)[N])
{
    return arr + N - 1;
}

Test 16.7

template<unsigned N, typename T>
constexpr unsigned getSize(T(&arr)[N])
{
    return N;
}

int main()
{
    int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };

    cout << getSize(arr) << endl;
}

Test 16.12

定义一个类一般都是在头文件.h中进行声明，在.cpp文件中实现，但使用模板类时应注意目前的C++编译器还无法分离编译，最好将实现代码和声明代码均放在头文件中。

Blob.h

#pragma once

#include<initializer_list>
#include<memory>
#include<string>
#include<vector>
#include<stdexcept>
using namespace std;

//statement
template <typename> class BlobPtr;
template <typename> class Blob;
template <typename T> bool operator==(const Blob<T>&, const Blob<T>&);

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

	friend class BlobPtr<T>;
	friend bool operator==<T>(const Blob<T>&, const Blob<T>&);

public:
	Blob() : data(make_shared<vector<T>>()) {};
	Blob(initializer_list<T> il) : data(make_shared<vector<T>>(il)) {};
	template <typename U> Blob(const U& beg, const U& end) : data(make_shared<vector<T>>(beg, end)) {};
	// elements number in Blob
	size_type size() const { return data->size(); };
	bool empty() const { return data->empty(); };
	// add and delete element
	void push_back(const T& t) { data->push_back(t); };
	void push_back(T&& t) { data->push_back(std::move(t)); };
	void pop_back();

	// access element
	T& front();
	const T& front() const;
	T& back();
	const T& back() const;
	T& operator[](size_type i);
	const T& operator[](size_type i) const;

private:
	shared_ptr<vector<T>> data;
	void check(size_type i, const string& msg) const;
};

template <typename T> class BlobPtr
{
public:
	BlobPtr() : curr(0) {};
	BlobPtr(Blob<T>& a, size_t sz = 0) : wptr(a.data), curr(sz) {};
	T& operator*() const { auto p = check(curr, "dereference past end"); return (*p)[curr]; };
	BlobPtr& operator++();
	BlobPtr& operator--();
private:
	shared_ptr<vector<T>> check(size_t, const string&) const;
	weak_ptr<vector<T>> wptr;
	size_t curr;
};

// Blob
template <typename T>
void Blob<T>::check(size_type i, const string& msg) const
{
	if (i >= data->size())
		throw out_of_range(msg);
}

// add and delete element
template <typename T>
void Blob<T>::pop_back()
{
	check(0, "pop_back on empty strblob");
	return data->pop_back();
}


// access element
template <typename T>
T& Blob<T>::front()
{
	check(0, "front on empty strblob");
	return data->front();
}

template <typename T>
const T& Blob<T>::front() const
{
	check(0, "front on empty strblob");
	return data->front();
}

template <typename T>
T& Blob<T>::back()
{
	check(0, "front on empty strblob");
	return data->back();
}

template <typename T>
const T& Blob<T>::back() const
{
	check(0, "front on empty strblob");
	return data->back();
}

template <typename T>
T& Blob<T>::operator[](size_type i)
{
	check(i, "out of range");
	return (*data)[i];
}

template <typename T>
const T& Blob<T>::operator[](size_type i) const
{
	check(i, "out of range");
	return (*data)[i];
}

// non-member interface function
template <typename T>
bool operator==(const Blob<T>& lhs, const Blob<T>& rhs)
{
	return lhs.data == rhs.data;
}

// BlobPtr
template <typename T>
BlobPtr<T>& BlobPtr<T>::operator++()
{
	check(curr, "increment past end of strblobptr");
	++curr;
	return *this;
}
template <typename T>
BlobPtr<T>& BlobPtr<T>::operator--()
{
	--curr;
	check(curr, "decrement past begin of strblob");
	return *this;
}

Test 16.14 - Test 16.15

template <unsigned W, unsigned H> class Screen;
template <unsigned W, unsigned H> ostream& operator<<(ostream&, const Screen<W, H>&);
template <unsigned W, unsigned H> istream& operator>>(istream&, Screen<W, H>&);

template <unsigned W, unsigned H> class Screen
{
	template <unsigned W, unsigned H> friend ostream& operator<<(ostream&, const Screen<W, H>&);
	template <unsigned W, unsigned H> friend istream& operator>>(istream&, const Screen<W, H>&);
public:
	Screen() : contents(W * H, ' ') {};
	Screen(const char& c) : contents(W* H, c) {};
	Screen& set(const char& c) { contents = string(W * H, c); return *this; };
private:
	string contents;
};

template <unsigned W, unsigned H> 
ostream& operator<<(ostream& os, const Screen<W, H>& screen)
{
	os << screen.contents << endl;
	return os;
}

template <unsigned W, unsigned H> 
istream& operator>>(istream& is, Screen<W, H>& screen)
{
	char c;
	is >> c;
	screen.set(c);
	return is;
}

Test 16.19

template<typename T>
void printi(const T& target)
{
    typedef typename T::size_type size_type;
    for (size_type i = 0; i < target.size(); ++i)
        cout << target[i] << " ";
    cout << endl;
}

Test 16.20

template<typename T>
void printj(const T& target)
{
    for (auto beg = target.begin(); beg != target.end(); ++beg)
        cout << *beg << ' ';
    cout << endl;
}

Test 16.21

class DebugDelete
{
public:
    DebugDelete(ostream& s = cerr) : os(s) {};
    template<typename T> void operator()(T* p) { os << "delete pointer" << endl; delete p; };
private:
    ostream& os;
};

Test 16.22

把原来的TextQuery::TextQuery(ifstream& is)构造函数定义改成：

TextQuery::TextQuery(ifstream& is) : file(new vector<string>, DebugDelete())
{
	//.......
}

Test 16.24

template <typename T> class Blob
{
public:
	template <typename U> Blob(const U& beg, const U& end) : data(make_shared<vector<T>>(beg, end)) {};

private:
	shared_ptr<vector<T>> data;
	void check(size_type i, const string& msg) const;
};

Test 16.26

不可以，当我们显式实例化 vector 时，编译器会实例化 vector 的所有成员函数，包括它接受容器大小参数的构造函数。vector 的这个构造函数会使用元素类型的默认构造函数来对元素进行值初始化，而 NoDefault 没有默认构造函数，从而导致编译错误。

Test 16.38

make_shared需要传递一个动态内存的值，并返回一个指向该值的指针。由于返回类型中包含模板参数，因此需要显式指定实参类型

Test 16.39

template<typename T>
int compare(const T& v1, const T& v2)
{
    if (v1 < v2) return -1;
    if (v2 < v1) return 1;
    return 0;
}

int main()
{
    cout << compare<string>("aaa", "bbb");
    return 0;
}

Test 16.41

template<typename T1, typename T2>
auto sum(const T1& v1, const T2& v2) -> decltype(v1 + v2)
{
    return v1 + v2;
}

Test 16.46

若第二个参数是一个左值，则进行拷贝动作。但在上面的代码中，用 std::move 将一个左值转换为右值引用，这样，construct 会调用 string 的移动构造函数将数据从旧内存空间移动而不是拷贝到新的内存空间中，避免了不必要的数据拷贝操作。

Test 16.47

template<typename F, typename T1, typename T2>
void flip(F f, T1 &&t1, T2 &&t2)
{
    f(std::forward<T2>(t2), std::forward<T1>(t1));
}

void g(int&& i, int& j)
{
    cout << i << ' ' << j << endl;
}

int main()
{
    int i = 0;
    flip(g, i, 42);
    return 0;
}

Test 16.48

template<typename T> string debug_rep(const T& t)
{
    ostringstream ret;
    ret << t;
    return ret.str();
}

template<typename T> string debug_rep(T* p)
{
    ostringstream ret;
    ret << "pointer: " << p;
    if (p)
        cout << " " << debug_rep(*p) << endl;
    else
        cout << " null pointer" << endl;
    return ret.str();
}

string debug_rep(const string& s)
{
    return s;
}

string debug_rep(char* p)
{
    return debug_rep(string(p));
}

string debug_rep(const char* p)
{
    return debug_rep(string(p));
}

int main()
{
    string str("aaaa");
    string* p = &str;

    cout << debug_rep(p);

    return 0;
}

Test 16.52

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

int main()
{
    int i = 0; double d = 3.14; string s = "what can i say";
    foo(i, s, d, 42);

    return 0;

}

Test 16.53

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...);
}

int main()
{
    int i = 0; double d = 3.14; string s = "what can i say";
    print(cout, i, s, d, 42);

    return 0;

}

Test 16.56

template<typename T> string debug_rep(const T& t)
{
    ostringstream ret;
    ret << t;
    return ret.str();
}

template<typename T> string debug_rep(T* p)
{
    ostringstream ret;
    ret << "pointer: " << p;
    if (p)
        cout << " " << debug_rep(*p) << endl;
    else
        cout << " null pointer" << endl;
    return ret.str();
}

string debug_rep(const string& s)
{
    return s;
}

string debug_rep(char* p)
{
    return debug_rep(string(p));
}

string debug_rep(const char* p)
{
    return debug_rep(string(p));
}

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...);
}

template<typename... Args>
ostream& errorMsg(ostream& os, const Args&... rest)
{
    return print(os, debug_rep(rest)...);
}

int main()
{
    int i = 0; double d = 3.14; string s = "what can i say";
    errorMsg(cout, i, s, d, 42);

    return 0;

}

Test 16.58

class StrVec
{
    //...
public:
	template<typename...Args> void emplace_back(Args&&...);

    //...
    
};

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

Test 16.59

由于 s 是一个左值，经过包扩展，它将以如下形式传递给 construct。

std::forward<string>(s)

std::forward<string> 的结果类型是 string& ，因此，construct 将得到一个左值引用实参，它继续将此参数传递给 string 的拷贝构造函数来创建新元素。

Test 16.60

make_shared 的工作过程类似 emplace_back。

它接受参数包，经过扩展，转发给 new，作为 vector 的初始化参数。

Test 16.61

template <typename T, class... Args>
SharedPtr<T> make_shared(Args&&... args) {
    SharedPtr<T> s(new T(std::forward<Args>(args)...));
    return s;
}

Test 16.62

my_sales_data.h中

#ifndef MY_SALES_DATA_H
#define MY_SALES_DATA_H

#include<iostream>
#include<string>
template <class T> struct std::hash;
class my_sales_data
{
	friend std::istream& operator>>(std::istream&, my_sales_data&);
	friend std::ostream& operator<<(std::ostream&, const my_sales_data&);
	friend my_sales_data operator+(const my_sales_data&, const my_sales_data&);
	friend bool operator==(const my_sales_data&, const my_sales_data&);
	friend bool operator!=(const my_sales_data&, const my_sales_data&);
	friend struct std::hash<my_sales_data>;

public:
	//构造函数（声明）
	//my_sales_data() : units_sold(0), revenue(0.0) {}; //使用类内初始值
	my_sales_data(std::string s) : bookNo(s) {};
	my_sales_data(std::string s, unsigned n, double r) : bookNo(s), units_sold(n), revenue(r) { };
	my_sales_data() : my_sales_data("1001", 0, 0) { }; //使用委托构造函数
	my_sales_data(std::istream&);
	
	inline double avg_price() const;
	std::string isbn() const { return bookNo; }
	
	my_sales_data& operator+=(const my_sales_data&);
	my_sales_data& operator=(const std::string&);

	operator std::string() const { return bookNo; };
	operator double() const { return revenue; };

private:
	//成员变量
	std::string bookNo;
	unsigned units_sold = 0;
	double revenue = 0.0;

};

//hash函数的特例化版本，用于对my_sales_data对象使用无序容器
namespace std
{
	template<>
	struct hash<my_sales_data>
	{
		typedef size_t result_type;
		typedef my_sales_data argument_type;
		size_t operator() (const my_sales_data& s) const;
	};

	inline
	size_t hash<my_sales_data>::operator() (const my_sales_data& s) const
	{
		return hash<string>()(s.bookNo) ^ hash<unsigned>()(s.units_sold) ^ hash<double>()(s.revenue);
	}
}

#endif

main.cpp

int main()
{
    unordered_multiset<my_sales_data> mySet;

    my_sales_data data1("1001", 2, 19.99);
    my_sales_data data2("1002", 4, 49.99);
    my_sales_data data3("1003", 2, 79.99);

    mySet.insert(data1);
    mySet.insert(data2);
    mySet.insert(data3);

    for (auto& s : mySet)
        cout << s << endl;

    return 0;

}

Test 16.63

template<typename T>
void count(const vector<T>& vec, T val)//这里注意val不能是引用，这样的话字符串字面值便不可传入（左值引用不能绑定到一个右值）
{
    int times = 0;
    for (auto& i : vec)
        if (i == val)
            ++times;
    cout << val << " occurs " << times << endl;
}


int main()
{
    vector<int> ivec{ 1, 1, 2, 3, 3, 3, 4 };
    vector<double> dvec{ 1.99, 2.99, 2.99, 3.99 };
    vector<string> svec{ "aaa", "bbb", "ccc", "ccc" };


    count(ivec, 1);
    count(dvec, 2.99);
    string s1("ccc");
    count(svec, s1);

    return 0;

}

Test 16.64

template<typename T>
void count(const vector<T>& vec, T val)//这里注意val不能是引用，这样的话字符串字面值便不可传入（左值引用不能绑定到一个右值）
{
    int times = 0;
    for (auto& i : vec)
        if (i == val)
            ++times;
    cout << val << " occurs " << times << endl;
}

template<>
void count(const vector<const char*> & vec, const char* val)
{
    int times = 0;
    for (auto& i : vec)
        if (i == val)
            ++times;
    cout << val << " occurs " << times << endl;
}

int main()
{
    vector<const char*> cvec{ "aaa", "bbb", "ccc", "ccc", "ccc"};

    count(cvec, "ccc");

    return 0;

}

Test 16.65

template<> string debug_rep(char* p)
{
    return debug_rep(string(p));
}

template<> string debug_rep(const char* p)
{
    return debug_rep(string(p));
}
WingiiLab
关注
  • 40
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++primer 笔记 02 命名空间
weixin_46646888的博客
05-07 218
18.2命名空间 命名空间污染：应用程序用到多个独立开发的库（内含大量的全局名字，如类，函数模板）就会引发名字冲突 命名空间：命名空间分割全局命名空间，每个命名空间是一个作用域 18.2.1命名空间定义 namespace cplusplus_primer { class Sales_data{}; Sales_data operator+(const Sales_data&, const Sales_data); class Query{}; class
C++Primer读书笔记：C++概述.pdf
03-23
C++Primer中文第三版（C++从入门到精通）第一章的读书笔记，主要是C++程序、预处理器指示符、iostream库等的基础知识点读书笔记。
c++ primer plus chapter8 习题
编写一个生成器函数，能够生成斐波那契数列
01-05 125
c++ primer plus 第八章习题
C++：C++Primer Plus(第六版)：Chapter16 : string类和标准模板库：智能指针
C++ JAVA的专栏
05-11 598
C++：C++Primer Plus(第六版)：Chapter16 : string类和标准模板库：智能指针
C++ Primer Plus, Sixth Edition - 下载电子书与源代码
既然选择了远方 便只顾风雨兼程 - 永强
03-04 3825
C++ Primer Plus, Sixth Edition - 下载电子书与源代码
《C++ Primer》第16章 16.5节习题答案
chenyijun的专栏
11-02 237
《C++ Primer》第16章 模板与泛型编程 16.5节模板特例化 习题答案 练习16.62：定义你自己版本的hash<Sales_data>，并定义一个Sales_data对象的unordered_multiset。将多条交易记录保存到容器中，并打印其内容。 【出题思路】 本题练习类模板特例化。 【解答】 #ifndef PROGRAM16_62_SALES_DATA_H #define PROGRAM16_62_SALES_DATA_H #include <str
C++ Primer, Fifth Edition - 下载电子书与源代码
既然选择了远方 便只顾风雨兼程 - 永强
07-29 2566
C++ Primer, Fifth Edition - 下载电子书与源代码
C++PrimerPlus(第6版)中文版:Chapter16.5.1函数对象_函数符概念
只会写HelloWorld的专栏
09-20 207
list模板有一个将谓词作为参数的remove_if()成员，该函数将谓词应用于区间中的每一个元素，如果谓词返回true，很多STL算法都使用函数对象（也叫函数符functor）函数符是可以以函数方式与（）结合使用的任意对象。STL也定义了函数符概念。
c++ primer plus chapter16 string类和标准模板库
kdb_viewer的博客
08-23 142
内容摘要： 1.标准c++ string类 2.模板auto_ptr，unique_ptr，shared_ptr 3.标准模板库STL 4.容器类 5.迭代器 6.函数对象functor 7.STL算法 8.模板intializer_list C语言提供的字符串相关函数在string.h和cstring中，而c++的string类是在头文件&lt;string&gt;中支持的，要...
《C++ Primer Plus》（第6版）第16章编程练习
ProgramNovice的博客
04-21 606
《C++ Primer Plus》（第6版）第16章编程练习
C++Primer Plus附录源码等文件.zip
12-27
1. 变量与数据类型：C++中的基本数据类型包括整型（int）、浮点型（float和double）、字符型（char）以及布尔型（bool）。练习题可能涉及声明、初始化、赋值以及不同类型之间的转换。 2. 运算符：C++提供了丰富的...
C++ primer Plus的pdf资源
11-02
C++ primer Plus的pdf资源
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
8. **STL（Standard Template Library）**：C++标准库中的容器（如vector、list、set）、迭代器、算法和函数对象是STL的核心部分，它们极大地提高了编程效率。 9. **异常处理**：C++提供了异常处理机制，使得程序在...
CppPrimer:C++ 入门 5 个回答
06-04
##C++ 入门 5 个回答 笔记 编译时使用-std=c++11 （可选： ...第二部分：C++ 库 第 8 章 IO 库 第 9 章顺序容器 第 10 章通用算法 第 11 章关联容器 第三部分：课堂作者工具 第四部分：高级主题 第 19 章专用工具和技术
C++ std::thread 管理线程生命周期：join 和 detach
m0_59680769的博客
07-16 982
方法用于同步主线程和子线程。也就是说，当主线程调用子线程的join方法时，主线程会被阻塞，直到子线程完成其执行。这意味着join方法确保主线程等待子线程结束，然后继续执行后续代码。t.join()方法则是让子线程在后台独立运行，与主线程分离。分离后的线程（也称为“游离线程”）不能再被join，它的资源会在该线程完成后自动释放。主线程会继续执行而不会等待该子线程。如果把std::this_thread::sleep_for(std::chrono::seconds(3));
JNI: 在Kotlin和C++之间通过JNI进行接口传递，两边参数定义映射
tyfwin的博客
07-15 1050
在Kotlin和C++之间通过JNI进行接口传递时，需要注意两边参数定义的映射关系。JNI（Java Native Interface）为Java（Kotlin也适用）与本地语言（如C/C++）之间的交互提供了桥梁。在Kotlin中定义的外部函数和C++中的实现需要通过JNI签名相互对应。
C++ std::partial_sort_copy 用法
07-16 296
部分排序，即选出前n个最大值或者最小值，并将其保存到另外一个容器中。
C++的内存管理
最新发布
2301_78694309的博客
07-19 556
C++的内存管理
C++ Primer：全新升级，聚焦C++11标准与标准库
"C++ primer 入门" C++ Primer 是一本经典的C++编程教程，针对C++11标准进行了全面更新。这本书旨在帮助初学者掌握C++语言，并深入理解其核心概念和现代编程技巧。作者团队由C++大师Stanley B. Lippman、C++标准...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值