一个demo学会c++编程

学习了c++高级编程这本书，自己喜欢边学边总结边写demo，所以写了这篇文章，包含了大部分的c++编程知识。让你一个demo掌握c++编程，如果有问题可以留言。
此demo主要包括三个文件：namespace.h文件，包含了自定义空间、空间函数、空间变量、空间自定义类；namespace.c文件为namespace.h文件中定义函数的实现;main.cpp文件为主程序运算。

namespace.h和namespace.cpp包含了自定义基、继承类、模板类的定义及实现。涉及到自定义类的构造函数、重载构造函数、函数默认值、析构函数、复制构造函数、重载运算符（赋值函数、加法函数）、虚函数、常值函数、静态函数、静态变量、常值变量、枚举变量、内部类、访问修饰符、继承、重写虚函数、基类引用、不定参数函数、友函数、友类、类型引用、终态函数、终态类、模板变量等内容。

namespace.h文件

#pragma once  //防止文件被多重包含#include <stdio.h>#include <iostream>  //数据流#include <string>  //字符串#include <exception>  //异常#include <stdarg.h>  //变化参数#ifndef PI   //如果没有定义PI则定义，否则跳过  避免重复包含#define PI 3.1415926#endifusing namespace std;  //常用空间函数//自定义命名空间namespace mynamespace{//静态整型static long long timenow;//自定义函数void myfun(string str);                                 //自定义类-学生类class Student{public:                                                             //公共成员，外部可以访问的成员    Student();                                                      //无参构造函数   //默认构造函数（参数全有默认值+无参函数）可以无参调用    Student(string name,int age=default_age);                       //有参构造函数   //函数名相同,方法重载,age含有默认参数,此参数可有可无    Student(int age);                                               //有参构造函数 //函数名相同,方法重载,函数名相同，参数类型和数量不同的为重载，与返回值无关    virtual ~Student();                                                //析构函数  //销毁对象时，自动调用该函数，该方法用来释放内存，最好设为虚函数，这样多态特性，能销毁派生类对象创建的内存    Student(const Student& another);                                //复制构造函数    Student& operator=(const Student& another);                     //重载赋值运算符，在函数内生成类对象的就要返回类，没有生成类对象的返回类引用    //可以重载关系运算符 算数运算符  递增递减运算符  按位运算  二元逻辑运算符  插入<<运算符  提取>>运算符  下标运算符  函数调用运算符  解除引用运算符  内存分配和释放运算符    Student operator+(const Student& another) const;                //加法运算符重载  Student的加法运算，const函数不改变类内成员，返回对象不返回引用是因为生成了一个新的对象，与原对象并列存在    Student operator+(const string& anothername) const;             //加法运算符重载   避免重载时的隐式转化 +必须在Student的后面。对象名称既可以作为对象返回，又可以作为对象引用返回    virtual void setname(string name);                              //virtual关键字，虚函数，支持派生类重写，最好所有函数都设置为虚函数，java就是这么做的    string getname() const;                                         //不改变数据成员的函数声明为const    void setage(int age);                                           //常规函数声明    static int getage();                                            //static关键字，静态函数，静态方法不能重写，不存在继承  //静态方法属于定义它的类的名称，不属于特定的对象，调用时使用名字解析    static string default_name;                                     //静态数据,存储在静态区    static const int default_age=18;                                //const关键字，常值数据，数据存储在文字常量区，const数据定义时需要赋值。                                                                    //mutable标记的为可变变量   在const函数中可以改变值的变量    enum allsex{boy,girl};                                          //enum关键字，枚举类型，用于限定参数的取值范围，相等于define，或者const    class sex{                                                      //定义内部类，性别    public:        string getsex();           void setsex(allsex sextype);                                //使用枚举类型作为参数    private:        string sexstr;    };protected:                                                          //派生类可以访问的成员    string name;private:                                                            //只能在类内访问的成员    int age;};//派生类-班长类 class Monitor:public Student                                       //公有继承   public代表基类的最高访问权限  所有操作的权限自动降级为此权限  尽量使用public { public:     Monitor(){                                                     //构造函数不能继承         this->task = "帮助老师管理班级";                           //函数定义可以直接在声明中实现，也可以在对象cpp中实现，也可以不实现，在调用时实现         name="monitor";         cout<<"无参派生类构造函数"<<endl;                           //cout<<           <<endl; 输出内容到dos窗口     };         virtual void setname(string name) override                     //override，重写虚方法  virtual、override可以不写，override写上以便与隐藏函数混淆     {         this->name=name;                                           //this作为对象Student         cout<<"派生类设置名称参数:"+name<<endl;     }     using Student::getname;                                        //包含基类函数，使用using关键字显示的包含基类中定义的同名的所有版本的方法，包含后相当于在当前内中展开     string getname(string surname)                                 //创建新成员函数，与基类形成重载  因为参数不同，若不使用using包含，则会隐藏基类函数     {         cout<<"派生类获取名称参数:"+surname+name<<endl;         return surname+name;     }     void setage()                                                  //隐藏基类函数，与基类函数同名     {          age=7;          cout<<"派生类设置年龄参数:"<<age<<endl;     }     int getage(){                                                  //创建对象成员函数，基类中的函数为静态函数，不属于对象，属于类         cout<<"派生类读取年龄参数:"<<age<<endl;         return age;     };     string gettask(){return task;};                                //创建对象成员函数     void settask(string task,...){                                 //...表示不定长的参数数目。创建对象成员函数         va_list arg_ptr;                                           //定义参数列表         va_start(arg_ptr,task);                                    //将参数列表起始位置绑定为第一个参数         string aa=" ";        // while (aa!="" && !aa==NULL)                              //无法对参数列表个数或结尾进行判断，必须自己传入特性参数来代表个数或结尾         {             aa = va_arg(arg_ptr,string);                           //迭代读取参数，并转化为相应的类型         }         va_end(arg_ptr);                                           //参数清理工作         this->task = task;     };                  private:     int age;                                                       //基类中age为private，派生类无法访问，派生类重新定义     string task;                                                   //添加派生类自有属性 }; //自定义类-老师类 class Teacher { public:     Teacher():name("teacher"),course("语文"){                        //基类的默认构造函数，同时初始化数据成员name、course         cout<<"基类无参构造函数："+name<<endl;     };      Teacher(string name){cout<<"基类有参构造函数："+name<<endl;};   //基类的有参构造函数     ~Teacher(){cout<<"基类析构函数"<<endl;};                        //析构函数     friend class Student;                                          //友元，Student 类中所有的方法可以访问Teacher的private、protected、public数据成员和方法     friend void Student::setname(string name);                     //只有设置友元的函数可以访问当前类的成员和方法，只有Student:;setname函数可以访问Teacher的成员方法     virtual Student& getstudent()=0;                               //=0代表为纯虚函数，没有定义方法，只是声明了方法，包含纯虚函数的类为抽象类，抽象类不能实例对象     virtual void setstudent(Student& students) =0;                 //&为引用，相当于变量别名     virtual string getname() final{                                //final函数，禁止重写，用在派生类再次被继承后重写的情况下;          cout<<"基类获取名称参数："+name<<endl;return name;};       virtual void setname(string name="teacher"){this->name = name;};  private:     virtual string getcourse(){return course;};                    //c++中，private函数也可以虚化重写，java中只能重写public和protect方法//继承时可以修改访问限制符     string name; protected:     string course; }; //创建班主任类 class Headmaster final:public Teacher          //final标记的类不能被继承 { public:     //using Teacher::Teacher;                                      //构造函数不能继承，只能显示调用     Headmaster(){cout<<"派生类无参构造函数：headmaster"<<endl;}; //派生类的构造函数  调用前会自动调用基类的默认构造函数     Headmaster(string name):Teacher(name){                         //派生类的构造函数,调用前会调用显示引用的基类构造函数         cout<<"派生类有参构造函数："+name<<endl;     };       ~Headmaster(){cout<<"派生类析构函数"<<endl;};                    //析构函数     //使用时,默认参数取值根据指针类型  函数方法根据指向对象     //virtual void setname(string name="headmaster") override;     //派生类的构造函数  没有using时  默认为重写了所有版本   有using时，表示重写了当前版本   派生类可以使用不同的默认参数     virtual Student& getstudent() override{return student;};       //记得添加override,因为基类改变,派生类没改变会报错,这样提醒修改派生类     virtual void setstudent(Student& students) override{           //应该重写,重载方法的,所有版本。虚函数可以不重写，重写不重写都保持函数虚化特性         this->student = student;};      virtual string getcourse() override{return course;};           //重写基类的private函数，并修改访问修饰符 private:     Student student;  }; }; template<class TT=int>  class classA{                              //template<class T>为模板，类型T为不确定类型，classA为类模板,可以为不定类型设置默认值，但是在使用类定义示例时，仍然需要使用<> public:     TT add(TT tt,TT pp);                                           //使用模板函数     template<class TT> TT plus(TT tt,TT pp){                       //在类模板内部定义函数         return tt+pp;     } };

自定义空间namespace.app文件

#pragma once  //防止文件被多重包含#include <stdio.h>#include <iostream>  //数据流#include <string>  //字符串#include "namespace.h"using namespace std;using namespace mynamespace;void mynamespace::myfun(string str) {    cout<<str<<endl;}//构造函数 //设置成员数据初始化值Student::Student():name("student"),age(default_age)  {    cout<<"无参基类构造函数："+name<<endl;}//构造函数Student::Student(string name,int age){    this->name=name;    this->age = age;    cout<<"有参基类构造函数："+name<<endl;}//构造函数Student::Student(int age){    this->age = age;    name="student";    cout<<"有参基类构造函数："+name<<endl;}//复制构造函数Student::Student(const Student& another){    name=another.name;    age=another.age;    cout<<"基类复制构造函数："+name<<endl;}//赋值构造函数Student& Student::operator=(const Student& another){    //自赋值检测    if (this==&another)    {        return *this;    }    //释放this原内存    //赋值新内存    name = another.name;    age=another.age;    cout<<"基类赋值构造函数："+name<<endl;    return *this;}//运算符重载Student Student::operator+(const Student& another) const{    Student student;    student.setname(name+" and "+another.name+"'s group");    student.setage((age+another.age)/2);    cout<<"基类加法运算符重载"<<endl;    return student;}//运算符重载Student Student::operator+(const string& anothername) const{    Student parents(anothername);    cout<<"基类加字符串运算符重载"<<endl;    return parents;   //不能返回局部对象的引用。  返回对象，会将局部对象赋值给接收对象，再销毁局部对象。不销毁指针内存。返回引用，将局部引用赋值给接收引用，再销毁局部对象，则接收引用的内容也全部销毁了。}void Student::setname(string name)   //无需重复使用virtual{    this->name=name;   //this作为对象Student    cout<<"基类设置名称参数:"+name<<endl;}string Student::getname() const{    cout<<"基类读取名称参数:"+name<<endl;    return (*this).name;  //this是指针  可以取指向值    //return name;}void Student::setage(int age){    cout<<"基类设置年龄参数"<<endl;    this->age=age;}int Student::getage(){    cout<<"基类共享静态函数读取年龄参数"<<endl;    return default_age;   //静态函数只能操作静态数据}//析构函数   所以堆栈指针在函数退出时总是会自动释放指向的堆中的内存。造成原内存损坏（调用函数）Student::~Student(){    cout<<"基类析构函数:"+name<<endl;    //这里填写释放对象内存的函数}//嵌套类函数定义string Student::sex::getsex(){    return sexstr;}//嵌套类函数定义void Student::sex::setsex(allsex sextype){    if (sextype==boy)        sexstr = "boy";    else        sexstr = "girl";}//在类模板外部定义成员函数的方法为：template<模板形参列表> 函数返回类型 类名<模板形参名>::函数名(参数列表){函数体}，template<class TT> TT classA<TT>::add(TT tt,TT pp){     return tt+pp;}               

main.cpp文件主要涉及头文件引用、空间引用、结构体、类型别名、常值变量、全局变量、常值函数、函数别名、函数指针、函数声明、函数参数、内联函数、模板函数、时间函数、输入输出流、字符串转换、变量推导、类的指针和数组、lambda表达式、智能指针、类型向上转型、输入输出文件流、STL容器和算法操作、数组、向量、列表、堆栈、队列、集合、映射、迭代器、搜索算法、分区算法、排序算法、操作算法、字符串正则表达式、多线程、线程安全、自定义字面量、变长模板等内容

主文件main.cpp文件

#pragma once                  //防止文件被多重包含#include <stdio.h>#include <stdlib.h>#include <chrono>             //正则表达式   vs2012后有#include <iostream>           //数据流#include <memory>             //内存操作#include <fstream>            //文件流#include <string>             //字符串#include <regex>              //正则表达式#include <exception>          //异常#include <stdexcept>          //异常类型#include <iterator>           //迭代器#include <array>              //可获取大小的固定数组#include <vector>             //数据结构  连续分布的动态数组#include <list>               //不连续分布的双向链表#include <deque>              //双头队列#include <queue>              //先入先出队列#include <stack>              //先入后出堆#include <set>                //有序集合#include <map>                //哈希表#include <algorithm>          //STL算法#include <numeric>            //数值计算算法#include <math.h>             //数值计算算法#include <functional>         //函数指针，将函数指针作为自定义函数参数   实现设置回调函数#include <thread>             //多线程库   vs2012后有#include <atomic>             //原子类型  线程安全  vs2012后有#include <mutex>              //互斥体类型  vs2012后有#include <time.h>             //时间类型#include "namespace.h"        //自定义空间  ""先搜索本地目录  再遍历全部  <>遍历系统目录     引用h文件  相当于h文件直接展开using namespace std;                                                    //重用空间函数using namespace mynamespace;                                            //自定义命名空间   要避免不同空间下的同名变量函数冲突struct People                                                           //自定义结构体{    string name;    int age;}People1;                                                               //People是类型，People1是变量typedef int* intptr;                                                    //类型别名  typedef为已有类型声明提供一个新的名称  using有类似功能const string studentname = "student";                                   //常量变量  任何不再名称空间、函数、类中的名称都被认为全局作用string stringtemp="";                                                   //全局变量const int getstudentnumber(){return 33;}                                //常量表达式typedef void (*funtype)(string);                                        //定义函数指针类型  输入string  返回void    等价于 using funtype = void (*)(string);。为了出现频率高的代码，避免改动繁琐性和书写繁琐性//function<void(string)> function_pointer = printstring;                //函数指针//void (*function_pointer)(string str)= printstring;                    //函数指针void printstring(string str);                                           //函数声明void process(const vector<string>& vec,function<void(string)> fun);     //函数声明inline void sprintf1(string str){                                       //内联函数，编译时在代码处展开，为读使用频率高，且代码量小的函数。避免改动繁琐型和调用快捷性    cout<<str<<endl;}void printstring(string str)                                            //自定义函数（打印输出字符串）{    cout<<str<<endl;}void process(const vector<string>& vec,function<void(string)> fun)      //自定义函数（调用函数fun，调用向量成员）{    for (auto& item:vec)        fun(item);}template<class T> void print(T a)                                       //模板函数，函数模板通式{    cout<<a<<endl;}string Student::default_name = studentname;                             //类内静态变量，无需创建对象，初始化需放在函数外全局区域int main(){    myfun("代码调试者：栾鹏");                                          //调用自定义空间内函数，//两个字符串常量不能相加    cout<<"============基本类型数据============"<<endl;                   //cout<<    <<endl打印输出    timenow = time(NULL);                                               //空间静态变量，直接使用，此句返回的只是一个时间戳    cout<<"当前时间戳"<<timenow<<"\n";                                   //时间戳表示指定时间点距离标准时间原点之间的秒数    int* const temp = new int(0);                                       //const作用于左侧的类型(作用于*指针)，此处表示指向不变，若作用于int(const int*  var)，表示指向的数据不变    int& studentnumber = *temp;                                         //设置引用,引用不占内存,不创建对象,只是别名    cout<<"默认学生名称为"+studentname+"\n";                           //cout中支持转移字符，支持打印各种类型数据    cout<<"默认班级人数为"<<(studentnumber = getstudentnumber())<<endl; //打印输出，常量变量、调用常量表达式，endl是换行刷新    string str1 = to_string(std::min(studentnumber,22));                //其他类型转化为字符串。min和max被vs中windows.h定义为了宏，导致库里面的正常函数没法使用:    string str2 = str1+"34";                                            //字符串使用+合并，字符串不能直接初始化为两个常量字符串相加。如果不能string str2 = "11"+"34";        studentnumber = (stoi(str2))/10;                                   //字符串转化为指定进制的其他类型，stoi，stof，stod    cout <<"算上班主任，班级人数："<<studentnumber;    cout.flush();                                                       //显示刷新数据流，写入控制台，不换行    //float classtime = 45_min+50_s;                                    //调用自定义字面量，c++11后才有    classA<int> initstr;                                                //定义模板类 <>内替换成需要的类型，                    auto  int1=initstr.plus(3,2);                                       //自动变量类型，会去除const限定符和引用     decltype(int1) int2=0x11;                                           //类型借用，0x为16进制表示    int int3=int1^int2;                                                 //补码按位异或   即101与10001  按位异或为10100    cout<<"；其中男孩个数约"<<int3<<endl;                               //打印输出    classA<> initstr1;                                                  //使用默认类型参数                                                                        //栈stack跟随函数，一个函数，一个堆栈，相互不影响，自动释放，一级缓存，先进后出，内存限定  内存向下增长                                                                        //堆heap，公共空间  手动释放，二级缓存存储，链表结构，内存根据物理内存，内存向上增长。                                                                        //全局区、文字常量区、程序代码区   字符指针初始化的字符串在常量，指针在栈上    cout<<"============类的指针与数组============"<<endl;    Student* student=nullptr;                                           //指针定义初始化为空    student = new Student;                                              //开辟指针内存   指针存在栈中  对象在堆中    //student->age = 3;                                                 //私有成员  无法访问    //(*student).name = "小明";                                           //保护成员   无法访问    student->setname("小明");    delete student;                                                     //释放指针内存    student = nullptr;                                                  //指针置空   防止野指针    Student* students=nullptr;                                          //类指针定义，初始化为空    students = new Student[3];                                          //开辟数组内存    delete[] students;                                                  //释放数组内存    string namestr;    int age;    print("输入学生姓名和年龄：");                                        //调用模板函数    cin>>namestr>>age;                                                  //获取从窗口输入的数据，分别放在namestr变量和age变量中    auto vlambda = [namestr](int age){                                  //lambda表达式，函数名代替函数体展开  []内为捕获变量  ()内为参数，在没有参数时可以不加()        cout<<"创建学生结构体：名称："+namestr<<"；年龄："<<age<<endl;    };      vlambda(age);                                                       //展开vlambda函数    cout<<"============学生,基类操作============"<<endl;    Student student1("晓刚");                                         //在堆栈中创建对象    student1.setname("小刚");                                         //调用类内函数，在栈上使用对象    Student* student2 = new Student("晓红",7);                            //使用new 开辟的内存在堆上，指针在栈上，需要代码释放在堆上的对象    student2->setname("小红");                                            //在堆上使用对象    Student student3(student1);                                         //调用复制构造函数，即复制一个对象，    Student& student4 = student3;                                       //设置引用,引用不创建对象,只是别名    student4 = *student2;                                               //赋值构造函数    student4.setname("小刘");    Student student5 = student1+student4;                               //重载加法运算符    student5 = student3+"小韩";                                           //重载加法运算符    cout<<"学生列表："+student1.getname()        <<+"、"+student2->getname()        <<"、"+student3.getname()        <<"、"+student4.getname()        <<"、"+student5.getname()<<endl;    delete student2;                                                    //释放内存，会调用析构函数。只有通过new开辟了内存的才需要释放，否则会自动释放    student2 = nullptr;                                                 //指针置空，避免野指针    auto student6 = unique_ptr<Student>();                              //使用智能指针，指针销毁时会自动销毁指向内存，在try catch中不用担心出错而指针内存泄漏    cout<<"============班长派生类操作============"<<endl;    Monitor monitor;                                                    //生成派生类，会先调用基类构造函数，再调用派生类构造函数    Student student11 = monitor;                                        //派生类转化为基类，产生截断，这里调用的是基类的构造函数    //指向派生类对象的基类指针，可以调用派生类重写的虚函数、基类中的非虚函数、基类的默认参数、基类中未被重写的虚函数(被派生类继承默认了)    Student& student12 = monitor;                                       //引用指向派生类对象，派生类转为基类，不产生截断。引用定义时需要初始化，引用不可改变    student12.setname("小明");                                            //调用派生类重写的虚函数    student12.getname();                                                //调用基类函数    student12.getage();                                                 //静态函数，所有对象共享    Student::getage();                                                  //静态函数，可通过类型名称调用    monitor.getname("王");                                               //调用派生类的新增函数    monitor.getname();                                                  //调用派生类包含的基类函数，不包含没法调用    monitor.setage();                                                   //调用派生类覆盖的函数    monitor.getage();                                                   //    cout<<"============老师类型操作============"<<endl;    Teacher* teacher = nullptr;                                         //抽象类不能实例化对象，但是可以建立指针                                                       teacher = new Headmaster();                                         //抽象类的子类可以实例化对象   因为子类重写了所有纯虚函数，使得子类成为非抽象类    teacher->getname();                                                 //指针可以调用基类的方法，因为存在声明  但是实现方法是不一定   因为不同派生类写入方法不同    delete teacher;                                                     //基类指针    Headmaster Headmaster1("刘家航班主任");                                   cout<<"============流操作============"<<endl;    ifstream infile("input.txt", std::ios::in);                                     //输入文件流ifstream  输出文件流  ofstream   fstream双向文件流同时读写文件    ofstream outfile("output.txt",ios_base::trunc);                     //app写之前移动到文件尾，ate打开后移动到文件尾，binary二进制模式输入输出                                                                        //in从头开始读   out从头开始写   trunc打开删除已有数据    if (outfile && infile)    {        try                                                             //try{}catch(){}  尝试运行某段代码        {            infile.tie(&outfile);                                       //将输入流与输出流绑定，输入流会自动刷新至输出流，两个输出流也可以绑定，实现同步            string readstr;            infile>>readstr;                                            //读入数据流  数据流同时进入输出流            outfile<<readstr;                                           //再一次写入字符串            ios_base::streampos curpos = outfile.tellp();               //获取标记位置，输出流tellp，输入流tellg            if (10==curpos)                                             //这里等号两边缓过来会报错            {                                                                        //输出流seekp，输入流seekg //iso_base::end流的结尾，iso_base::beg流的开始，iso_base::cur流的当前位置                outfile.seekp(-2,ios_base::end);                        //-2表示指定流位置前面2个位置                outfile<<0;                outfile.close();            }            char line[1024]={0};                                        //按行读取文件            while(infile.getline(line, sizeof(line)))             {            }        }        catch (const exception err)                                     //抛出异常并不一定遵循异常列表，java只能抛出异常列表中的异常        {                                                               //c++中的所有异常都是exception的派生  所以抛出exception 没有针对性            cout<<"异常描述:"<<err.what()<<endl;                        //所有异常类都有.what()，异常描述函数        }        catch (...)                                                     //匹配所有异常                  {                                                               //try catch 中异常类不需要字符串设置构造函数 throw需要字符串设置异常类的构造函数            throw invalid_argument("无法打开文件");                     //抛出invalid_argumenty异常  除exception的所有异常类都需要字符串设置构造函数        }    }else        cout<<"文件不存在"<<endl;    cout<<"============STL容器和算法操作============"<<endl;            //STL  4类16大容器                                                                        //顺序容器  vector、deque、list、forward_list、array                                                                        //关联容器map、multimap、set、multiset                                                                        //无序关联容器或哈希表 unordered_map、 unordered_multimap、unordered_set、unordered_multiset                                                                        //容器适配器  queue、priority_queue、stack    //容器：一定数据结构的数据集；分配器：数据元素的内存管理；元素迭代器iterator:容器元素的访问（指向元素的指针）；算法：数据运算    array<string,3> allstr0 = {"name1","name2","name3"};                //可获取大小的固定数组    vector<string> allstr1=vector<string>(10);                                              //连续分布的动态数组    list<string> allstr2;                                               //不连续分布的双向链表    deque<string> allstr3;                                              //连续分布的双头队列    queue<string> allstr4;                                              //先入先出的队列    stack<string> allstr5;                                              //先入后出的栈    set<string>  allstr6;                                               //有序的元素唯一的集合    multiset<string> allstr7;                                           //有序的元素不唯一的集合    map<string,int>   map_student;                                      //multimap支持重复键值    map_student.insert(pair<string,int>("小明",12));                  //map的插入    string allnamestr[]={"小明","小王","小刚","小红","小刘"};    vector<string> allstudent(allnamestr, allnamestr+5);                //数组转化为向量    //allstudent.assign(5,"studentname");                               //动态分配内存    vector<string> allteacher(2);                                       //定义字符串向量;    allteacher[0]="王老师";    allteacher[1]="张老师";    if (allstudent!=allteacher)                                         //向量==或!=进行了重载    {        allstudent.push_back("小张");                                 //尾部添加元素        allstudent.pop_back();                                          //尾部删除元素        auto iter = begin(allstudent);                                  //获取首部        allstudent.insert(iter,"小李");                                   //在指定位置插入元素        iter++;                                                         //相当于指针++        *iter = "小陈";        allstudent.erase(iter);                                         //在指定位置删除元素  删除后iter不能继续使用了        for (vector<string>::iterator iter1 = begin(allstudent);iter1!=end(allstudent);++iter1)        {            cout<<*iter1<<endl;        }        for (const auto& iter2:allteacher)                              //迭代器引用，反向迭代器rbegin(vectorstr1)，insert_iterator插入迭代器，move_iterator移动迭代器        {            cout<<iter2<<endl;        }    }    process(allstudent,[](string str){cout<<str<<endl;});               //使用lambda设置遍历的回调函数    process(allteacher,printstring);                                    //自定义函数作为参数传递    int sum=0;    vector<int> vectorint1(10,1);    auto it = find_if_not(begin(vectorint1),end(vectorint1),[](int i){return i<8;});    //搜索算法    for_each(begin(vectorint1),end(vectorint1),[&sum](int i){sum+=i;});                 //操作算法，每个元素执行回调函数    partition(begin(vectorint1),end(vectorint1),[](int i){return i%2;});                //分区算法  一个目标到两个目标  通过返回值 true、false决定区间//lambda表达式，返回true的排在前面   返回false的排在后面    std::sort(begin(vectorint1),end(vectorint1));                                           //排序算法，只能用于顺序容器    cout<<"============字符串和正则法则==========="<<endl;      string strtemp="luanpengluanpeng";    string str11(strtemp,2,3);                                                          //构造函数，原字符串，起始位置，截取长度。从后向前依次可以省略。string str2(num,c);生成num个c字符的字符串    string str= "luanpengluanpeng";    str.swap(strtemp);  //交换字符串的值，    //append和push_back在尾部添加字符串，    //insert在指定位置插入字符串，    //erase(在指定位置删除长度字符串，    //replace替换字符串，size和length返回长度，    //substr子字符串，    //find，返回的string::size_type 类型的值，string::npos表示字符串末尾后，查询结束位置    regex myregex("ua[l-q]");                                                           //正则表达式模式   //正则表达式   ^$\.*+?()[]{}|为特殊字符    regex_match(str,myregex);                                                           //验证源字符串是否存在指定模式的子字符串    smatch mysmatch;                                                                    //结果集  字符串数组    if(regex_search(str,mysmatch,myregex))                                              //查找符合规则的字符串,默认只查询第一个符合条件的   返回存在或不存在bool    {        for (auto x=mysmatch.begin();x!=mysmatch.end();x++)             cout<<x->str()<<endl;    }                                                   //$1表示匹配出的字符串第一段模糊区间  $&表示匹配出来的所有字符串  $表示匹配出来段前的字符串   $`表示匹配出来的断后的字符串    const string format("name=$1");                                                        //替换格式  替换成name=匹配出来的模糊字符串      string result=regex_replace(str,myregex,format);                                    //字符串替换    cout<<result<<endl;    thread t1(printstring,"这是一个新线程");                                           //创建多线程  可以有多个参数    //t1.join;                                                                          //顺序执行线程    t1.detach();                                                                        //创建线程分支    //如果使用较为频繁的对象构造，可以使用对象池   一次构造函数，每次去读取即可    //内存常见错误    //内存泄漏，释放操作不匹配，多次释放，释放未分配的，释放堆栈内存    //访问无效内存，访问已释放内存，内存越界，指针未初始化    system("pause");}//自定义字面量可以让用户定义符号所引起的变化   以_开头   定义//标准中 i  il   if被字面量为创建复数complex<double>  complex<long double>   complex<float>//float operator"" _min(float minute)//{//  return minute/60;//}//float operator"" _s(float second)//{//  return second/60/60;//}//只在c++11编译器以后//通过重载边界条件//double sum2(){//  return 0;//}////变长模板//template<typename T1,typename...T2> double sum2(T1 p,T2...args)//{//  double ret = p+sum2(args);//  return ret;//}