c++基础学习笔记（二）

女爷i 2021-11-01 12:00 332阅读 0赞

\-----摘自c++菜鸟教程----

#### 模板 ####

模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。

模板是创建泛型类或函数的蓝图或公式。库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。

每个容器都有一个单一的定义，比如 **向量**，我们可以定义许多不同类型的向量，比如 **vector**  或 **vector** 。

您可以使用模板来定义函数和类，接下来让我们一起来看看如何使用。

##### 函数模板 #####

模板函数定义的一般形式如下所示：

template <class type> ret-type func-name(parameter list)
    {
       // 函数的主体
    }

在这里，type 是函数所使用的数据类型的占位符名称。这个名称可以在函数定义中使用。

下面是函数模板的实例，返回两个数中的最大值：

#include <iostream>
    #include <string>
    
    using namespace std;
    
    template <typename T>
    inline T const& Max (T const& a, T const& b) 
    { 
        return a < b ? b:a; 
    } 
    int main ()
    {
     
        int i = 39;
        int j = 20;
        cout << "Max(i, j): " << Max(i, j) << endl; 
    
        double f1 = 13.5; 
        double f2 = 20.7; 
        cout << "Max(f1, f2): " << Max(f1, f2) << endl; 
    
        string s1 = "Hello"; 
        string s2 = "World"; 
        cout << "Max(s1, s2): " << Max(s1, s2) << endl; 
    
       return 0;
    }

当上面的代码被编译和执行时，它会产生下列结果：

Max(i, j): 39
    Max(f1, f2): 20.7
    Max(s1, s2): World

##### 类模板 #####

正如我们定义函数模板一样，我们也可以定义类模板。泛型类声明的一般形式如下所示：

template <class type> class class-name {
    	...
    }

在这里，type 是占位符类型名称，可以在类被实例化的时候进行指定。您可以使用一个逗号分隔的列表来定义多个泛型数据类型。

下面的实例定义了类 Stack<>，并实现了泛型方法来对元素进行入栈出栈操作：

#include <iostream>
    #include <vector>
    #include <cstdlib>
    #include <string>
    #include <stdexcept>
    
    using namespace std;
    
    template <class T>
    class Stack { 
      private: 
        vector<T> elems;     // 元素 
    
      public: 
        void push(T const&);  // 入栈
        void pop();               // 出栈
        T top() const;            // 返回栈顶元素
        bool empty() const{       // 如果为空则返回真。
            return elems.empty(); 
        } 
    }; 
    
    template <class T>
    void Stack<T>::push (T const& elem) 
    { 
        // 追加传入元素的副本
        elems.push_back(elem);    
    } 
    
    template <class T>
    void Stack<T>::pop () 
    { 
        if (elems.empty()) { 
            throw out_of_range("Stack<>::pop(): empty stack"); 
        }
    	// 删除最后一个元素
        elems.pop_back();         
    } 
    
    template <class T>
    T Stack<T>::top () const 
    { 
        if (elems.empty()) { 
            throw out_of_range("Stack<>::top(): empty stack"); 
        }
    	// 返回最后一个元素的副本 
        return elems.back();      
    } 
    
    int main() 
    { 
        try { 
            Stack<int>         intStack;  // int 类型的栈 
            Stack<string> stringStack;    // string 类型的栈 
    
            // 操作 int 类型的栈 
            intStack.push(7); 
            cout << intStack.top() <<endl; 
    
            // 操作 string 类型的栈 
            stringStack.push("hello"); 
            cout << stringStack.top() << std::endl; 
            stringStack.pop(); 
            stringStack.pop(); 
        } 
        catch (exception const& ex) { 
            cerr << "Exception: " << ex.what() <<endl; 
            return -1;
        } 
    }

当上面的代码被编译和执行时，它会产生下列结果：

7
    hello
    Exception: Stack<>::pop(): empty stack

--------------------

#### STL ####

##### STL（标准模板库） #####

C++ STL（标准模板库）是一套功能强大的 C++ 模板类，提供了通用的模板类和函数，这些模板类和函数可以实现多种流行和常用的算法和数据结构，如向量、链表、队列、栈。

C++ 标准模板库的核心包括以下三个组件：

<table> 
 <thead> 
  <tr> 
   <th align="center">组件</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">容器（Containers）</td> 
   <td align="left">容器是用来管理某一类对象的集合。C++ 提供了各种不同类型的容器，比如 deque、list、vector、map 等。</td> 
  </tr> 
  <tr> 
   <td align="center">算法（Algorithms）</td> 
   <td align="left">算法作用于容器。它们提供了执行各种操作的方式，包括对容器内容执行初始化、排序、搜索和转换等操作。</td> 
  </tr> 
  <tr> 
   <td align="center">迭代器（iterators）</td> 
   <td align="left">迭代器用于遍历对象集合的元素。这些集合可能是容器，也可能是容器的子集。</td> 
  </tr> 
 </tbody> 
</table>

这三个组件都带有丰富的预定义函数，帮助我们通过简单的方式处理复杂的任务。

下面的程序演示了向量容器（一个 C++ 标准的模板），它与数组十分相似，唯一不同的是，向量在需要扩展大小的时候，会自动处理它自己的存储需求：

实例

#include <iostream> 
    #include <vector> 
    using namespace std; 
    
    int main()
    {    // 创建一个向量存储 int 
    	vector<int> vec;
    	int i;      // 显示 vec 的原始大小    
    	cout << "vector size = " << vec.size() << endl;      // 推入 5 个值到向量中    
    	for (i = 0; i < 5; i++) 
    	{
    		vec.push_back(i);
    	}      // 显示 vec 扩展后的大小    
    	cout << "extended vector size = " << vec.size() << endl;// 访问向量中的 5 个值    
    	for (i = 0; i < 5; i++)
    	{
    		cout << "value of vec [" << i << "] = " << vec[i] << endl;
    	}      // 使用迭代器 iterator 访问值    
    	vector<int>::iterator v = vec.begin();
    	while (v != vec.end()) 
    	{
    		cout << "value of v = " << *v << endl;
    		v++;
    	}
    	return 0;
    }

当上面的代码被编译和执行时，它会产生下列结果：

vector size = 0
    extended vector size = 5
    value of vec [0] = 0
    value of vec [1] = 1
    value of vec [2] = 2
    value of vec [3] = 3
    value of vec [4] = 4
    value of v = 0
    value of v = 1
    value of v = 2
    value of v = 3
    value of v = 4

关于上面实例中所使用的各种函数，有几点要注意：

*  push\_back( ) 成员函数在向量的末尾插入值，如果有必要会扩展向量的大小。
 *  size( ) 函数显示向量的大小。
 *  begin( ) 函数返回一个指向向量开头的迭代器。
 *  end( ) 函数返回一个指向向量末尾的迭代器。

##### vector 的 capacity 和 size 属性区别 #####

**size** 是当前 vector 容器真实占用的大小，也就是容器当前拥有多少个容器。

**capacity** 是指在发生 realloc 前能允许的最大元素数，即预分配的内存空间。

当然，这两个属性分别对应两个方法：**resize()** 和 **reserve()**。

使用 **resize()** 容器内的对象内存空间是真正存在的。

使用 **reserve()** 仅仅只是修改了 capacity 的值，容器内的对象并没有真实的内存空间(空间是"野"的)。

此时切记使用 **\[\]** 操作符访问容器内的对象，很可能出现数组越界的问题。

**下面用例子进行说明：**

#include <iostream>
    #include <vector>
    
    using std::vector;
    int main(void)
    {
        vector<int> v;
        std::cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << std::endl;
        v.reserve(10);
        std::cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << std::endl;
        v.resize(10);
        v.push_back(0);
        std::cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << std::endl;
    
        return 0;
    }

运行结果为：(win 10 + VS2019)  
![在这里插入图片描述][20190808215849879.png]  
**注：** 对于 **reserve(10)** 后接着直接使用 **\[\]** 访问越界报错(内存是野的)，大家可以加一行代码试一下，我这里没有贴出来。

这里直接用\*\*\[\]\*\*访问，vector 退化为数组，不会进行越界的判断。此时推荐使用 at()，会先进行越界检查。

> **相关引申：**
> 
> 针对 capacity 这个属性，STL 中的其他容器，如 list map set deque，由于这些容器的内存是散列分布的，因此不会发生类似 realloc() 的调用情况，因此我们可以认为 capacity 属性针对这些容器是没有意义的，因此设计时这些容器没有该属性。
> 
> 在 STL 中，拥有 capacity 属性的容器只有 vector 和 string。

--------------------

#### 标准库 ####

C++ 标准库可以分为两部分：

*  **标准函数库：** 这个库是由通用的、独立的、不属于任何类的函数组成的。函数库继承自 C 语言。
 *  **面向对象类库：** 这个库是类及其相关函数的集合。

C++ 标准库包含了所有的 C 标准库，为了支持类型安全，做了一定的添加和修改。

##### 标准函数库 #####

标准函数库分为以下几类：

*  输入/输出 I/O
 *  字符串和字符处理
 *  数学
 *  时间、日期和本地化
 *  动态分配
 *  其他
 *  宽字符函数

##### 面向对象类库 #####

标准的 C++ 面向对象类库定义了大量支持一些常见操作的类，比如输入/输出 I/O、字符串处理、数值处理。面向对象类库包含以下内容：

*  标准的 C++ I/O 类
 *  String 类
 *  数值类
 *  STL 容器类
 *  STL 算法
 *  STL 函数对象
 *  STL 迭代器
 *  STL 分配器
 *  本地化库
 *  异常处理类
 *  杂项支持库

--------------------