day 1.c++语法

字符数组初始化字符串会默认添加\0，要注意数组下标大小
例如 char a[]="123"，要开到4；
C数组 int a[]不能拷贝和赋值；如a2=a,int a2[]=a //错误
int *a[10] //a是指向10个int *
int (*a)[10] //指向10个int型的数组指针
int a[10]={1,2,3...};
a[2]=*(a+2)=3;
int *p=&a[2];
p[2]=*(p+2)=5;//a[4];
数组int a[]内置下标可以有负值，标准库类型sting,vector都是unsigned
内置数组初始化vector
int a[10]={0};
vector<int>ans(begin(a),end(a));
花括号初始化数组
int a[5]={0,1..};
int a[2][3]={{0,0,0},{0,0,0,}};也可以写成int a[2][3]={0,0,0,0...};
缓冲区溢出：越界索引访问容器内容
常量可以引用非常量，非常量不能转常量；
int i;
const int &j=i;
const int *p=&i
int &r=j//非法，不能从常转非常
只要不包括底层const都能用static_cast
int j;
double d=static_cast<double> (j);
const int*p1 = &a; //p1是底层const，通过p1不能改变p1指向的数据a。p1本身可变。
int const*p2 = &a; //同上，p2是底层const，通过p2不能改变p2指向的数据a。p2本身可变。
顶层const表示指针本身是一个常量
底层const表示指针指向的对象是一个常量

常量转非常量用const_cast 只能在同类型去const 不能转换类型
const int *a;
int *p=const_cast<int*>(a);
goto跳转到同一函数内的其他地方；

异常部分知识点
try
{
...
if(失败)
{
抛出异常让catch捕获；
}
}
catch(A)
{
捕获异常...
}
catch(B)
{
捕获异常...
}

函数
定义
int fac(int n)
{
return 0;
}
调用可以fac(3.14)会自动进行类型转换；

分离式编译 把函数声明放一个文件；定义放另一个文件


重载函数
函数名相同，形参列表不同的成为函数重载；
int fac(int p);
int fac(string p);
int fac(int a,int b);
注意main不能重载
应用于数据库
record lookup(const name&);
record lookup(const phone&);

int fac(int);
int fac(const int)是等价的，顶层const会被忽略；所以是声明两次；

int fac(int *);
int fac(int *const);顶层const 可以忽略；
但是
int fac(int *)
int fac(const int*)确是重载，两个新函数，因为后面是底层const

重载和作用域

在外面重载的函数，在里面作用域会被屏蔽；即调用时是调用内部的

int fac(double);

void test()
{

int fac(int);
fac(3.14);//会被调用成fac(3)，屏蔽外面的
简单总结就是，都有同名函数，会屏蔽外部的重载，没有才会调用外部重载；
}

内联函数 可以避免函数调用的开销；
如coutt<<strcmp(s1,s2)<<endl;
等价cout<<s1<s2?s1:s2<<endl;

constexpr函数的返回值和形参都得是字面常量

内联函数和constexpr函数可以多次定义，但是定义必须一致

调用重载函数时，如果有默认形参，那么实参可以不用考虑默认形参，可能会少于定义的形参数

重载函数匹配优先精确匹配，实在不行系统会强制转换，如果可以的话

返回指向函数的指针
using F=int(int *,int)//F是函数
using pf=int (*)(int*,int)//pf是指向函数的指针，形参要和函数一致

函数的返回值不能是函数

decltype
①当使用decltype(var)的形式时，decltype会直接返回变量的类型（包括顶层const和引用），不会返回变量作为表达式的类型。
如
const int ci=0;
decltype(ci) x=0;

decltype(expr)的结果根据expr的结果不同而不同：expr返回左值，得到该类型的左值引用；expr返回右值，得到该类型。

int i = 42, *p = &i, &r = i;

// r + 0是一个表达式
// 算术表达式返回右值
// b是一个int类型
decltype(r + 0) b;

// c是一个int &
decltype(*p) c = i;
因此，decltype(expr)的结果根据expr的结果不同而不同：expr返回左值，得到该类型的左值引用；expr返回右值，得到该类型。

我们可以使用decltype获得函数add_to的类型：
decltype(add_to) *pf=add_to//add_to类型的函数指针；

首先，我要告诉你static与extern是一对“水火不容”的家伙，也就是说extern和static不能同时修饰一个变量；其次，static修饰的全局变量声明与定义同时进行，也就是说当你在头文件中使用static声明了全局变量后，它也同时被定义了；最后，static修饰全局变量的作用域只能是本身的编译单元，也就是说它的“全局”只对本编译单元有效，其他编译单元则看不到它,如:


extern 是声明全局的变量的意思。

例如在一个工程中有两个cpp，一个是test.cpp一个是main.cpp 。

我们在test.cpp中定义了一个int num;但是我们在main.cpp中想要调用。这时候我们就需要使用到extern

在main.cpp中进行声明extern int num;这样我们就可以调用到test.cpp中的num。

注意：

在main.cpp中，我们只是进行了声明，而真正定义是在test.cpp中。那就意味着我们不能这样写：extern int num = 1;这样就变成了定义

 

类
在类中被const声明的成员函数只能访问const成员函数,而非const函数可以访问任意的成员函数,包括const成员函数..
b.在类中被const声明的成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.
c加上mutable修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的const成员函数是可以修改它的

类成员函数必须在内部声明；但是可以在内部和外部定义

成员函数调用对象成员 是默认有this变量

class
{
int add() const//表示常量成员函数，函数只能读不能修改数据

常量对象，以及常量对象的指针或引用都只能调用常量成员函数；
成员函数可以随意使用类中其他成员函数而不考虑出现先后顺序；

2. 常量成员函数：在类的成员函数说明后面可以加const关键字，则该成员函数成为常量成员函数
常量成员函数在执行期间不应修改其所作用的对象。所以，常量成员函数不能修改成员变量的值（静态成员变量除外），也不能调用同类的非常量成员函数（静态成员函数除外）。

};

常量成员函数的重载：两个成员函数，名字和参数表都一样，一个是const，一个不是，算是重载情况

在类外部定义的成员函数
double sales_data::avg_price() const
{
if(units_sold)
return revenue/units_sold;//隐式调用类成员
else return 0;
}
类默认的对象指针是this；
sales_data & sales_data::combine(const sales_data &rhs)
{
units_sold+=rhs.unis_sold;
return *this;
}
istream &read(istream &is,sales_data &item)
{
double price=0;
is>>item.bookNp>>item.units_sold>>price;
return is;//流(is>>item.bookNp )操作完后返回流is。>>被重载过的
}
ostream &read(ostream &os,sales_data &item)
{
os<<...<<...;
return os;
}
IO类属于不能被拷贝类型所以只能传引用和返回引用；
truct ListNode {
int val;
ListNode *next;
ListNode() : val(0), next(nullptr) {}//构造函数
ListNode(int x) : val(x), next(nullptr) {}
ListNode(int x, ListNode *next) : val(x), next(next) {}
};

struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode() : val(0), left(nullptr), right(nullptr) {}
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};


seles_data add(const seles_data& lhs,const seles_data&rhs)
{
seles_data sum=lhs;
sum.combine(rhs);
return sum;
}


构造函数