一个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; //不改变数据成员的函数声明为constvoid 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,或者constclass 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作为对象Studentcout<<"派生类设置名称参数:"+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、coursecout<<"基类无参构造函数:"+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作为对象Studentcout<<"基类设置名称参数:"+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";elsesexstr = "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,stodcout <<"算上班主任,班级人数:"<<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 按位异或为10100cout<<";其中男孩个数约"<<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,输入流tellgif (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的所有异常类都需要字符串设置构造函数}}elsecout<<"文件不存在"<<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;
//}
一个demo学会c++编程相关推荐
- 一个demo学会css
全栈工程师开发手册 (作者:栾鹏) 一个demo学会css css选择器全解 css操作语法全解 学习了css权威指南这本书,自己喜欢边学边总结边写demo,所以写了这篇文章,包含了大部分的css编程 ...
- 一个Demo学会用Android兼容包新控件
2019独角兽企业重金招聘Python工程师标准>>> 前言 伟大的Google为Android推出了一系列的兼容包,最新的就是Design Support Library了,这里我 ...
- 一个demo学会jquery mobile
全栈工程师开发手册 (作者:栾鹏) jQuery Mobile事件全解 jQuery Mobile 所有class选项 jQuery Mobile 所有data-*选项 一个demo学会jquery ...
- 一个demo学会c#
全栈工程师开发手册 (作者:栾鹏) c#教程全解 学习了c#4.5高级编程这本书,自己喜欢边学边总结边写demo,所以写了这篇文章,包含了大部分的c#编程知识.让你一个demo掌握c#编程,如果有问题 ...
- 一个demo学会java
全栈工程师开发手册 (作者:栾鹏) 快捷链接: java开发大全 这篇demo较长,包含了java基本的内容,若不是出于校验自己java基础能力的朋友,建议按照上面的链接分章节学习.本demo包含了j ...
- 一个demo学会js
全栈工程师开发手册 (作者:栾鹏) 快捷链接: js系列教程1-数组操作全解 js系列教程2-对象和属性全解 js系列教程3-字符串和正则全解 js系列教程4-函数与参数全解 js系列教程5-容器和算 ...
- 中国电子学会青少年编程能力等级测试图形化一级编程题:小狗进圈
「青少年编程竞赛交流群」已成立(适合6至18周岁的青少年),公众号后台回复[Scratch]或[Python],即可进入.如果加入了之前的社群不需要重复加入. 小狗进圈 小狗非常听话,收到命令能在舞台 ...
- 中国电子学会青少年编程能力等级测试图形化一级编程题:海底世界
「青少年编程竞赛交流群」已成立(适合6至18周岁的青少年),公众号后台回复[Scratch]或[Python],即可进入.如果加入了之前的社群不需要重复加入. 海底世界 1. 准备工作 (1)背景:U ...
- 中国电子学会青少年编程能力等级测试图形化一级编程题:无奈的Jaime
「青少年编程竞赛交流群」已成立(适合6至18周岁的青少年),公众号后台回复[Scratch]或[Python],即可进入.如果加入了之前的社群不需要重复加入. 我们将有关编程题目的教学视频已经发布到抖 ...
最新文章
- VS中添加lib文件,编译出错:LINK : fatal error LNK1104: 无法打开文件:×××.lib解决办法
- 使用Java connector消费ABAP系统的函数
- Android课程设计倒计时app,单片机课程设计-可调倒计时器.doc
- React + TypeScript 默认 Props 的处理
- Java父类强制转换子类原则
- DockerFile 入门到精通
- c++ 结构体中不同类型的初始值_Golang语言基础教程:结构体
- 【Mac】mac安装redis客户端 Error: Cask ‘rdm‘ is unavailable: No Cask with this name exist
- 《SQL高级应用和数据仓库基础(MySQL版)》学习笔记 ·005【表的CRUD操作(DML语句)】
- Android NFC识别CPU卡和m1卡
- 新版代挂网站PHP源码+去除授权/支持燃鹅代抽
- 攻略 | 一文教你学会使用GitHub!(附视频)
- 华为链路聚合(路由器和交换机)
- 算法——递归与递推[蓝桥杯]
- 全球及中国柔性AMOLED面板行业消费量调研及投资前景预测报告2022-2028年
- 再见了,MySQL之父!
- java全拼,Java获取汉字全拼和首拼
- python里面pop,remove和del 三者的用法区别
- nodejs调用webservice接口(https)
- 编译原理三大经典书籍(龙书 虎书 鲸书) 转
热门文章
- 微软语音识别技术屡破世界纪录的秘密都在这里了
- 目前效果最好、应用较广且比较成熟的语音识别模型是什么?
- 语音识别系统功能_语音识别系统的应用
- C语言内存模型的栈帧,java内存模型(线程独占部分)
- java jtable 按钮_java web 怎么在jtable中添加按钮?
- 【王道操作系统笔记】系统调用
- 【Java笔记】四种权限修饰符总结
- Tiny Jpeg Decoder (JPEG解码程序) 源代码分析 1:解码文件头
- linux实现开机自启动脚本
- Apache No installed service named “Apache2.4“的解决办法