C++编程提高

末蓝、 2022-12-13 01:57 160阅读 0赞

## 18 常用类的使用 ##

#### 18.1 string类的使用 ####

> 通过代码实现对string对象的以下操作：  
> 构造、拷贝赋值、比较、截取、转换为c字符串

**构造&拷贝赋值**

//无参构造
    string s1; 
    //使用字符串s初始化
    const char* str = "hello world";
    string s2(str);
    //使用一个string对象初始化另一个string对象
    string s3(s2);
    //使用n个字符c初始化 
    string s4(10, 'a');

**字符串之间比较**

string str1 = "hello";
    string str2 = "aello";
    
    int ret = str1.compare(str2);
    if (ret == 0) {
        cout << " s1 等于 s2" << endl;
    }else {
        cout << "s1 不等于 s2" << endl;
    }

**字符串截取**

string str = "hello world";
    string sub_str = s1.substr(6);
    string sub_str = s1.substr(2,6);

**转换c字符串**

string str = "hello world";
    char p[20];
    int i;
    for (i = 0; i < s1.length();i++){
    p[i] = s1[i];
    }
    
    p[i] = '\0';

**补充：memcpy和strcpy的区别**

1、复制的内容不同：strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等

2、复制的方法不同：strcpy不需要指定长度，它遇到被复制字符的串结束符"\\0"才结束，若空间不足，则会引起内存溢出。而memcpy是根据第3个参数决定复制的长度

3、用途不同：通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy（因为C++的字符串是以“\\0”结尾的）

**补充：memset 的作用**

函数声明：`void *memset(void *str, int c, size_t n)`

#include<iostream>
    int main()
    {
        //定义了数组arr,包含100个元素
    	int arr[100];
        
        //方式一：将数组全部内容初始化为0
    	for (int i = 0; i < 100; i++){
    		arr[i] = 0;
    	}
        
    	//方式二：使用memset将数组初始化为
    	memset(arr, 0, sizeof(int)* 100);
    
    	system("pause");
    	return 0;
    }

正如上面的例子所示，memset 常常用于在内存分配后对变量的初始化。其次在使用`malloc`函数之前，我们也常使用`memset`对所申请的地址空间进行清理，防止因申请的空间有原始值而造成一些错误

另外，还有关于`memset` 一个奇特的现象，代码如下

#include<iostream>
    int main()
    { 
    	char buffer[] = "This is a test of the memset function"; 
    	printf( "Before: %s\n", buffer );
    
    	memset( buffer, '*', 4 ); 
    	printf( "After: %s\n", buffer ); 
    
    	system("pause");
    	return 0;
    }

打印结果：

Before: This is a test of the memset function 
    After:  **** is a test of the memset function 
    请按任意键继续..

这是因为`memset`的第二个参数，设置初始化的值。该值是 `int` 形式传递，但是函数在填充内存块时使用的是该值的无符号字符形式

#### 18.2 vector类的使用 ####

> 通过代码实现对vector对象的以下操作：  
> 构造初始化、拷贝赋值、插入、设置容量、设置size、清空元素、清空容量

**构造初始化**

//无参构造
    vector<int> v1; 
    
    //将v[begin(), end())区间中的元素拷贝给本身
    vector<int> v2(v1.begin(), v1.end());
    
    //构造函数将n个elem拷贝给本身
    vector<int> v3(10, 100);
    
    //拷贝构造函数
    vector<int> v4(v3);

**拷贝赋值**

vector<int> v1; 
    for (int i = 0; i < 10; i++)
    {
    v1.push_back(i);
    }
    
    vector<int>v2;
    v2 = v1;
    
    //assign(beg, end):将[beg, end)区间中的数据拷贝赋值给本身
    vector<int>v3;
    v3.assign(v1.begin(), v1.end());
    
    //assign(n, elem):将n个elem拷贝赋值给本身
    vector<int>v4;
    v4.assign(10, 100);

**插入**

//push_back(ele):尾部插入元素ele
    vector<int> v1;
    v1.push_back(10);
    v1.push_back(20);
    	
    //pop_back():删除最后一个元素
    v1.pop_back();
    	
    //insert(const_iterator pos, ele):迭代器指向位置pos插入元素ele
    v1.insert(v1.begin(), 100);
    
    //insert(const_iterator pos, int count,ele)
    //迭代器指向位置pos插入count个元素ele
    v1.insert(v1.begin(), 2, 1000);

**设置size**

//resize(int num)：重新指定大小,若指定的更大,默认用0填充新位置
    v1.resize(5);
    
    //resize(int num,elem)
    //重新指定容器的长度为num,若容器变长，则以elem值填充新位置
    //重新指定大小,若指定的更小,超出部分元素被删除
    v1.resize(15,10);

**设置容量**

//reserve(int num)：重新指定容器容量
    v1.reserve(5);

**清空元素**

//erase(const_iterator pos):删除迭代器指向的元素
    v1.erase(v1.begin());
    
    //erase(const_iterator start, const_iterator end)
    //删除迭代器从start到end之间的元素
    v1.erase(v1.begin(),v1.end());
    
    //clear()：删除容器中所有元素
    v1.clear();

**清空容量**

//清除元素并回收内存
    vector <int>().swap(v1);

#### 18.3 map类的使用 ####

> 通过代码实现对map对象的以下操作：  
> 构造初始化、插入、查找、清空元素

**构造初始化**

//无参构造
    map<int,int>m; 
    
    //拷贝构造
    map<int, int>m2(m);

**插入**

map<int, int> m;
    
    //第一种插入方式
    m.insert(pair<int, int>(1, 10));
    
    //第二种插入方式
    m.insert(make_pair(2, 20));
    
    //第三种插入方式
    m.insert(map<int, int>::value_type(3, 30));
    
    //第四种插入方式
    m[4] = 40;

**查找**

//find(key)
    //查找key是否存在,存在则返回该键的元素迭代器;不存在,则返回set.end()
    map<int, int>m; 
    map<int, int>::iterator pos = m.find(3);
    
    if (pos != m.end())
    {
    cout << "找到了元素 key = " << (*pos).first << " value = " << (*pos).second << endl;
    }

**清空元素**

//clear()：删除容器中所有元素
    m.clear();

#### 18.4 STL模板类的使用 ####

> 声明定义模板函数和模板类，特化实现

> 模板特化是在统一模板在某些情况下不能正常工作时，或是某些情况需要特殊处理，即模板在某种特定情况下的具体实现

1、模板函数的特化实现

#include<iostream>
    
    class Person{
    public:
    	Person(long long id, const int age){
    		id_card_ = id;
    		age_ = age;
    	}
    
    	long long getIdCard() const{
    		return this->id_card_;
    	}
    
    	int getAge() const{
    		return this->age_;
    	}
    
    private:
    	long long id_card_;
    	int age_;
    };
    
    //普通函数模板
    template<class T>
    bool myCompare(T& a, T& b){
    	if (a == b){
    		return true;
    	}
    	else{
    		return false;
    	}
    }
    
    //具体化优先于常规模板
    //具体化,显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
    template<>
    bool myCompare(Person &p1, Person &p2){
    	if (p1.getAge() == p2.getAge() && p1.getIdCard() == p2.getIdCard()){
    		return true;
    	}else{
    		return false;
    	}
    }
    
    int main(){
    
    	int a = 10;
    	int b = 20;
    	std::cout << myCompare(a, b) << std::endl;
    
    	//自定义数据类型,不会调用普通的函数模板
    	//创建具体Person数据类型的模板,用于特殊处理这个类型
    	Person p1(412824199705254312, 10);
    	Person p2(412824199705254312, 10);
    	std::cout << myCompare(p1, p2) << std::endl;
    
    	system("pause");
    	return 0;
    }

2、模板类的特化实现

#include <iostream>
    
    template<typename T>class A{
    public:
    	A(){
    		num_ = T(10);
    		std::cout << "num = " << num_ << std::endl;
    	}
    private:
    	T num_;
    };
    
    template<>class A<double>{
    public:
    	A(){
    		special_num_ = 3.14159;
    		std::cout << "special_num = " << special_num_ << std::endl;
    	}
    private:
    	double special_num_;
    };
    
    int main(){
    	A<int> a1; //显示模板实参的隐式实例化
    	A<double> a2;//使用特化的类模板
    
    	system("pause");
    	return 0;
    }

//reserve(int num)：重新指定容器容量
    v1.reserve(5);

**清空元素**

**清空容量**

//清除元素并回收内存
    vector <int>().swap(v1);

#### 18.3 map类的使用 ####

> 通过代码实现对map对象的以下操作：  
> 构造初始化、插入、查找、清空元素

**构造初始化**

//无参构造
    map<int,int>m; 
    
    //拷贝构造
    map<int, int>m2(m);

**插入**

**查找**

**清空元素**

//clear()：删除容器中所有元素
    m.clear();