注释：行注释
块注释：
（1）#if 0
#endif
（2）/* */
<>:表示系统文件
<stdlib.h>+syetem 调用windows中的程序
QT中
ctlr+I 自动对齐
ctlr+/ 自动注释
VS 2013中
system需要调用#include windows.h使用
防止命令框闪关：system("pause");
math.h 中 pow(x,y) x的y次方
字节概念：
位（0，1）简称bit --8个位>字节 简称BYTE --2个字节> 字 简称WORD --2个字> 双字 简称DWORD
sizeof()：配合%lu输出，表示在内存当中所占位置大小
#define MAX 100 宏常量
const int max=0; 常量定义 max的值不能被改变
volatile 程序不会被优化
redisdter 放在寄存器中，建议指令
常量中除了字符串常量有内存地址外，其余的都没有地址
int类型占4个字节
char类型中：
" "退格一个一个末尾字符
" " 横向制表符，一个 Tab 位
输出特殊字符需要加转义字符：
char 'a’常量,内存只存一个字符 a
char a 字符变量
' ' 表示ASCII码值为0的字符
0 表示数字 0
'0'字符0标的ASCII码制为48
"0"由0字符+字符串结尾的默认值
输出类型：
putchar 输出一个字符
printf 输出一个字符串 %s 输出是一个字符串
%p输出打印地址
%和d之间加个数字，决定它输出字节数 “-” 左对齐
%c输出单个字符
%.和f之间加数字，决定输出几个小数
%p:输出某个数的地址
%d:按十进制输出：
%o:按八进制输出
%x:按十六进制输出
%u;按无符号位输出
%数字1.数字2f(lf),数字1输出字节数 数字2输出小数点数
scanf_s 输入
需要写入地址：&
输入字符时时：注意字符会被回车键接受（一般用getchar接受）
b=a++ 先做表达式值，在自加
b=++a 先自加，在做表达式
getchar() 与printf("%d",a);等待输入一个字符，然后输出他的ASCII码值
输入一个字符串：gets(a) a必须为一个字符串数组，用puts输出
变量的定义：
形式：数据类型 变量名：
变量的初始化：数据类型 变量名=初始值；
整数与整数相除一定是个整数。
输入输出文件需要包含头文件 stdio.h
输出的值一定初始化
例：i=2；j=i*i++ 得出来的值j为6；
if中:无大括号的情况下，默认带下面一个语句
switch()
{
case 常量表达式1：
语句1；
case 常量表达式2：
语句1
case 常量表达式3：
语句1
}
语句后要加break;执行符合值的语句后退出
最后加default:执行没有符合条件的default后的语句：
for（赋值语句1；判断语句2（不可缺少）；表达式语句3）//没有语句2时，默认为1，进入死循环
语句1：初始运行一次->对语句2进行判断（为真进入循环体，执行语句3；为假跳出循环体）
while(表达式)//没有表达式时，直接编译不通过
负数在计算中放的是补码
原码、反码、补码：
正数的补码为源码，
负数的补码到源码：符号位不变，按位取反，再加1；
数组的定义：
类型 数组名[常量] 定义的常量个数 下角标总数为常量-1；存储地址相邻
定义方法：未对数组进行复制，电脑随机分配数
只定义一部分，数组后面只默认为零
数组名[常量]={值} 数组统一赋值
数组名[]={值,值二.......} 常量由值数决定
"asdsad"后面自带
注意：初始值中间用 , 分开
求数组大小 运用sizeof(a)/sizeof(a[0])
随机数函数：
rand（） 产生随机数不变
srand(常量) 常量不变，产生的随机数不变 注意：不产生数，只是一个种子，将种子
给rand产生随机数
运用rand 和% 确定随机数范围
例：
结合时间使用：
srand(int(x=time(NULL)))；
rand（）;
例 产生27到127的随机数 rand%101+27
gets()输入一个字符串放进数组，认为回车代表输入完成，空格只是字符串中的一部分而已
fgets(开始存的起始地址，输入的个数，stdin) stdin表示输入
多文件编译：
#ifndef 常量名
#define 常量名
#endif 常量名
指针
* 解引用 单目运算符
形式 *指针变量 把指针变量指向的内存空间的数据取出来
*是简介索引，是把指针变量保存的数当成地址，去地址里面取数据，能取几个字节，取决于指针变量的修饰符
*p *p表指针指向变量的值，p代表指向变量的地址//定义一个指针变量，而指针变量p只储存地址
*p 只能接受地址，不能直接负常量
*p 输出指针的到的值
p 输出为地址 （p-p1）得出俩个的距离值
*p 如果没有进行取值赋值，不能直接赋值。例：int *p ,i=1 *p=2 定义直接报错 经过取址后：p=&a; *p=2 输出后 i连同*p的值一起改变为2
指针只有接受过非指针地址后，才能接受赋值（或定义的时候间接赋值：int a=0;int *p=&a）
用相同数据类型的指针，不要混用。必须使用相同类型的指针
统一系统下，不管指向什么样类型的变量，地址大小总是一样的
void *p 无类型的指针
int *p p=NULL; 空指针，没有明确的指向某块变量。NULL在c语言里面是一个宏，值为零
针对数组，关于指针变量的取指能力
常量指针
int a
const int *p=a//p是一个变量，可指向一个变量或者常量
p可以指向一个int类型的地址，不可以通过*p改变内存值。但可以指向其他地址
例：指针常量
int const *p2;//const在*之前，用以修饰地址类型，表示不能通过*p去修改
const在*之后，用以修饰指针变量
int *const p2=&a//p是一个常量，不可以指向其他数据空间地址，p2指向固定的变量地址，可以通过*p2读写这个变量的值
const int *const p//既不可以改变指向的地址，也不能通过*p改变值
指针指向数组时
int a[100]
p=a;
p=p+4等价p[0+4]
指针计算，改变的是地址
p:指针变量的的地址
*p：指向的地址的值
&p：取指针变量p在内存中的地址
char *str="hello itcast"//字符串常量，不能修改
c语言中所有数据类型都可以理解成一个char类型的数组
二级指针赋值：必须先取一级指针地址
字符串
字符串指针数组中，只要获得首地址，即可打印出字符串
例 char *str="hello itcast";printf("%s",str)
main(char argc,char **args) main函数参数 输入的数字的地址自动填充给args[i]
字符串查找：例：strstr(str1,str2)//str1和str2为字符串。
字符串的分割：运用指针接受后，可进行多次分割：例char *strl strl=strtok(数组首地址,"分割符号")，后循环判断while（strl）strl=strtok(NULL,"分割标志")
清空函数：例memset(a,0,8)，数组名，被覆盖后显示的值，覆盖内存大小（字节）
覆盖函数：memcpy(a,b,字节数)，将b中多少个字节数拷贝到a中
auto（自动变量）：一般情况下函数内部定义的变量都是动态auto类型的便量。只在自己作用域有效
static（静态变量）:只初始化一次，与大括号的出现无关。程序开始时被创建，程序结束生命周期结束。.注意：不能在其他文件试用。有同名时，优先使用本区域的作用域的值。
变量冲突的概念：变量名相同，作用域也相同，就会冲突
在代码块外定义的变量，即默认为全局变量或者叫文件变量
extern :声明文件至之外的东西
内存分区的意义：
代码区：存放代码，只能执行--------只读区
静态区：全局变量和静态变量全在其中。只在程序消失的时候才会释放。静态函数只影响他所作用的区域，其他文件不可见，它在代码区 （常量区：const类型的常量、字符串常量----------只读区；全局区：；静态区：；）
栈区：自动变量，函数的形参，函数的返回值。一种先进后出的
堆区：需要手动分配(malloc())和释放(free())。malloc(常量值)// 在堆中分配常量值个字节空间，返回的是一个void *类型。需要手动释放free()：1.一定要释放，不然会造成内存泄漏2.一定不能多次释放，释放前要接受首地址。（1）数组大小不确定或者很大的时候，使用堆-（2）malloc分配的值是随机、不确定的--------例：char *s=malloc(10);strcpy(s,”abcd”);printf(“%s”,s); free(s)
malloc的参数是指定分配的大小，单位：字节。要用memset清空
calloc的第一个参数是指定单位的数量，第二个参数是指定一个单位的大小，内存自动清空
rellaoc（扩大的名字，扩大后 的大小）。用realloc增加的空间也不会自动清零
概念：函数不能直接返回auto类型的地址
结构体的定义和初始化：
struct 结构体类型名
{ 结构体成员的数据类型 结构体成员的名};
例： struct student st;//定义一个student类型的结构体变量，名字叫 std。
结构体变量的初始化：(1) struct 结构体类型名 结构体变量名=｛初值｝，按照成员顺序赋值
（2）struct 结构体类型名 结构体变量名=｛结构体成员名｝；指定成员进行赋值。
结构体变量之间的赋值是可以用“=”,实际上就是内存拷贝。如果是结构体指针，也要开闭堆空间。如果结构体成员中有指针，注意需要指针先指向堆，让指针有明确的地址。结构体中的堆内存需要释放干劲（注意结构体成员中数组和指针对堆的释放，释放后把它定义为空）
结构体中：在变量的时候，使用 . 例 （*p）.结构体成员。在地址的时候，使用->，例 p->结构体成员名
typedef
typedef unsigned int size_t; 结构体成员间的赋值：字符串用strcpy，整型和字符可以直接用 =；
文件操作中，
文件的读取（用 r 模式打开）：
getc:要读取所有字符，文件内容以“EOF”结尾 例：利用while（c!=EOF）循环c=getc(p) 一个个接收，之后输出c;
fgets: 读取一行字符串，如何到文件以结尾停止：（1）用feof函数，例if(feof(p)) break;//到结尾跳出循环。例：fgets(buf,sizeof(buf),p);(2)例：while(fgets(buf,sizeof(buf),p)!=NULL),如果函数值返回为NULL，及到达文件末尾，跳出循环。
fscanf:按格式读取文件中的数据到某个变量中去。例：fscanf(p,”%s%d”,s,&a)，返回值为匹配的项数
文件的输入（用 w 模式打开）：
putc 写入一个字符或者一个整型;例：putc(1,2); 1:需要写入的字符，2：被写入文件的指针
fputs 写入一个字符串;例：fputs(1,2) 1:需要写入的字符串，2：被写入文件的指针(字符串的输入接受用fgets(buf,sizeof(buf),stdin))
fprintf:将数据中变量，输出到文件中。例：fprintf(p,”%s%d”,a,b);
文件拷贝的实现：
先读出文件中数据，c=getc(p);然后写入另一个文件，putc(c,p1);循环读取，因为文件最后以EOF结尾
C++:
C++分配堆，直接用关键词 new,释放用delete关键词（数组释放[]p）
函数重载的规则：函数名同名，但是参数类型、个数不同
pthread(线程程序)在Linux系统下编译。gcc main.c –o app –std=c99(如果在编译过程中出现c99)
pow函数的使用方法?
这俩条指令在那里使用： 删除文件remove(filename)
改名文件rename(oldname,newname)
static的作用：延长了局部变量的生命周期；限定了访问作用域；避免命名控件污染；
缓冲区分类：
行缓冲（针对终端）：’ ’;fflush;缓冲区满；结束程序；遇到输入时
全缓冲(针对磁盘文件)：fflush;缓冲区满;正常结束程序
无缓冲（stderr）
终端输出：stdout stderr(无缓冲)
数据类型的理解：int a=10; a代表的是一个内存空间的标识符号而已。
typedef的用法：1、typedef struct person(类型) p(别名)；2、typedef struct person{ }别名；3、typedef char *pointer; pointer p1,p2;得出p1和p2为指针类型。定义出来的为 *p1,*p2; 目的，增加程序的可移植性。
指针只是保存了数据的首地址，必须根据指针类型，才能知道取多少字节
void *指针主要用于数据的封装
sizeof()函数返回值为无符号整型。
sizeof碰到数组参数时：1、数组名出现在表达式(在形参)中，那么数组名就表示指向数组首元素的指针；2、在对数组名&arr取地址，或者使用sizeof(数组名)之外，数组名就是首元素指针
const:全局的时，放在常量区，数据被初始化后，不能修改。为局部时，放在栈区，数据被初始化后，可以通过间接，指针方式修改（day01-源码-全局静态区）
void:1、无类型，表示编译都不知道要分配多少内存；2、主要用在函数的参数和函数的返回值中；3、不能去定义变量
字符串中：同一字符串中，右边字符的地址高于左边字符地址
sscanf: 1、%*s或%*d 跳过数据 2、%[width]s 读指定宽度的数据3、%[a - z] 匹配a到z中任意字符(尽可能多的匹配)，没匹配的到就跳出4、% [aBc] 匹配a、B、c中一员，贪婪性，没有匹配到其中数据，函数结束5、%[^a] 匹配非a的任意字符，贪婪性 匹配到a,函数就结束 6、%[^a - z] 表示读取除a - z以外的所有字符，匹配到其中数据，结束函数 不符合要求，就跳出函数，在sscanf ”参数” 在其参数中输入摸个字符。也不会写入数据中
const int *p:常量指针，指向的的值不能改变，不能通过*p去修改它指向的值
int const *p:指针常量，指向的地址不能改变，不能去修改p指向的地址，可以通过*p去修改他指向的值
一级指针传地址给二级指针，注意数组指针的运用。
<<:左移位运算符，a<<b,表是a乘以2的b次方
>>:右移运算符，a>>b,表是a除以2的b次方
VS中，打开文件路径表示用 \ ;
运用^进行值交换：a = a ^ b; b = a ^ b; a = a ^ b;
三目运算符：表达式?参数1：参数2；表达式为真，返回参数1；表达式为假，返回参数2
链表数据的插入，在数据后插入，和前面链表数据比较。在数据前插入，和后面链表数据比较
C++语法
作用域运算符 ：：访问全局变量，否则就近原则
命名空间的使用，头文件声明空间，另外文件实现头文件的时候，需要带上空间名+函数，主函数调用也需要带上空间名+函数（命名空间的使用.cpp）
结构体中可以定义函数，定义：struct+结构体名字｛｝； 变量定义：结构体名字 变量名字
三目运算符，返回的是一个左值，例：a=10,b=20(a > b ? a : b) = 100。返回的变量将会被改变为100；结果返回b，然后对b进行重新赋值
引用：& 被引用变量必须先初始化，引用与被引用类型必须相同
理解成内存块进行重命名，理解成操作内存
函数返回引用，可以作为左值，值可以用引用接，变量接
命名空间：数据类型优先于命名空间，命名空间优先与类。C++中所有数据都是基于命名空间上操作。
命名空降使用规则：1：命名空间必须在全局范围内写
2：命名空间可以嵌套命名空间
3：命名空间是开放的，即可以随时把新的成员加入已有的命名空间中
4：匿名命名空间的使用等价于 = static int count = 0;
类：
类的概念：为一种自定义数据类型
编译器自动对类有默认的三个函数：构造函数、拷贝函数、析构函数
对类中的析构函数和构造函数：
class 类名
｛
类名（）｛代码语句｝；//定义一个类变量后，系统会自动调用构造一次构造函数。执行顺序：分配内存->调用构造函数。注意：可以重载，可以有参
类名（const 类名 &变量）
~类名（）｛代码语句｝；//定义一个类变量后，系统会自动调用构造一次构造函数。
执行顺序：销毁对象前，调用析构函数。注意：调用几次构造函数，就会调用几次析构函数
｝
类中的构造规则：先成员构造，在类本身构造，析构与构造循序相反。在继承中：先父后子
动态成员的创建：运用new（分配某种数据类型内存）和delete;(见C++中的基本语法->类的基本概念)
类中的静态成员：（为所有对象共有，所以没有this指针）
静态成员函数：静态成员函数只能访问静态成员变量
由于静态成员函数，没有this指针，所以不能访问。
静态成员变量：静态成员变量 声明周期：整个程序 作用域:MyClass类
静态成员变量必须类内声明，类外定义
类的大小：由对象中的非静态的成员变量决定
mutable关键字，可以使数据不受const影响
类的三大特性：
封装：对函数和变量封装，控制访问权限
字符串类封装注意事项：
加号的重载，需要借助第三方临时类，
加等号的重载，需要借助另外一个指针，存放数据最开始指向的数据
数组类的定义：
运用一级指针存放地址
数组、字符串封装：
运用一级指针
函数重载（同一作用域下）：
一般在类中进行重载，主要是类中运算符的重载
概念：函数同名，但是必须满足以下其中几个要求：1、参数个数不同 2、参数类型不同
3、参数顺序不同（匹配从严到妥协）
友元函数声明：友元成员函数（注意类内声明，类外定义），友元类、全局友元函数
运算符的重载：成员函数中 成员类 operator运算符（类2）｛｝其中隐藏一个this指针，如果设计类的私有变量，可进行友元函数声明。
常用重载运算符格式：
类内重载：
=： 类名& operator=(const 类名 变量)
前置++： 类名& operator++(){数据++，return *this};
后置++： 类名 operator++(int) {借用第三个变量储存 this ,数据++，return 返回第三变量（未++ this）}
+= :类名& operator+=(const 类名 变量)
[]:类型& operator[](int index)
全局函数重载：(如果访问类内私有变量，进行友元声明)
>>:istream & operator>>(istream &in,类名 &变量)
<<:ostream & operator<<(ostream &in,类名 &变量)
继承：
继承父类的访问权限：继承权限越来约严格，继承父类属性。只是访问权限有限制，主要目的是继承父类中的方法
靠近静态变量最近的那个类的作用域
多态实现原理：父类为虚函数声明（例：virtual 类型 函数名()=0;），同时父类虚析构。具体由子类实现
父类和子类有同名成员函数时，定义子类对象时，优先调用子类成员函数，父类的成员函数被隐藏，需要借助作用域声明
友元：
关键字：friend
友元解决问题: 授权某个函数 某个类 某个成员函数可以访问类内部的私有成员
全局友元函数：类内声明，类外实现
友元类：进行友元类在类内声明声明
友元成员函数：进行友元类内声明，类外实现，同时被有的类，需要提前声明。
类似于继承
异常处理：
throw 抛出异常数据类型，需要进行严格类型匹配，运用catch接收异常数据，catch(数据类型)与throw抛出数据类型必须相同，否则调用catch(…) （见源码中）
标准的输入输出
cin
概念：流中的函数（针对的是缓存区到变量中；键盘->缓存区（黑窗口中数据）->变量中）
cin.get():按个读取缓存区中的数据，知道将所有数据读完，注意：缓存区中的数据会读入其中
cin.get(数据地址，读取个数)：按行读取，遇到’ ’,读取结束。注意：不会读取缓存区中的’ ’;
cin.getlin(数据地址，读取个数)：按行读取，遇到’ ’,读取结束。注意：会读取缓存区中的’ ’;单不会写入到数据地址中
cin.ignore(参数)：忽略某个位置上的数据。也可以理解成，结合cin.get()使用，也可以理解成，读取缓存区中小标为多少的数据
cin.peek():窃取缓存区中的某个数据，不破换缓存区中的数据结构
cin.putback(参数):将参数放入缓存区中。
cout
cout.put(字符).put(字符):字符单个输入，后面可以无限.put(参数)
cout.write(数据地址，参数值)：参数个数决定输出多少个数据
cout.width(参数值)：输出数据所占宽度，默认右对齐，只对当前最近的一个数据有效
cout.fill(字符)：字符的自动填充
cout.setf(ios::参数):参数包含：left和right
文件的读取
头文件：fstream
写文件：
打开方式：ofstream 类名(“文件目录”,ios::out) 以写的方式打开文件。成功 类名 为非空
例：ofstream os(“文件目录”,ios::out) 类名为一个指针
写文件的三种方式：类名<<数据地址 ； （将指针指向的数据，写入文件中）
类名.write（数组首地址，字节数）；
类名.put(参数)；
读取文件：
打开方式：ifstream类名(“文件目录”,ios::in) 主要知道读到什么时候结束
读取文件结束的俩种函数：(类名.get())!=EOF;
while(!类名.eof()) 未读到末位，返回值为空
例：while(!ifs.eof){char buf[128]={0}; ifs.getline(buf,1024);cout<<buf<<buf} 文件按行读取
类名.read(buf,参数) 文件按字节数读取 主要运用于对象中
STL
vector 容器：
格式： vector<数据类型> 变量名 运用其头文件<vector>和算法头文件<algorithm> 去操作其内部函数 运用 变量名.begin() 和变量名.end(),去遍历数据 其俩个返回值为指针 v.push_back(数据)，去初始化容器。 （见 myself_sound codeC++语法函数）
注：不定类型容器变量名：Var
int类型变量名：number
char类型变量 ch
ch*类型变量：ch*
string类型变量：str
不确定数据类型（包括类）：elem
|
|
string类型容器 |
vector类型容器 |
deque类型容器 |
||||
|
概念 |
主要针对字符串 （只对字符） |
内存连续（类似数组概念） |
内存连续（自留头空间和尾空间，双端队列） |
||||
|
构造方式 |
相同 |
1、 容器类型 Var 2、 容器类型 Var（n个数，elem数据类型） 注：n个elem拷 贝给Var 3、 容器类型 Var（Var 2） 注：拷贝构造 4、 容器类型 Var（Var 2.begin(),Var 2.end()） 将此区间的数据，拷贝给Var |
|||||
|
不同: string容器针对string类和字符,而另外容器可以针对任何数据类型 |
|||||||
|
重载方式 |
相同 |
1、 Var（容器变量名2.begin(),容器变量名2.end()） 将此区间的数据，拷贝给本身 2、=重载 Var = Var 1 |
|||||
|
不同 |
1、 Var.assign(char *或者string类型) 2、 Var.assign(ch*,number)将ch*前number个字符赋给Var 3、 Var.assign(number,ch)将number个ch赋给Var 4、 Var.assign(str,number1, number2)将str中的number1到number2中间的字符赋给Var
|
1、 Var.assign（number,elem） 将n个elem（数据）拷贝给Var; 2、 Var.swap(Var1) 数据交换 |
|||||
|
大小操作 |
相同 |
1、 Var.size();//返回容器中实际元素 2、 Var..empty();//判断容器是否为空 3、 Var. resize (num);//重新指定长度，变短丢弃原来的数据，变长默认值填充 4、 Var.resize(num, elem); //重新指定长度，变短丢弃原来的数据，变长默elem填充 注：string类型只能填充char类型 |
|||||
|
不同 |
Var.reserve(数值) 数据不进行初始化 |
||||||
|
插入和删除 |
相同 |
1、Var.insert(number,emle,); //在number位置插入数据 2、Var.insert(number, number1, ch);//在指定number位置插入number1个字符c 3、Var.erase(number, number1);//删除从number位置开始的number1个字符 |
1、 Var.push_back(elem) //将数据从尾插（reserve和resize区别） 2、 Var.pop_back();//删除容器最后一个数据 3、 Var.insert(const_iterator pos, number,ele);//迭代器指向位置pos插入number个元素ele. (为俩个参数是，即在指定位置插入第二个参数) 4、 Var.insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，(是否俩个都能) 5、 Var.erase(const_iterator pos);//删除迭代器指向的元素 6、 Var.erase(beg,end);//删除[beg,end)区间的数据，返回Var的类型。
|
||||
|
不同 |
Var.push_front() |
1Var.push_front(elem);//在容器头部插入一个数据 Var.pop_front();//删除容器第一个数据 |
|||||
set容器中的迭代器：删除操作之后的数据，迭代器依旧有效
容器中常用API总结
数据类型：T 变量：Var
|
概 念 |
string容器 |
vector容器 |
deque容器 |
list 容器 |
set/multiset 容器 |
map/multimap 容器 |
stack 容器 |
queue容器 |
|||||||||||||||
|
迭代器 |
有 |
有 |
有 |
有 |
有 |
有 |
无 |
无 |
|||||||||||||||
|
随机访问 |
支持 |
支持 |
支持 |
不支持 |
不支持 |
不支持 |
不支持 |
不支持 |
|||||||||||||||
|
构 造 方 法 |
默认构造函数 |
类型 < T > Var 注：Var可以为char *和string |
map/multimap < T ，T1> m |
类型 < T > Var |
|||||||||||||||||||
|
拷贝构造 |
类型 < T > Var（Var1） 注：Var可以为char *和string |
map/multimap < T ，T1> m（m 1） |
类型 < T > Var（Var1） |
||||||||||||||||||||
|
区间拷贝构造 |
无 |
数据类型 Var 1（Var 2.begin(),Var 2.end()）Var2区间的数据拷贝给Var 1 |
无 |
无 |
无 |
无 |
|||||||||||||||||
|
重复构造（某种数据类型重复构造） |
类型 Var（n,elem） 将n个数据拷贝给给类名 注：string中，数据只能是char类型 |
||||||||||||||||||||||
|
赋 值 方 法 （ 改 变 原 有 数据 ） |
= 重载操作 |
Var=Var |
|||||||||||||||||||||
|
区间赋值法 |
Var.assign(Var2.begin(),Var2.end) . Var2区间的数据拷贝给Var 1 |
||||||||||||||||||||||
|
同一数据重复赋值 |
Var（n,elem） 将n个数据拷贝给给类名 注：string中，数据只能是char类型 |
||||||||||||||||||||||
|
asssign指定赋值（只针对string容器） |
Var.assign (Var1,num,num2) 将Var1从num开始num2个字符赋值给字符串(Var需要为string类型，一个参数时直接将Var1赋值给 Var) Var.assign(Var2) 注：Var2为char*类型，将Var2赋值给Var Var.assign(Var2,n)注：Var2为char*类型，将Var2前n个字符赋值给Var |
||||||||||||||||||||||
|
swap（）交换赋值 |
Var.swap(Var1),将Var1的值交换给Var |
||||||||||||||||||||||
|
概 念 |
string容器 |
vector容器 |
deque容器 |
list 容器 |
set/multiset 容器 |
map/multimap 容器 |
stack 容器 |
queue容器 |
|||||||||||||||
|
迭代器 |
有 |
有 |
有 |
有 |
有 |
有 |
无 |
无 |
|||||||||||||||
|
随机访问 |
支持 |
支持 |
支持 |
不支持 |
不支持 |
不支持 |
不支持 |
不支持 |
|||||||||||||||
|
数 据 查 找 方 法 |
Var[pos]:会出现越界问题 |
Var[pos]，返回容器pod位值的值，同时可以同Var[pos]=Var2,去修改数据类型,注：string类型数据时，Var2只能为char类型 |
|||||||||||||||||||||
|
Var.at(pos):不会出现越界问题 |
Var.at(pos)，返回容器pos位值的值，同时可以同Var[pos]=Var2,去修改数据类型,注：string类型数据时，Var2只能为char类型 |
||||||||||||||||||||||
|
运用find |
Var.find(Var1,ch) 返回在Var1中字符ch第一次出现的位置值（整型数据），结合[],at(),可以进行替换操作 Var.rfind(ch) 返回字符最后返回在Var1中一次出现的位置值（整型数据），注：Var数据类型可以为char,char*,string |
Var.find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回 变量.endl(); 注意map中是操作键值 |
|||||||||||||||||||||
|
查找返回迭代器 |
count(key);//查找键key的元素个数 lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。 upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。 equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。 注：为set和map容器所有函数，其他容器没有，定义迭代器接收 类型<容器接收数据类型>：：iterator it） |
||||||||||||||||||||||
|
Var.front();//返回第一个数据。 Var.back();//返回最后一个数据(queue容器相同) ; |
Var.top();//返回栈顶元素 |
||||||||||||||||||||||
|
string容器 |
vector容器 |
deque容器 |
list 容器 |
set/multiset 容器 |
map/multimap 容器 |
stack 容器 |
queue容器 |
||||||||||||||||
|
数 据 删 除 操 作 |
erase()容器共有，参不同作用不同 |
Var.erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素 Var.erase(pos);//删除迭代器指向的元素（pos为指向的第几个位置） 注：在map和setp中:删除容器中键值为pos(可以为任何类型)的对组。 Var.clear();//删除容器中所有元素 |
|||||||||||||||||||||
|
pop方法删除 |
Var.pop_back();//删除最后一个元素 。 |
Var.pop();//从栈顶移除第一个元素 |
Var.pop();//从队头移除第一个元素 |
||||||||||||||||||||
|
Var.pop_front();//删除容器第一个数据 |
|||||||||||||||||||||||
|
romove方法删除 |
remove(elem);//删除容器中所有与elem值匹配的元素（在map中指的是键值） 注：remove_if(elem)在set和map中elem表示为bool函数时，表示按条件删除 |
||||||||||||||||||||||
|
string容器 |
vector容器 |
deque容器 |
list 容器 |
set/multiset 容器 |
map/multimap 容器 |
stack 容器 |
queue 容器 |
||||||||||||||||
|
数 据 的 插 入 |
push方法 |
pushu_back()尾部插入 |
push(elem);//注：stacks是栈顶添加元素 queue是往队尾添加元素 |
||||||||||||||||||||
|
push_front(elem);//在容器开头插入一个元素 |
|||||||||||||||||||||||
|
insert方 法 插 入 |
Var.insert (pos, n,emlem);//在pos位置插入n个元素 |
||||||||||||||||||||||
|
Var.insert(pos,s); //指定位置插入字符串（s可以为string和char*类型） |
insert(pos,elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置。 |
Var.insert(elem);//在容器中插入元素。 |
1.通过pair的方式插入对象 Var.insert(pair<int, string>(3, "小张")); 2.通过pair的方式插入对象 Var.inset(make_pair(-1, "校长")); 3.通过value_type的方式插入对象 Var.insert(map<int, string>::value_type(1, "小李")); 4.通过数组的方式插入值 Var [3] = "小刘"; (此方式如果插入相同的键值，实值发生改变第二次插入的值，其他不会) |
||||||||||||||||||||
|
Var.insert(pos,beg,end);//在pos位置插入[beg,end]区间的数据 |
|||||||||||||||||||||||
|
string容器 |
vector容器 |
deque容器 |
list 容器 |
set/multiset 容器 |
map/multimap 容器 |
stack 容器 |
queue 容器 |
||||||||||||||||
|
单口容器， 随机迭代器 |
双口容器 |
容器插入的数据会自动派好序，set不可以插入重复数据。默认升序。加前缀（multi）可以插入重复数据，改变排序方式在构造的时候，载入一个队形，对象内部有bool函数，例：struct MyComapre{bool operator ()(int v1, int v2){return v1 > v2;}}; map容器的方式是通过键值（第一个参数） |
|||||||||||||||||||||
常用算法
参数Var:容器变量名
参数B：Var.beign()
参数 E:Var.endl()
参数：Data某种类型数据
迭代器D：与容器所存数据类型相同 例：vector<int>::iterator it
|
函数名及作用 |
要求 |
返回值 |
参数 |
范例 |
|
|
for_each 遍历算法， |
有迭代器 |
无（当第三个函数为结构提函数，返回容器中对象类型值） |
(B,E,函数对像) 注：或者直接用Ladma表达式 |
struct Print {void operator()(int v1){cout << v1 << "___";}}; for_each(v1.begin(), v1.end(),[](int val)->void{cout<<val<< " "; });//ladam表达式 |
|
|
transform 容器数据搬运 （被放入数据的容器需要自行开辟空间） |
有迭代器 |
无 |
(B,E,函数对像) 注：或者直接用Ladma表达式 或为5个参数 |
transform(v.begin(), v.end(), v1.begin(), [](int val)->int{return val+10; }); transform(vc1.begin(), vc1.end(), vc2.begin(), vc.begin(), Trans_add()); //对象重载需要俩个参数 第二个容器小于第一个容器，第三个容器大小等于第一个容器大小 |
|
|
查找算法 |
find |
有迭代器 |
返回迭代器it,数据没有找到，则it == v.end()) |
(B,E, Data)：注：或者用bool类型的函数，满足某种条件第一个数据。如果是类，第三参数对象重载 |
vector<int>::iterator it = find(v.begin(), v.end(), 20); bool MyPrint03(int val) {return val > 30;} it = find_if(v.begin(), v.end(), MyPrint03); struct MyCompare :public binary_function<Person, Person, bool> {bool operator()(Person p1, Person p2)const {return p1.mName == p2.mName&&p2.mAge == p2.mAge;}}; vector<Person>::iterator it= find_if(v.begin(),v.end(),bind2nd(MyCompare(),Person("dddd",40))); |
|
find |
|||||
|
adgacent_find删除重复且相邻的数据 |
有迭代器 |
返回迭代器it,数据没有找到，则it == v.end()) |
(B,E) 注：如果为类的时候，使用bool函数在类内重载==，用俩个参数，类外重载，运用三个参数 |
vector<int>::iterator it = adjacent_find(v.begin(), v.end()); bool comareStudent(Student &s1, Student &s2) { return s1.mName == s2.mName&&s1.mAge == s2.mAge; } vector<Student>::iterator it = adjacent_find(v.begin(), v.end(),comareStudent); |
|
|
binary_search 二分查找法 |
数据有序，默认升序 |
bool值 |
(B,E, Data);过数据是降序，需写入第四个参数greater<Student>() |
||
|
count count_if 统计满足条件的数据 |
迭代器 |
int类型 |
(B,E, Data);统计等于Data的个数。 如果为_if中第三数据为bool函数 |
||
|
accumulate 容器中数据相加，放入第三个容器 |
无 |
int类型 |
(B,E, 0) 注：面对类的时候，第三个参数为对象重载 |
int ret = accumulate(v.begin(), v.end(), 0); struct MyPuls {int operator()(int val, Person &p){return val + p.mAge;}}; ret = accumulate(v.begin(), v.end(), 0, MyPuls()); |
|
|
fill向容器中添加元素 |
无 |
fill(v.begin(), v.end(), 100); |
|||
|
copy拷贝算法 |
无 |
copy(v1.begin(), v1.end(),v2.begin()); |
|||
|
替换算法 |
replace |
有序 |
无 |
(B, D, 20, 100); |
replace(v1.begin(), v1.end(), 20, 100); replace_if(v1.begin(), v1.end(), mycompare, 200); |
|
replace_if |
有序 |
无 |
(B, D, bool, 100);为bool函数 |
||
|
容器交换算法 |
swap(v1, v2); |
||||
|
set_intersection交集 |
需要开辟第三个容器，第三个容器大小要初始化 |
返回迭代器，输出的时候返回的迭代器作为输出结束的条件 |
（(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin())） |
vector<int>::iterator myend = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin()); |
|
|
set_union 并集 |
vector<int>::iterator myend = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin()); |
||||
|
set_difference 差集 （返回的为前面这个容器的差集） |
vector<int>::iterator myend = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin()); |
||||
|
merge （有序数据的合并） |
有序 |
无 |
5个，第六个参数进行升序降序判断 |
merge(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin(),greater<int>()); |
|
|
random_shuffle （容器数据随机排序算法） |
2个 |
random_shuffle(v1.begin(), v1.end()); |
|||
| w_x_me | |||||