C++ 基础语法

1.基础语法

1.1 关键字

1.2 标识符命名规则

1.标识符不能是1.1中的关键字
2.标识符只能由字母、数字、下划线组成
3.第一个字符必须为字母或者下划线
4.标识符中字母区分大小写

1.3 占用字节数

windows操作系统，32位机中，
char： 1个字节
short： 2个字节
int： 4个字节
long： 4个字节
pointer指针：占4个字节
float: 4个字节，7位有效数字 (eg:3.14，有效数字3)
double:8个字节，15~16位有效数字

windows操作系统，64位机中，
char： 1个字节
short： 2个字节
int： 4个字节
long： 4个字节
pointer：8个字节
float: 4个字节，7位有效数字
double:8个字节，15~16位有效数字

注：字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元。

1.4 ASCII码对照表详解

https://baijiahao.baidu.com/s?id=1704767913015693638&wfr=spider&for=pc

1.5 转义字符

用于表示一些不能显示出来的ASCII字符

1.6 字符串型

1.C风格字符串 ： char 变量名[] = “字符串值”;
eg: char str1[] =“Hello world”;
2.C++风格字符串：string 变量名 = “字符串值”;

1.7 数组

1.7.1 一维数组定义方式

1.数据类型 数组名[数组长度]；int score[10];
2.数据类型 数组名[数组长度] = {值1，值2，值3，…}；eg:
3.数据类型 数组名[] = {值1，值2，值3，…}；

1.7.2 一维数组数组名用途

1.可以统计整个数组在内存中的长度
求数组的元素个数： sizeof(arr)/sizeof(arr[0));
2.可以通过数组名获取到数组首地址
cout<<“数组首地址为：”<<(int)arr <<endl;

1.7.3 二维数组得定义方式

1.int arr[2][3];
2.int arr[2][3]={{1,2,3},{3,4,2}};
3.int arr[2][3]={1,2,3,3,4,2};
4.int arr[ ][3]={1,2,3,3,4,2};

1.7.4 二维数组组名

1.8 指针

1.指针前加 * 代表解引用，找到指针指向的内存中的数据

1.9 空指针和野指针

1.9.1 空指针

1.空指针：指针变量指向内存中编号为0的空间,int *p=NULL。
2.用途：初始化指针变量
3.访问空指针会报错 cout<<*p<<endl；会报错
4.空指针指向的内存是不可以访问的,内存编号0~255为系统占用内存，不允许用户访问。

1.9.2 野指针

1.定义：指针变量指向非法的内存空间。eg： int *p=(int *)0x1100;
2.空指针和野指针都不是我们申请的空间，因此不要访问。

1.10 const 修饰指针

1. const 修饰指针—常量指针 const int *p=&a; 指针的指向可以修改，但是指针指向的值不能修改。*p=20；错误 p=&b;正确
2. const 修饰常量–指针常量 int * const p2=&a;指针的指向不可以修改，但是指针指向的值可以修改。
   *p2=20;正确； p2=&b;错误
3. const即修饰指针，又修饰常量。指向和指向的内容均不可以修改

1.11 指针和数组

1.数组名就是数组的首地址；
int arr[3]={1,2,3}；int *p=arr; 不需要加“&”符号；
&arr ==arr ==p

1.12 结构体

语法：struct 结构体名{结构体成员列表};
结构体创建变量的方法
1.struct 结构体名 变量名 eg：struct Student stu; struct 关键字可以省略
2.struct 结构体名 变量名={成员值1，成员值2…};struct Student stu={“李四”,19,80}; struct 关键字可以省略
3.定义结构体时顺便创建变量；
struct Student
{
string name;
int age;
int score;
}stu1;

1.12.1 结构体数组

语法：struct 结构体名 数组名[元素个数]={{}，{}，…{}}; struct 可以省略
eg:struct Student arr[3]={{“学生1”,18,80},{“学生2”,19,82},{“学生3”,19,83}}

1.12.2 结构体指针

语法: Student stu={“张三”,20,89};*Student p=&stu; 注意，这里有&符号，数组没有这个

2 核心编程

2.1 程序的内存模型

2.1.1 内存分区

1.代码区：存放函数体的二进制代码，由操作系统进行管理。代码区是共享（代码在内存中只有一份）和只读的（防止程序被意外修改）。
2.全局区：存放全局变量，静态变量以及常量。
在程序编译后，生成了exe可执行程序，未执行该程序前分为代码区和全局区两个区域。

3.栈区：有编译器自动分配释放，存放函数的参数值，局部变量等
4.堆区：有程序员分配和释放，若程序员不释放，程序结束时有操作系统回收。

2.2 C++中的引用

2.3函数高级

2.3.1 函数重载

1.加const 或者不加const可以作为引用重载的条件；
即 void func(int& a){} 可以重载函数 void func(const int& a){} ，非引用(别名)时就不可以这样重载
2.函数重载遇到默认参数时，会出现二义性，调用时报错。
void func(int a,int b=10){} void func(int a){} 调用： func(10)；//会报错，尽量避免写这样的重载

2.4 类和对象

2.4.2 对象特性

1.struct和class的区别，默认权限不同，class 默认权限为私有，struct默认为公共的。
struct student{ string name;} class Student{ string name;}
2.构造函数分类及初始化；
分类：有参和无参构造函数；或者普通构造函数和拷贝构造函数
class Person
{
public:
Person() {} //无参构造 或者普通构造
Person(int age) {} //有参构造或者普通构造
Person(int a,int b,int c):m_a(a),m_b(b),m_c©{}
Person(const Person & per){} //拷贝构造
}
初始化方法有三种：
2.1 括号法
Person p1;正确
//Person p1();❌，会被编译器认为是一个函数声明，函数声明可以在方法内部；
Person p2(10);有参构造
Person p3(p2); //拷贝构造函数
2.2 显示法
Person p1;
Person p2=Person(10);
Person p3=Person(p2);
Person(10); 这是匿名对象，当前行结束之后，马上调用析构函数,系统会立即回收，其它局部变量会在方法调用完成后回收。
//Person(p3)；❌ 不能利用拷贝构造函数初始化匿名对象，编译器认为Person(p3)===Person p3; p3已经存在；
2.3 隐式转换法
Person p2=10;
Person p3=p2;
3.深拷贝和浅拷贝
3.1.浅拷贝 ：简单的赋值操作，如默认的拷贝构造函数
3.2 深拷贝：在堆区重新申请空间，进行拷贝操作；如果不进行深拷贝，会导致重复释放堆区的问题；
Person(const Person& p)
{ m_age=p.m_age; ptr_height=new int(*p.ptr_height);} //在堆区给指针创建新内存
4.对象特性
当其它类对象作为本类成员，先构造其它类对象，在构造自身，即先调用其它类构造函数 ，析构函数的调用顺序与构造函数的调用相反。先析构本身，在析构其它类对象。
5.静态成员变量和静态成员函数
5.1 静态成员变量：在编译阶段分配内存，在类内声明，类外初始化，所有对象共享同一份数据。
class Person
{
public:
static int m_A;//静态成员变量

	private:
            static int m_B;//静态成员变量也是有访问权限的

};
int Person::m_A=10;//在类内声明，类外初始化
int Person::m_B=20;//在类内声明，类外初始化，可以访问

int main()
{
//1.通过对象进行访问
Person p;
cout <<p.m_A<<endl;

   **//2.通过类名进行访问**
   cout<<Person::m_A<<endl;
   //cout<<Person::m_B<<endl;//❌  类外访问不到私有静态成员变量

}
5.2 静态成员函数 public : static void func();
a.所有对象共享同一个函数；
b.静态成员函数只能访问静态成员变量，不可以访问非静态成员变量；
c.静态成员函数可以通过对象进行访问；Person p; p.func();
也可以通过类名进行访问;Person::func();
d.类外访问不到私有静态成员函数；

2.4.3 继承

5 继承中的同名成员处理
1.通过子类对象访问到父类中的同名成员，需要加作用域。
Son s ;
s.m_A; //子类同名变量
s.Base::m_A;//父类同名变量
s.Base::func();
2.子类中的同名函数会隐藏掉所有父类的同名变量、同名函数、同名静态变量、同名静态成员函数，包括重载的同名都会被隐藏，只能通过作用域访问父类的同名变量、同名函数、同名静态变量、同名静态成员函数；

6 继承中的同名静态成员处理
1.通过对象访问
Son s;
s.staticFunc();//静态成员函数
s.Base::staticFunc();
2. 通过类名访问
Son::staticFunc();
Son::Base::staticFunc();
7.菱形继承问题： 利用虚继承可以解决菱形继承问题（两份相同数据）；
class Sheep：virtual publc Animal { }；
class Tuo:virtual publc Animal { }；
class YangTuo:public Sheep,public Tuo{ }；

2.4.4 多态

1.虚析构和纯虚析构：可以解决父类指针释放子类对象时不干净的问题；虚析构和纯虚析构都需要有具体的函数实现，父类的纯虚析构需要在类外实现。
Animal::~Animal(){ }

3.提高编程

3.1 STL的六大组件

STL大体分为六大组件，分别是：容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器
1.容器：各种数据结构，如vector、list、 deque、set、map等，用来存放数据。
2.算法：各种常用的算法，如sort、find、copy、for_each等
3.迭代器：扮演了容器与算法之间的胶合剂。
4.仿函数：行为类似函数，可作为算法的某种策略。
5.适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
6.空间配置器：负责空间的配置与管理。

3.5容器算法迭代器初识

3.常用容器

3.1 模板

3.1.1 类模板与继承

1.如果父类室类模板，子类需要指定出父类中T的数据类型

template<class T>
class Base
{
  public:
   T obj;
};
template<class T1,class T2>
class Son:public Base<T1>
{
   public:
   T2 obj;
}

3.1.2 类模板与友元

1.友元函数类内实现及类外实现

template<class T1, class T2>
class Person; 

template<class T1, class T2>
void PrintPerson2(Person<T1, T2>& p)
{
	cout << "name:" << p.m_Name << "  age:" << p.m_Age << endl;
}

template<class T1, class T2>
class Person
{
	 /// 全局函数,类内实现 
	friend void PrintPerson(Person<T1,T2> &p)
	{
		cout << "name:" << p.m_Name << "  age:" << p.m_Age << endl;
	} 
	// 全局函数类外实现 
	friend void PrintPerson2<>(Person<T1, T2>& p); 
public:
	Person(T1 name, T2 age);  
public:
	T1 m_Name;
	T2 m_Age;
};

3.2 vector 容器

3.2.1 vector基本概念

1.vector数据结构和数组非常相似，称为单端数组，不同之处在于数组是静态空间，而vector可以动态扩展；
2.动态扩展并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝到新空间，释放原空间；

3.2.8 vector对外接口

//构造函数
vector<T> v;
vector<v.begin(),v.end());
vector(n,elem);
vector(const vector &vec);
//vector 赋值操作
vector& operator=(const vector &vec);
assign(beg,end);//将[beg,end)区间中的数据拷贝赋值给本身
assign(n,elem);//将n个elem拷贝赋值给本身
//容量和大小
empty();
capacity();
size();
resize(int num);//默认值0填充
resize(int num,elem);//elem,填充默认值
//插入和删除
push_back(ele);
pop_back();
insert(const_iterator pos,ele);
insert(const_iterator pos,int cout,ele);
erase(const_iterator pos);
erase(const_iterator start,const_iterator end);
clear();
//数据存取
at(int index);
operator[];
front();
back();
swap(vec);  //vector<int>v;vector<int>(v).swap(v);//收缩内存
reserve(int len);//预留位置，不初始化，元素不可访问

1.减少vector在动态扩展容量时的扩展次数
2.reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问

3.3 deque 容器

3.3.1 deque容器基本概念

1.双端数组，可以对头端进行插入删除操作；


deque与vector区别：
a.vector 对于头部的插入删除效率低，数据量越大，效率越低；
b.deque相对而言，对头部的插入删除速度会比vector快；
c.vector访问元素时的速度会比deque快，这和两者内部实现有关；

3.3.2 deque对外接口

//构造函数
deque<T> deq;
deque(beg,end);
deque(n,elem);
deque(const deque& deq);
//赋值操作
deque& operator=(const deque &deq);
assign(beg,end);
assign(n,elem);
//大小操作
deque.empty();
deque.size();
deque.resize(num);
deque.resize(num,elem);
//插入和删除
push_back(elem);
push_front(elem);
pop_back();
pop_front();
insert(pos,elem);
insert(pos,n,elem);
insert(pos,beg,end);
clear();
erase(beg,end);
erase(pos);
//数据存取
at(int idx);
operator[];
front();
back();
//排序操作
sort(interator beg,iterator end);
//反转和排序
reverse();
sort();

3.5 stack 容器

3.5.1 stack 基本概念

3.5.1 stack 对外接口

3.6 queue 容器

3.6.1 queue 基本概念

注意：队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为。

3.6.1 queue对外接口

3.7 list容器

3.7.1 list基本概念

1.功能：将数据进行链式存储；
2.排序时使用自己的成员函数sort进行排序

list优点：
1.采用动态存储分配，不会造成内存浪费和溢出；
2.链表指向插入和删除操作十分方便，修改指针即可，不需要移动大量元素；
3.链表是非连续存储的；

list缺点：
1.链表灵活，但是空间（指针）和时间（遍历）额外消费较大；
2.STL中List和vector是两个最常被使用的容器；

3.7.1 list对外接口

//构造函数
list<T>lst;
list<T>lst(beg,end);
list<T>lst(n,elem);
list<T>lst(const list &lst);
//赋值和交换
assign(beg,end);
assign(n,elem);
list& operator=(const list &lst);
lst1.swap(lst2);
//大小操作
size();
empty();
resize(num);
resize(num,elem);
//插入和删除
push_back(elem);
pop_back();
push_front(elem);
pop_front();
insert(pos,elem);
insert(pos,n,elem);
insert(pos,beg,end);
clear();
erase(beg,end);
erase(pos);
remove(elem);
//数据的存取
front();
back();

所有不支持随机访问迭代器的容器，不可以用标准算法，如sort(lst.beg(),lst.end());❌ 内部会提供算法lst.sort();

3.8 set/multiset 容器

3.8.1 set基本概念

1.所有元素都会在插入时自动被排序；
2.set/multiset属于关联式容器，底层结果是用二叉树实现；
3.set和multiset区别：
a.set不允许容器中有重复的元素；
b.multiset允许容器中有重复的元素；
4.插入数据时，只有insert方法；

3.8.1 set对外 接口

set<T>st;
set（const set &st);
set& operator=(const set&st);
insert(elem);
clear();
erase(pos);
erase(beg,end);
erase(elem);

3.8.3 排序

class MyCompare
{
public:
bool operator()(int v1,int v2)
{
return v1>v2;
}
}
set<int,MyCompare>s2;//降序排序

3.8.4 对组

pair<type,type>p(value1,value2);
pair<type,type>p=make_pair(value1,value);

3.9 map/multimap 容器

3.9.1 map 基本概念

1.map中所有元素都是pair；
2.所有元素都会根据元素的键值自动排序；
3.map/multimap属于关联式容器，底层结果是用二叉树实现；
4.可以根据key值快速找到value值；
5.map和multimap的区别：
a.map不允许容器有重复key值元素；
b.multimap允许容器中有重复key值元素；
6.map中所有元素都是成对出现，插入数据时候要使用对组；

3.4 仿函数

3.4.1 谓词

1.返回bool类型的仿函数称为谓词，如果有一个参数，叫一元谓词，有2个参数，叫二元谓词

class MyAdd
{
public: 
	int operator()(int v1,int v2)
	{  return v1 + v2;  } 
};

3.5.2 内置仿函数

调用#include头文件

plus<int>p;
cout << p(10, 20) << endl;
//cout << plus<int>(10, 20) << endl;//× 
//运算仿函数
1.template<class T> T plus<T>
2.template<class T> T minus<T>
3.template<class T> T multiplies<T>
4.template<class T> T divides<T>
5.template<class T> T modulus<T> //取模
6.template<class T> T negate<T> //取反
//关系仿函数
1.template<class T> T equal_to<T>//等于
2.template<class T> T not_equal_to<T>//不等于
3.template<class T> T greater<T>//大于
4.template<class T> T greater_equal<T>//大于等于
5.template<class T> T less<T> //小于
6.template<class T> T less_equal<T> //小于等于
//逻辑仿函数
1.template<class T> bool logical_and<T>//等于
2.template<class T> bool logical_or<T>//不等于
3.template<class T> bool logical_not<T>//大于
eg:
vector<bool>v1;
v1.push_back(true);...
vector<bool>v2;
v2.resize(v1.size());//必须要先开辟空间，否则报错
transform(v1.begin(),v1.end(),v2.begin()，logical_not<bool>());

3.5 STL中常用算法

主要包括在头文件中
：是STL头文件中最大的一个，范围涉及到比较、交换、遍历操作、复制、修改等等；
:体积小，只包括几个在序列上面进行简单数学运算的模板函数；
：定义了一些模板类，用以声明函数对象。

3.5.1 常用遍历算法

1.for_each //遍历容器

void  print01(int val）
{ cout<<val<<" ";}
class Print
{  public:
      void operator()(int val)
      { cout<<val<<" ";}
}
vector<int> v;v.push_back（1）;）
for_each(v.begin(),v.end(),print01);
for_each(v.begin(),v.end(),Print());

2.transform //搬运容器到了另一个容器中

vector<bool>v1;
v1.push_back(true);...
vector<bool>v2;
v2.resize(v1.size());//必须要先开辟空间，否则报错
transform(v1.begin(),v1.end(),v2.begin()，logical_not<bool>());

3.5.2 常用查找算法

1. find //查找
   2.find_if
   3.adjacent_find //查找相邻重复元素，返回相邻元素的第一个位置的迭代器
   4.binary_search//查找指定元素是否存在，在无序序列中不可用
   5.count //统计元素出现的次数
   6.count_if //按条件统计元素个数

3.5.3 常用排序算法

1. sort //对容器内元素进行排序
   2 random_shuffle //洗牌 指定范围内的元素随机调整次序
   需要在方法中添加srand((unsigned int)time(NULL))；//随机函数 才能每次都不一样
   3 merge // 容器元素合并，并存储到另一容器中，两个容器必须是有序的，合并后依旧有序
   4 reverse //反转区间内元素

3.5.4 常用拷贝和替换算法

3.5.4.1 copy

1.容器内指定范围的元素拷贝到另一容器中
2.copy(iterator beg,iterator end,iterator dest);
3.注意事项：目标容器要提前开辟空间
vectorv2;
v2.resize(v1.size());

3.5.4.2 replace

1.将容器内指定范围的旧元素修改为新元素
2.语法：replace(iterator begin,iterator end,oldValue,newValue);
3.会替换掉区间内所有满足条件的元素

3.5.4.3 replace_if

1.容器内指定范围内满足条件的元素替换为新元素
2.语法：replace_if(iterator begin,iterator end,_pred,newValue);
-pred:谓词
3.总结：可以利用仿函数灵活筛选满足的条件

3.5.4.4 swap

1.互换两个容器的元素
2.要引用头文件#include
3.总结：交换的容器要同种类型

3.5.5 常用算术生成算法

3.5.5.1 accumulate

1.描述：计算区间内，容器元素累计总和
2.头文件：#include
3.语法：accumulate(iterator begin,iterator end,value)
value:起始累加值

3.5.5.2 fill

1.描述：向容器中填充指定的元素
2.语法：fill(iterator beg,iterator end,value) //----value,指定值
eg:
void test01()
{
vectorv;
v.resize(10); //默认填充值为0
fill(v.begin(),v.end(),100);//全部填充为100
}

3.5.6 常用集合算法

3.5.6.1 set_intersection

1.描述：求两个容器的交集
set_intersection(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);
//dest 目标容器开始迭代器
2.注意：两个集合必须是有序序列
3.目标容器需提前开辟空间，开辟空间需要为两容器容量较小者，min函数在 头文件中；
4.set_intersection函数返回值即是交集中最后一个元素的位置，遍历输出需要用此位置（dest容器可能空间大于结果）
5.函数包含在文件中

3.5.6.1 set_union

1.求两个集合的并集
set_union(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);
//dest 目标容器开始迭代器
2.注意：两个集合必须是有序序列
3.目标容器需提前开辟空间，开辟空间大小为两个容器的容量和；
4.set_union函数返回值即是交集中最后一个元素的位置，遍历输出需要用此位置

3.5.6.1 set_difference

1.求两个集合的差集
set_difference(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);
//dest 目标容器开始迭代器
2.注意：两个集合必须是有序序列
3.目标容器需提前开辟空间，开辟空间大小为两个容器的容量较大者，max函数在 头文件中；
4.set_union函数返回值即是交集中最后一个元素的位置，遍历输出需要用此位置

5.7其他

5.7.1 string转int

string str=“21”;
int count=atoi(str.c_str());

5.7.1 int转string

int i=20;
string str=to_string(i);