C++：模板初阶以及string类使用-Toy模板网

这篇具有很好参考价值的文章主要介绍了C++：模板初阶以及string类使用。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

模板的简单认识

1.泛型编程

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

实现加法：

//不使用模板，只使用函数重载，每一个需要的类型都需要写一份函数
int add(int a, int b)
{
	return a + b;
}

double add(double a, double b)
{
	return a + b;
}

int main()
{
	int a1 = 0;
	int b1 = 0;
	int c1 = add(a1, b1);

	double a2 = 0.1;
	double b2 = 0.5;
	double c2 = add(a2, b2);
	return 0;
}

两个函数只有类型上的不同，逻辑完全一致，能不能写一份表示逻辑的模板，让编译器帮我们生成函数呢？

2.函数模板

模板的原理图

C++：模板初阶以及string类使用,C++初阶,c++,学习,笔记,stl

函数模板格式

template<typename T1, typename T2,…,typename Tn>
返回值类型函数名(参数列表){}

用函数模板来实现加法：

//模板不是具体的函数，真正的函数是由编译器去生成的
template<typename T>
T add(T a,T b)
{
	return a + b;
}
//typename是用来定义模板参数的关键字，也可以用class

int main()
{
	int a1 = 0;
	int b1 = 0;
	int c1 = add(a1, b1);

	double a2 = 0.1;
	double b2 = 0.5;
	double c2 = add(a2, b2);
	return 0;
}

函数模板实例化

隐式实例化：由编译器依据实参来自行生成。

template<typename T>
T add(T a,T b)
{
	return a + b;
}

int main()
{
	int a1 = 0;
	int b1 = 0;
	int c1 = add(a1, b1);//编译器生成int add(int a, int b);

	double a2 = 0.1;
	double b2 = 0.5;
	double c2 = add(a2, b2);//编译器生成double add(double a, double b);
	return 0;
}

显示实例化：在函数名后的<>中指定模板参数的实际类型

下面这个例子不显示实例化就会报错：

template<typename T>
T add(T a,T b)
{
	return a + b;
}

int main()
{
	int a1 = 0;
	double b1 = 0.5;
	int c1 = add(a1, b1);
	//模板中两个参数类型是一致的，这里一个int，一个double，没有明确指定编译器无法生成函数
	return 0;
}

C++：模板初阶以及string类使用,C++初阶,c++,学习,笔记,stl
利用显示实例化解决：

template<typename T>
T add(T a,T b)
{
	return a + b;
}

int main()
{
	int a1 = 0;
	double b1 = 0.5;
	double c1 = add<double>(a1, b1);
	//指定生成double add(double a,double b)并调用，和正常函数一样这里会进行隐式类型转换
	return 0;
}

非模板函数和模板函数的匹配原则

一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

//专门处理int
int add(int a, int b)
{
	return a + b;
}
//通用的函数模板
template<typename T>
T add(T a,T b)
{
	return a + b;
}

int main()
{
	int a1 = 0;
	int b1 = 5;
	int c = add(a1, b1);//与非模板函数完全匹配，编译器不会生成
	c = add<int>(a1, b1); //指定编译器生成并调用
	//两个函数同时存在不冲突	
	return 0;
}

对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板

//专门处理int
int add(int a, int b)
{
	return a + b;
}
// 通用加法函数
template<class T1, class T2>
T1 add(T1 left, T2 right)
{
	return left + right;
}
int main()
{
	add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
	add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
	return 0;
}

3.类模板

类模板的定义格式

template<class T1, class T2, …, class Tn>
class 类模板名
{
// 类内成员定义
};

//和函数模板一样，这里并不是真正的类
template<class T>
class A
{
public:
	A(T a)
		:_a(a)
	{}
	//演示一下定义声明分离
	T get();
private:
	T _a;
};

// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template <class T>
T A<T>::get()
{
	return _a;
}

类模板的实例化

类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

int main()
{
	//A是类名，A<int>才是类型
	A<int> a(5);
	A<double> b(5.22);
	return 0;
}

string

1.string简介

C++：模板初阶以及string类使用,C++初阶,c++,学习,笔记,stl

string是表示字符串的字符串类

string类是basic_string模板类的一个实例，即typedef basic_string<char> string

该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。

string是一个顺序容器，会自动扩容。

2.string常用的接口

string类中有一个静态成员npos：static const size_t npos = -1;
本文只讲使用，不讲底层原理

string类对象的常见构造

函数名称	功能说明
string() （常用）	构造空的string类对象，即空字符串
string(const char* s) （常用）	用C字符串来构造对象
string(size_t n, char c)	string类对象中前n个字符初始化为C
string(const string&s) （常用）	拷贝构造

int main()
{
	string s1; // 构造空的string类对象s1
	string s2("hello"); // 用C格式字符串构造string类对象s2
	string s3(s2); // 拷贝构造s3
	return 0;
}

string类对象的容量操作

函数名称	功能说明
size_t size() （常用）	返回有效字符数('\0’不算有效字符)
size_t length()	和size()功能一致
size_t capacity()	返回可存储有效字符的空间总大小，'\0’不算
bool empty() （常用）	检查是否为空串，是返回true，否则返回false
void clear() （常用）	清空字符串，变成空串
void reserve (size_t n = 0) （常用）	预留空间，n大于容量时扩容，不然什么都不做
void resize (size_t n, char c)	n>有效字符数时从从字符串尾开始填充c直到字符串满；n>容量就先扩容再填充；n<有效字符数时缩短字符串，保留前n个字符。

int main()
{
	string s2("hello"); 
	cout << s2.empty() << endl;
	s2.clear();//调用clear清理
	cout << s2.empty() << endl;

	cout << "capacity:" << s2.capacity() << endl;
	s2.reserve(100);//调用reserve预留空间
	cout << "reserve_capacity:" << s2.capacity() << endl;

	s2.resize(50, 'c');//填充
	cout << "s2:" << s2 << endl;

	s2.resize(10);//缩短到10字符
	cout << "s2:" << s2 << endl;
	return 0;
}

string类对象的访问及遍历操作

函数名称	功能说明
(const)char& operator ()	运算符重载，可以像数组一样通过下标访问字符
(const_)iterator begin()和end()	begin取第一个字符位置的迭代器，end取最后一个字符的下一个位置的迭代器（大家可以把迭代器想成指针，后面使用大家就明白了）
(const_)reverse_iterator rbegin()和rend()	反向迭代器，使用和begin()一致，方向相反
范围for	C++11支持，底层是迭代器

int main()
{
	string s2("hello"); 
	//利用[]运算符重载遍历
	for (int i = 0; i < s2.size(); i++)
		cout << s2[i];
	cout << endl;

	//利用迭代器进行遍历，利用auto自动推导类型
	//这里是std::string::iterator
	auto it = s2.begin();
	while (it != s2.end())
	{
		cout << *it;
		it++;
	}
	cout << endl;

	//反向迭代器遍历
	//这里是std::string::reverse_iterator
	auto rit = s2.rbegin();
	while (rit != s2.rend())
	{
		cout << *rit ;
		rit++;
	}
	cout << endl;

	//范围for遍历
	for (auto ch : s2)
		cout << ch ;
	cout << endl;
	//修改
	for (auto& ch : s2)
		cout << ch ;
	return 0;
}

string类对象的修改操作

函数名称	功能说明
void push_back(char c)	尾插一个字符c
string& append (const char* s)	尾插一个字符串
string& operator+=() （常用）	既可尾插字符串，也可单个字符，非常好用
const char* c_str() （常用）	返回C格式字符串首地址
size_t find (char c,size_t pos = 0) （常用）	从pos位置开始寻找第一个出现c的位置并返回，否则返回npos
size_t rfind (char c,size_t pos = npos)	从pos位置开始向前寻找第一次出现c的位置并返回，否则返回npos；当pos大于等于长度时，从尾开始向前搜索。（一般就是用这个函数搜索单个字符最后出现的位置）
string substr (size_t pos = 0, size_t len = npos)	从pos位置开始截取len个字符，如果截取长度大于后面长度，就截取到字符串尾部结束，然后返回
1.string& insert (size_t pos, size_t n, char c) 2.string& insert (size_t pos, const char* s)	1.在pos位置插入n个c 2.在pos位置插入C格式字符串

int main()
{
	string s2("hello "); 
	s2.push_back('w');
	s2.append("or");
	s2 += 'l';
	s2 += "dd!";

	cout << s2.c_str() << endl;
	
	cout << "pos(find):" << s2.find('w') << endl;
	cout << "pos(rfind):" << s2.rfind('d') << endl;
	
	if (s2.find('k') == std::string::npos)
		cout << "没找到" << endl;

	string sub = s2.substr(6, 6);
	cout << sub.c_str() << endl;
	//这里相当于头插'c'
	s2.insert(0,1,'c');
	s2.insert(2,"hello ");
	return 0;
}

string类非成员函数

函数	功能说明
string operator+()	先拷贝一份，实现尾插后返回，不改变原对象
operartor>>() （常用）	输入运算符重载
operator<<() （常用）	输出运算符重载
istream& getline (istream& is, string& str)	读取一行字符，遇到’\n’才结束
bool operator>() (<，<=，>=，==，!=)	进行字符串比较

int main()
{
	string s2("hello "); 
	string s3 = s2 + "world";
	cout << "s3:" <<  s3 << endl;

	cin >> s3;
	cout << "s3:" << s3 << endl;

	getchar();
	getline(cin, s3);//可以读取空格
	cout << "s3:" << s3 << endl;

	string s("hello");
	string s1("hellO");
	if (s == s1)
		cout << "s == s1" << endl;
	else if (s > s1)
		cout << "s > s1" << endl;
	else if (s < s1)
		cout << "s < s1" << endl;
	
	return 0;
}

题目练习

1.字符串相加

链接：字符串相加

题目要求：
C++：模板初阶以及string类使用,C++初阶,c++,学习,笔记,stl

题解：
C++：模板初阶以及string类使用,C++初阶,c++,学习,笔记,stl

class Solution {
public:
    string addStrings(string num1, string num2) 
    {
        //用来遍历
        int end1 = num1.size()-1;
        int end2 = num2.size()-1;
        //用来记录进位
        int flag = 0;
        int sum = 0;
        string str;
        while(end1 >= 0 || end2 >= 0)
        {
            //只有不越界的情况才给值，否则给0
            int x1 = end1>=0?num1[end1]-'0':0;
            int x2 = end2>=0?num2[end2]-'0':0;
            sum = flag + x1 + x2;
            //这里使用尾插，头插效率比较慢
            str += ('0'+sum%10);
            flag = sum/10;
            end1--;
            end2--;
        }

        //还需要处理一种特殊情况，比如"9"+"1"，同时结束刚好进位，需要补1
        if(flag == 1)
            str += '1';

        //数据是尾插的，需要逆置
        //reverse属于stl中的算法
        //只需要传入迭代器区间就能实现逆置
        reverse(str.begin(),str.end());
        return str;
    }
};

2.字符串里面最后一个单词的长度

链接：字符串里面最后一个单词的长度

题目要求：
C++：模板初阶以及string类使用,C++初阶,c++,学习,笔记,stl

题解：文章来源地址https://www.toymoban.com/news/detail-643318.html

#include <iostream>
#include<string>
using namespace std;

int main() 
{
    string str;
    getline(cin,str);
    //直接调用rfind找最后一个空格的位置
    //没有找到说明只有一个单词，直接返回长度
    int pos = str.rfind(' ');
    if(pos == std::string::npos)
        cout << (str.size()) << endl;
    else
        cout << (str.size()-(pos+1));
}

3.翻转字符串区间

链接：翻转字符串区间

题目要求：
C++：模板初阶以及string类使用,C++初阶,c++,学习,笔记,stl

题解：

class Solution 
{
public:
    string reverseStr(string s, int k) 
    {
        int index1 = 0;
        int index2 = k-1;
        //每2k个字符中反转前k个字符
        //"abcdefg" ->前4个反转前2个，"abcd"->"bacd","efg"->"feg"
        while(index2 <= s.size()-1)
        {
            reverse(s.begin()+index1,s.begin()+index2+1);
            index1 += 2*k;
            index2 += 2*k;
        }
        //最后一段小于k的全部反转
        reverse(s.begin()+index1,s.end());
        return s;
    }
};