前言：主要介绍了I/O操作、模板编程、容器、函数对象等。

---

1.I/O操作

1.1 基本输入输出

#include <iostream>
#include <iomanip>using namespace std;int main() {//输出布尔数据bool flag = false;cout << "flag的值是：" << flag << endl; // 打印 0//操作符只会影响后续的输出  打印 0  falsecout << "flag的值是：" << flag  <<" 添加操作符后："<<boolalpha << flag << endl;//输出整型数字cout <<"十进制：" << dec  <<9 << endl;  // 9cout <<"八进制：" << oct  <<9 << endl;  // 10cout <<"十六进制：" << hex <<10 << endl; // a//若想在输出前面表示打印的数值显示前缀进制标识，可以使用showbase关键字cout <<showbase;//默认即采用十进制输出cout <<"十进制：" << dec  <<9 << endl; //9cout <<"八进制：" << oct  <<9 << endl; //011cout <<"十六进制：" << hex <<10 << endl;  //0xacout<<noshowbase;//输出浮点数double a = 10.12345678901234;cout.precision(3); //  设置输出多少位数字 ,该函数有返回值，为设置的精度值。cout  <<" a ="<<a << endl;  // 10.1//或者使用setprecision() ，不过需要导入 #include <iomanip>//做一个标记位的设置，所以还是要连上  <<cout  << setprecision(5)<<" a ="<<a << endl;  // 10.123//小数点后面都是0，默认是不会被输出的，若想强制输出，可以使用showpoint关键字，配合precision 可以精确打印float  f =10.00;cout.precision(4);cout <<showpoint <<"f="<< f <<noshowpoint<< endl;  //10.00//禁止忽略空白符号cin>>noskipws;char c ;cout <<"请输入字符：" << endl;while(cin >> c){cout << c ;}cin >> skipws;return 0;
}

1.2 string 流

#include <iostream>
#include <iomanip>
#include <string>
using namespace std;int main() {string str = "I am fly";istringstream stream(str);string s;while (stream >> s){// 抽取stream中的值到scout<<s<<endl;}int a = 55;double b = 65.123;string str2 = "";//头文件是sstreamostringstream oss;oss << a << "---" << b;str2 = oss.str();cout << str2 << endl;return 0;
}

1.3 读取文件

#include <iostream>
#include <string>
#include <fstream>
using namespace std;
//读取文件
int main() {//构建文件对象， ../表示上一级目录，因为执行的时候是exe文件，它位于debug目录，并不和//test.txt 处于同级目录， in表示仅仅是读取文件内容//ios:: 表示域操作符，表示使用ios这个对象里面的in静态常量fstream file("../test.txt",ios::in);if (file.is_open()){string line;while (getline(file,line)){//getline 用于读取文件的整行内容，直到碰到文件末尾或者超过字符串可存储的最大值才会返回cout<<line<<endl;}file.close();} else{cout<<"文件无法打开"<<endl;}return 0;
}

1.4 写入文件

#include <iostream>
#include <iomanip>
#include <string>
#include <fstream>
#include <vector>using namespace std;
//写入文件
int main() {//若问写入操作，文件不存在，会自动创建文件//out： 每次写入都会覆盖源文件内容//app: 在末尾处追加内容fstream file{"../test2.txt",ios::app};if(file.is_open()){cout << "正常打开文件"<<endl;//写入数据file << "hi c++";//写入换行file << endl;//写入结束file.close();}else{cout << "无法正常打开文件" << endl;}return 0;
}

2.模板编程

2.1函数模板

模板的定义以template关键字开始，后面跟随着参数列表，使用<> 包含

2.1.1 函数模板的简单使用

#include <iostream>
#include <string>//函数模板
using namespace std;template<typename T>
T add(const T& t1,const T& t2){return t1+t2;
}
int main() {int result = add<int>(3,5);cout<<"result"<<result<<endl;return 0;
}

2.1.2 函数模板重载

#include <iostream>
#include <string>//函数模板 函数模板重载
using namespace std;template<typename T>
T add(const T& t1,const T& t2){return t1+t2;
}template<typename T>
T add(const T& t1 , const T& t2 , const T& t3){return t1 + t2 + t3;
}int main() {int result1 = add( 1, 2 );int result2 = add( 1, 2 ,3);cout <<"result1 = " << result1 << endl;cout <<"result2 = " << result2 << endl;return 0;
}

2.2 可变参数

2.2.1 省略号方式（不推荐使用）

#include <iostream>
#include <string>
#include <cstdarg>//可变参数 省略号方式
using namespace std;int add(int count,...){va_list v1;va_start(v1,count);int sum = 0;for(int i = 0; i<count;i++){sum+=va_arg(v1,int);}va_end(v1);return sum;
}
int main() {int result = add(3,2,3,4);//count是参数的个数cout<<result<<endl;return 0;
}

2.2.2 initializer_list 方式

#include <iostream>
#include <string>
#include <cstdarg>//可变参数 initializer_list
using namespace std;int add(initializer_list<int> il){int sum = 0;for (auto ptr = il.begin(); ptr != il.end(); ptr++) {sum+=*ptr;cout<<*ptr<<endl;}return sum;
}
int main() {int result = add({3,2,3,4});cout<<result<<endl;return 0;
}

2.3 可变参数模板

2.3.1 定义可变参数函数模板

#include <iostream>
#include <string>
#include <cstdarg>//定义可变参数函数模板
using namespace std;template <typename ...Args>
int add(Args...args1){int a =  sizeof...(args1);cout <<"传递进来的参数有："<< a << endl;
}int main() {add(2,3,4);return 0;
}

2.3.2 递归展开参数包

#include <iostream>
#include <string>
#include <cstdarg>//展开参数包
using namespace std;//这里定义一个空的函数，目的是为最后的递归终止。
int add(){return 0 ;}
template <typename T, typename ...Args>
int add(T t , Args...args){cout <<"打印的数字时：" << t << endl;//开始这里循环调用自己，知道最后那个没有参数的，才会调用外面的add()t += add(args...);return t;
}int main() {cout << add(1,2,3,4,5) << endl;return 0;
}

2.4 类模板编程

有时候继承、包含并不能满足重用代码的需要，这一般在容器类里面体现的尤为突出。例如： 我们定义了一个容器类，Container， 这个Container类可以实现类似verctor一样的工作，能保存数据，能修改数据，并且数据的类型不限制，但是针对数据的操作都是一样的。那么类模板编程就成了不二之选了。

template <typename T> class Stack{private :enum{MAX = 10}; //表示这个Stack容器最多只能装10个。int top =0 ; //表示最顶上的索引位置T items[MAX]; //定义一个数组，以便一会装10个元素
public:bool isempty(){return top == 0;}bool isfull(){return top == MAX;}//压栈int push(const T& val){if(isfull()){return -1;}//没有满就可以往里面存items[top++] = val;}//出栈T pop(){if (isempty()){return "";}//如果不是空 top 只是指向位置，而数组获取数据，索引从0开始，所以先--return items[--top] ;}T operator[](int index){if(isempty() || index > --top){cout <<"容器为空或者超出越界" << endl;return "";}return items[index];};
};

3.容器

3.1 顺序容器

• string 与vector相似，尾部插入|删除速度快
• array 固定大小数组，支持快速随机访问，不能添加和删除
• vector 可变大小数组，支持快速随机访问，在尾部之外的位置插入和删除 速度慢
• deque 双端队列，支持快速随机访问，两端插入和删除速度快
• forward_list 单向链表、只支持单向顺序访问，插入和删除快，查询和更新慢
• list 与单向链表不同，它是双向链表，其他一样

3.1.1 deque的简单使用

#include <iostream>
#include <string>
#include <deque>//deque
using namespace std;int main() {deque<int> de;de.push_back(10);de.push_back(20);de.push_back(30);cout<<"第一个是"<<de.front()<<endl;cout<<"最后一个是"<<de.back()<<endl;cout<<"长度"<<de.size()<<endl;cout<<"de[0]:"<<de[0]<<endl;de.at(0) = 100;//修改值for(int i:de){cout<<"遍历循环："<<i<<endl;}return 0;
}

3.1.2 forward_list简单使用

#include <iostream>
#include <forward_list>//forward_list
using namespace std;int main() {forward_list<int> flist = {10,20,30};//添加:: 只能在头的位置追加flist.push_front(100);//添加:: 在第一个位置的后面，插入一个新的元素。 需要使用迭代器来完成flist.insert_after(flist.begin() , 35);//删除:: 直接给元素值即可flist.remove(20);//修改元素值： 也可以使用迭代器的方式修改值flist.front() = 10;*flist.begin()  = 20;cout <<"第一个元素是：" << flist.front() << endl;cout << "排序后打印：" << endl;flist.sort();for(auto i = flist.begin() ; i != flist.end() ; i++){cout << "--->" << *i << endl;}return 0;
}

3.1.3 list简单使用

#include <iostream>
#include <string>
#include <list>//list
using namespace std;int main() {list<int> list1{1, 2, 3};//添加数据list1.push_front(10);list1.push_back(20);//删除元素list1.remove(2);//修改元素list1.front() = 10;cout << "第一元素：" <<list1.front() << endl;*list1.end() = 20 ;cout << "第一元素：" <<list1.back() << endl;//遍历链表：for (auto i  = list1.begin();  i != list1.end() ; i++) {cout <<" ---> "<< *i << endl;}return 0;
}

3.2 迭代器

#include <iostream>
#include <string>
#include <vector>//迭代器  使用迭代器
using namespace std;int main() {vector<int> s{88,85,90,95,77};cout <<"*s.begin():"<<*s.begin() << endl; //88cout <<"*(s.begin()+1):"<<*(s.begin()+1) << endl; //85cout <<"*(s.end()-1):"<<*(s.end()-1) << endl;//77//遍历容器for(auto i = s.begin() ; i != s.end() ; i++){cout << *i << endl;}return 0;
}

3.3 关联容器

关联容器和顺序容器有很大的不同，顺序容器的元素在容器中是有顺序的（按照添加先后计算） ， 而关联容器并不计较顺序的概念，因为他们是按照关键字来访问元素的。

3.3.1 pair简单使用

pair定义在头文件#include 中，一个pair保存两个数据成员，它是类模板，所以在创建对象的时候，需要添加泛型参数，以用来表示所保存的数据类型。

//关联容器 pair介绍
#include <iostream>
#include <string>using namespace std;int main(){pair<string ,int> p("张三",17) ;cout << p.first  << p.second <<endl;return 0 ;
}

3.3.2 map简单使用

map 只允许产生一对一的关系，也就是一个关键字对应一个值，如生活中大多数人，一人一套房差不多。但是也有人是名下多套房，这时候可以使用multimap, 它允许一个关键字对应多个值。

#include <iostream>
#include <string>
#include <map>
using namespace std;//map操作
int main() {map<string , string> address_map ;//添加//匹配可变参数列表address_map.insert({"张三" , "星湖花园1号"});address_map.insert(make_pair("李四" , "星湖花园2号"));address_map.insert(pair<string ,string>("王五" , "星湖花园3号"));//有疑问address_map.insert({"张三" , "星湖花园2号"}); //与第一个同关键字，会覆盖原有数据//访问string address = address_map["张三"] ;cout << address << endl;string address2 = address_map.at("李四");cout << address2 << endl;//修改address_map.at("张三") = "西湖花园X号";cout <<address_map["张三"] << endl; //99//容量查询bool empty = address_map.empty();cout <<"empty = " << empty << endl;//获取大小int size = address_map.size();cout <<"size = " << size << endl;//查询该key在map中的个数，可用来判断是否存在该keyint count = address_map.count("张三");cout <<"count = " << count << endl;//删除//迭代器方式删除。for(auto i = address_map.begin() ; i != address_map.end() ; i++){cout <<i->first << " =  "<< i->second << endl;if(i->first == "李四"){address_map.erase(i);}}//使用关键字删除address_map.erase("张三");//清空整个mapaddress_map.clear();return 0;
}

3.3.3 set简单使用

set就是关键字的简单集合，并且容器内部元素不可重复且有顺序。当只是想知道一个值是否存在时，set是最有用的。 set 为不可重复容器，而multiset为可重复容器。在set中每个元素的值都唯一，而且系统能根据元素的值自动进行排序。set中元素的值不能直接被改变。

#include <iostream>
#include <string>
#include <set>
using namespace std;//set
int main() {//创建容器并初始化，可变参数往里面赋值，但是这里添加了重复的3. 后面的3不会被添加进去。set<int> s{3,4,5,6,3};s.insert(16);s.insert({7,8,9,10}); //也可以接收可变参数//遍历setfor(auto p = s.begin(); p != s.end() ; p++){cout <<"遍历："<<*p<< endl;}//容量查询bool empty = s.empty();cout <<"empty = " << empty << endl;//获取大小int size = s.size();cout <<"size = " << size << endl;//查询该key在map中的个数，可用来判断是否存在该keyint count = s.count(4);cout <<"count = " << count << endl;//删除指定元素for(auto p = s.begin(); p != s.end() ; p++){cout <<*p << endl;if(*p == 4){s.erase(p);}}//清空这个容器s.clear();return 0;
}

3.4 常用容器函数

3.4.1 只读函数

#include <iostream>
#include <set>
#include <numeric>
#include <vector>using namespace std;int main() {//accumulate 它定义在头文件#include 中，所以不要忘记了导入头文件，它的功能是对一个容器的所有元素取和。set<int> s1({3,4,5,6});int a = accumulate(s1.begin(), s1.end() , 0 );cout <<"a:"<<a << endl;//equal 比较两个不同类型的容器是否保存了相同的值，比较的是里面保存的值，容器里面的元素类型要一样。set<int> s2{1,2,3,4,5};vector<int> v1{1,2,3,4,5};bool flag = equal(s2.begin(), s2.end(),v1.begin());cout <<"flag = " <<flag <<endl;return 0;
}

3.4.2 写入函数

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>using namespace std;//写入函数
int main() {//fill 给定一个范围，把这个范围的元素全部替换成指定的值。实际上也是填充的意思。vector<int> scores {10,20,30,40,50,60,70};for(int score :scores){cout <<"score = " << score <<endl;}fill(scores.begin() ,scores.end() , 0 ); //从起始到结束，全部用0替换。for(int score :scores){cout <<"score = " << score <<endl;}//copy 由于数组是不允许拷贝的，若要对数组进行一次拷贝，通常使用copy 函数来实现int scores1[] {66,77,88,99,100};int size = sizeof(scores) / sizeof(int);int scores2[size];//参数一，表示起始位置，参数二： 结束为止，参数三：拷贝的目标位置copy(begin(scores1), end(scores1) , scores2);for(int i = 0 ; i < size; i++){cout << i << " = " << scores2[i] << endl;}//替换vector<int> scores3 {30,20,30,40,30,60};//把容器中，从开始到结束为止，所有的30，替换成100.replace(scores3.begin(),scores3.end(),30 , 100);for(int score : scores3){cout << " ===> " <<score <<endl;}//重新排序vector<string> scores4{"ab","bc","aa","abc","ac"};//默认使用字母表顺序排序sort(scores4.begin(),scores4.end());for(string score : scores4){cout << " ===> " <<score <<endl;}//删除重复元素vector<int> stu_vector{ 100,90,88,75,90,88,90};//如果是我们自己做。遍历 ---> 不重复的元素，装到一个vector，然后返回vectorsort(stu_vector.begin() , stu_vector.end());//先排序，然后确定唯一值，所有不重复的值先放前面， 重复的值放后面， 这个end就是指向了//最后一个不重复的值位置auto end = unique(stu_vector.begin() , stu_vector.end());//删除从最后不重复位置开始一直删除到vector的末尾位置，//因为所有的重复元素都已经赶到了末尾。 其实并不是删除，只是隐藏了而已。stu_vector.erase(end , stu_vector.end());for (int a : stu_vector){cout << a << "\t";}cout <<"vector的长度是：" <<stu_vector.size() << endl;cout << "vector的下标4的元素是："<< stu_vector[4] << endl;cout << "vector的下标5的元素是："<< stu_vector[5] << endl;return 0;
}

4.函数对象

4.1 function

4.1.1 接收全局函数&接收lambda表达式

#include <iostream>
#include <functional>using namespace std;void print(int a , string b){cout <<a <<" = " <<b << endl;
}int main(){//使用function对象接收函数 <void (int , string)>//前面的void 表示返回值  <>表示接收的参数类型，个数要对应上。function<void (int ,string)> f = print;f(3, "fly");function<int (int ,int)> f1 = [](int a ,int b){return a + b ;};cout << f1(1 , 2 ) <<endl;return 0 ;
}

4.1.2 接收静态成员函数

#include <iostream>
#include <functional>
using namespace std;//接收静态成员函数class stu{public:static int run(string name ,int age){cout <<age <<" 的 "<< name << " 在跑步... "<< endl;}
};int main() {function<int (string, int)> f = stu::run;f("fly",20);return 0;
}

4.1.3 接收成员函数

#include <iostream>
#include <functional>
using namespace std;//接收成员函数class stu{public:int run(string name ,int age){cout <<age <<" 的 "<< name << " 在跑步... "<< endl;}
};int main() {function <int (stu , string , int )> f1 =  &stu::run; //正确写法 对象function <int (stu& , string , int )> f2 =  &stu::run; //正确写法 对象引用function <int (stu* , string , int )> f3 =  &stu::run; //正确写法 指针//真正调用run();stu s1;f1(s1 , "张三" , 18 ); //会发生拷贝 这里指的是stu发生拷贝，stu s2;f2(s2 , "张三" , 18 ); //避免发生拷贝 ， 这里指的是stu发生拷贝，，引用指向实体stu s3;f3(&s3 , "张三" , 18 );return 0;
}

4.2 bind

可以理解为把函数 、函数的实参以及调用函数的对象打包绑定到一起。然后用一个变量来接收它，这个变量也就是这些个打包好的整体。

4.2.1 绑定全局函数

#include <iostream>
#include <functional>
using namespace std;//绑定全局函数
int add3(int a ,int b){cout <<"执行了add函数" << endl;return a + b;
}int main() {//可以看成是把p 绑定到add3上， 以后使用p() 等同于 add3()//但是bind的一个好处是，参数不用在后续调用p()的时候传递了，因为在绑定的时候已经传递进来了。auto p1 = bind(add3 , 3 ,4 );int result1 = p1();cout <<"result1 = "<< result1 << endl;//也可以是用function来接收，但是由于参数的值已经在bind的时候传递进去了，所以接收的时候//function的参数可以使用() 表示无参。否则在调用p1的时候，还必须传递参数进来function<int ()> p2 = bind(add3 , 5 ,4 );int result2 =p2();cout <<"result2 = "<< result2 << endl;return 0;
}

4.2.2 绑定成员函数

#include <iostream>
#include <functional>
using namespace std;class stu{public :int run(string name ,int age){cout <<age << " 的 " << name << "在跑步" << endl;return 10;}
};int main() {stu s ;function<int ()> f= bind(&stu::run , s , "张三" ,18);f();//使用auto 完成类型推断。auto b = bind(&stu::run,s,"张三",18 );b();return 0;
}

4.2.3 使用 placeholders占位

#include <iostream>
#include <functional>
using namespace std;// 使用 placeholders占位class stu{public :int run(string name ,int age){cout <<age << " 的 " << name << "在跑步" << endl;return 10;}
};int main(){stu s ;//placeholders::_1 , 表示run的第一个参数，现在先不给，后面调用的时候再给。auto b = bind(&stu::run,s,placeholders::_1,18 );b("王五");stu s2 ;function <int (string)> f = bind(&stu::run,s2, placeholders::_1,19 );f("李四");return 0 ;
}

---

结束！！！

C++快速讲解（九）：I/O操作、模板编程、容器、函数对象相关推荐

1. C++模板学习之函数对象之谓词

   函数对象是用对象来表示的函数: 可以执行operator()的对象都叫做函数对象. 谓词是那些返回bool,operator()操作的函数对象. 考虑如何对一个序列求和: 函数对象的优势在于可以将参数 ...

2. Python之数据分析（Numpy的矩阵相关操作、ufunc泛化函数对象）

   文章目录 一.矩阵相关操作 二.ufunc统一泛化函数 一.矩阵相关操作 1.三种构造矩阵的方法 np.matrix(二维容器, copy=True) 一参为可被解释为矩阵的二维容器,比如二维数组.二 ...

3. 【C++ 语言】面向对象 ( 模板编程 | 函数模板 | 类模板 )

   文章目录 函数模板 类模板 代码示例 函数模板 1. 模板编程 : 类似于 Java 中的泛型编程 ; ① 函数模板 : 对应着 Java 中的泛型方法 ; ② 类模板 : 对应 Java 中的泛型类 ...

4. 二叉树(类模板、函数模板、函数对象、函数指针)

   这个二叉树的代码只是简单的实现了一些功能,比如插入和遍历.关键是用到了函数指针和函数对象,还有shared_ptr. 其中shared_ptr一定定义在节点中,因为new出来的空间时节点,释放的时候是 ...

5. is属性用法 vue_vue组件讲解(is属性的用法)模板标签替换操作

   vue中is的属性引入是为了解决dom结构中对放入html的元素有限制的问题,譬如ul里面要接上li的标签,引入is的属性后,你完全可以写成这样 这样会保证dom结构在浏览器的正常渲染,尽量避免在不正 ...

6. Allegro如何使用快捷键快速切换走线线宽操作指导

   Allegro如何使用快捷键快速切换走线线宽操作指导 Allegro可以用快捷键快速切换走线线宽,比如在command下方输入数字5,可以切换到5mil的线宽 具体操作如下 打开系统属性,选择环境变量 ...

7. 利用Snippet快捷键在TeXpad上快速初始化中文环境的LaTeX模板

   利用Snippet在TeXpad上快速初始化中文环境的LaTeX模板 背景 在 TeXpad 中,利用快捷键键入 Snippet 被设置为一个专门的 Meau 对用户进行展示,并提供了一个 Add/E ...

8. 现场总线快速讲解之一

   随着物联网.工业互联网.工业4.0.中国制造2025等等词汇的大热,现场总线又将成为行业的热门技术,需要在技术上,尤其是要在思维方式上进行一次全面的革新. 过去学习现场总线的一般都会参考<现场总 ...

9. 论文、报告及教案公式编辑：图片公式转换Mathpix snipping Tool、快速编辑神器AxMath插件操作使用的几种用法（最详细精致）

   图片公式转换Mathpix snipping Tool及快速编辑神器AxMath插件操作使用的几种用法(最详细精致) [文章内容较多, 点击目录链接可直达标题内容] 文章目录 图片公式转换Mathpi ...

最新文章

1. 最小化安装时没有ifconfig命令，没有firewalld.service
2. 二叉树的基本特性和二叉树的几种基本操作的机制_关于二叉树，你该了解这些！...
3. Nginx 搭建图片缓存服务器-转
4. Java怎么查找字符串大写_在Java中，如何检查字符串是否包含子字符串(忽略大小写)？...
5. Angular自学笔记（一）ngModule 元数据
6. Git管理多个远程分支
7. 【搜索】【广搜模板】
8. 归并排序的java代码_归并排序的原理及java代码实现
9. css修改上传文件按钮样式,CSS自定义文件上传按钮样式，兼容主流浏览器
10. 电脑网速,别把宽带浪费了，一招提升电脑网速
11. 计算机辅助档案管理文字说明,计算机辅助档案管理
12. （内附独家PPT）李岩：CynosDB高可用系统介绍
13. matlab 张正友工具箱,TOOLBOX_calib0 张正友的标定工具箱，直接运行会有错误，这是经过修改的 首先 _gui,确 matlab 238万源代码下载- www.pudn.com...
14. Arduino 读取 Pin2 的电平信号，并把结果打印到串口，也同时反映到 LED 灯
15. 饭谈：高手是怎么炼成的？
16. 中兴echat_中兴通讯助力公共安全行业数字化转型
17. Python OpenSSL 解析证书
18. vue3.0 组件传值
19. 苹果开机是白苹果黑屏_这是苹果应如何回应史诗般的1984年诱饵
20. 2022年数维杯国际赛ABCD题思路

热门文章

1. 有意思，原来SQL中的NULL是这么回事儿
2. S-function入门及案例详解（2）——S-function基本案例介绍
3. CG快报 2011.11.22
4. 【转】最全网上纳税申报流程
5. vivos9更改控制中心样式(修改方法分享)
6. docker简单学习
7. python 股票竞价数据_GitHub - TruthHun/auction-stock: 集合竞价选股(股票)，基于收盘价与前收盘价的选股策略...
8. 学院图书管理系统的设计与实现
9. OP向左，SaaS向右，如何选择？
10. 千道Java面试真题整理系列：MySQL灵魂五十问，在遇面试也不怕！