1. 符号.和->的区别

A.B，则A为对象或者结构体，点号（.）左边必须为对象实体

A->B，则A为指针，->为成员提取，A->B为提取A中的成员B，A只能指向类，结构体，箭头（->）左边必须为指针

2.const

const对象声明必须进行初始化，且不可被修改

默认情况下，const对象仅在文件内有效

多文件下

//file1.cpp,定义并初始化一个常量，能被其他文件访问
extern const int a=1;
//file1.h，与a是同一个常量
ertern const int a;

对常量的引用可能引用一个非const对象

int i=1;
int &r1=i;
const int &r2=i;//对常量的引用，不能通过r2修改i
r1=0;//编译通过，可以通过r1修改i
r2=0;//编译错误

指向常量的指针

const int p=3;
int *ptr=&p;//编译错误，指针类型必须与所指对象类型一致，const int！=int
const *ptr=&p;//编译通过

常量指针，将指针本身定为常量

int r=0;
int *const c=&r;
//c将一直指向r

顶层const

指针常量：代表指针本身是常量，声明时必须初始化，之后它存储的地址值就不能再改变。声明时const必须放在指针符号后面，即：const 。声明常量指针就是顶层const，

底层const

指向常量的指针：代表 不能改变其指向内容的指针。声明时const可以放在类型名前后都可，拿int类型来说，声明时：const int和int const 是等价的。声明指向常量的指针也就是 底层const

一个指针本身添加const限定符就是顶层const，而指针所指的对象添加const限定符就是底层const

3.constexpr 常量表达式

常量表达式 值不会改变且自编译过程就会得到结果的表达式

const int s=10;
const int s2=s*10;//常量表达式
const int s3=get_size();//非常量表达式，他的变量类型为int

constexpr int s=10;
constexpr int s1=s+1;
constexpr int s2=get_size();//get_size()是一个constexpr函数时为常量表达式，在编译时将结果进行编译

尽管指针引用共可以定义为constexpr，但初始化的值必须为nullptr或0

constexpr定义的对象为顶层const

const int *p=nullptr;//指向整数常量的指针
constexpr int *p=nullptr;//一个指向整数的常量指针

4.类型别名

typedef wage double ;//double wage同义
typedef wage base,*p;//wage base同义。p，double*同义

C++11

using wage=double;

5.auto

auto(C++11)自动推导类型

int i=0,*p=&i;//编译通过，i:int,p:int *
auto i=0,p=3.0;//编译失败，i，p类型不一致 

5.decltype

decltype选择并返回操作数的数据类型

decltype(f()) sum=x;

sum的类型为函数的返回类型

如表表达式是一个变量则返回该变量类型

int i=0,*p=&i,&r=i;
decltype(i+1) b;//b为未初始化的int,正确
decltype(*p) c;//c是引用类型，必须初始化，错误
decltype((i)) d;//参数加了（），则为赋值语句左值的特殊表达式，为引用l

6.string

string可变长的字符串序列

string s1;
string s2=s1;
string s3="a";//拷贝初始化
string s4(5,'a');//"aaaaa"//直接初始化
string s5("aaaaa")//直接初始化

操作

os<<a;//写入输出流os，返回os
is>>a;//从is中读出字符串，字符串用空白分割，返回is
getline(cin,s);//从cin中读取一行给s，返回is
s.empty();//空返回true
s.size();//返回字符个数,返回类型：size_type，无符号类型的值，能存下所有的字符串长度
s[n];//返回第n个字符的引用
s1+s2;//返回拼接后的结果
<,<=,>,>= //判断字典序
s1==s2;//长度和字符全部相等成立
s1="hello";
s2=s1+"world"//正确，
s2="hello"+"world"//错误，+支持字符串相加（至少有一个），不支持两个字面量相加

cctype头文件中的函数（处理每个字符）

isalnum(c)//是数字/字母时为真
isalpha(c)//字母
iscntrl(c)//控制字符
isdigit(c)//数字
isgraph(c)//不是空格
islower(c)//小写字母
isprint(c)//可打印字符
ispunct(c)//标点
isspace(c)//空白
issupper(c)//大写字母
isxdigit(c)//16进制数字
tolower(c)//转小写
toupper(c)//转大写

遍历

for(auto i:s){
	//i为字符的拷贝，操作不影响原字符串
}
for(auto &i:s){
	//i为字符的引用，操作影响原字符串
}

字符串截取

//pos必选参数，开始位置
//n可选参数，取n个字符，没有表示截取到末尾
string substr(int pos=0,n) const;

7.右值引用

8.仿函数

仿函数(functor)，是通过重载()运算符模拟函数形为的类

1. 仿函数是一种类
2. 必须重载（）

template<typename T> struct comp
{
    bool operator()(T in1, T in2) const
    {
        return (in1>in2);
    }
};
//第一种方式
//先初始化一个对象，再调用该对象的方法
comp<int> cp;
cout << cp(6, 3) << endl;     //使用对象调用
//第二种方式
//仿函数，会产生一个临时的无名对象，并调用其方法
cout << comp<int>()(1, 2) << endl;       //使用仿函数实现

使用仿函数

class comp
{
    comp(int a)
    {
        sec = a;
    }
    int sec;
    bool operator()(int num)
    {
        return (num < sec);
    }
};
vector<int> v{1,2,3,4,5,6,7,8,9};
count_if(v_a.begin(), v_a.end(), comp<int>(5))

bool comp(int a,int b){
	return a<b;
}
vector<int> v{1,2,3,4,5,6,7,8,9};
//这里编译错误，只能传入方法，不能传参
count_if(v_a.begin(), v_a.end(), comp(5))