一个demo学会c++编程


这篇文章包含了c++的基本知识,起始并不适合0基础程序员。如果你只是对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
#endif
using 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;
//}
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页
实付 29.90元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值