C++：
C++:面向对象的C语言
面向对象（C++）与面向过程（C语言）的区别：
面向对象：强调属性（数据）和行为（方法，函数）
面向过程：强调数据结构与算法
这里着重去了解与c具有差异的部分
输入输出：
头文件：<iostream>
输入：cin：表达式1 >> 表达式2 >> ......
输出：cout：表达式1 << 表达式2 << ......
这里的表达式类似printf，输出文本时加上""，输出变量时会自动判别，并且使用endl来代替回车
std::cout << "数字是: " << number << std::endl; // 输出文本和数字
在文件中加上using namespace std;（std命名空间）后，可以省去std::前缀
cout << "数字是: " << number << endl; // 输出文本和数字
函数的参数传递：
1.值传递：
void swap(int a,int b)
{
int tmp = a;
a = b;
b = tmp;
}
2.引用传递
void swap(int &a,int &b)
{
int tmp = a;
a = b;
b = tmp;
}
-->引用传递：传递形参时使用引用变量
引用（&）是一种特殊类型的变量，可以认为是另一个变量的别名（使用引用的方法实现被调修改主调，区别与c语言中传地址实现被调修改主调的方法）
注：
1.声明一个引用时，就必须对其进行初始化，使它指向一个已经存在的对象
2.一旦一个引用进行初始化之后，就不能改为指向其他对象
注：
在函数传参时，不能使用auto（实际上不规定变量关键字时默认auto，交给编译器自己识别），如果参数为auto类型，就意味着其不论传递什么参数都可以，这是我们不期望的，此时报错
void test(auto a)
{}
内联函数：
一般函数调用：跳转，到函数处调用；内联函数：在编译时把函数嵌入在每一个调用处，这样的话能加快运行速度，内联函数的结构应该比较简单，如果将一个复杂的函数定义为内联函数，会造成代码膨胀，增大开销（有些函数不能使用内联函数处理，如递归）
显式内联：在函数定义处直接使用incline来指定：
inline int add(int a, int b)
{
return a + b;
}
隐式内联：通常发生在类内部定义，函数体非常短小，常用于构造函数与析构函数
带默认形参的函数：
在定义时给出函数的默认值，此时不传参时其参数为默认值，但是注意，函数获取参数的时候是从左往右来获取，也就是说，我如果只传递一个参数，必然是会传给a的，不能跳过a传给b
int add(int a=0, int b=0)
{
return a + b;
}
在相同的作用域内，不能存在参数数量与类型相同的重复定义（两个有一个不同就可以，也就是下文的重载）
如果写成函数声明的版本，那么其默认值只在声明（.h文件）时写出，不在函数体（.c文件）中写出，不然会发生重定义错误
int add(int a=0, int b=0) //声明
int add(int a, int b) //实现
{
return a + b;
}
函数的重载：
两个及以上的函数，形参数量或类型不同，编译器根据形参类型与个数，自动判断出调用哪一个函数，这就是函数的重载，需要注意的是，返回值类型不能作为编译器判断重载函数的标准
double add(double a=0, double b=0)
{
return a + b;
}
int add(int a=0, int b=0)
{
return a + b;
}
类：
抽象：
抽象，是指一个对具体问题进行，并对一些公共性质进行描述的过程
-->数据抽象（数据）与行为抽象（方法，函数）
简单的时钟程序：
数据抽象：
int add(int a=0, int b=0)
行为抽象：
showtime（）,settime
封装：
实际上就是将数据与方法集合形成类，其中的数据的方法都是类的成员
class Clock
{
public:
void setTime (int newH, int newM, int newS ) ;
void showTime ( ) ;
private:
int hour , minute, second;
};
在调用时，只能访问关键字public里面的数据与方法，而禁止访问private以及protect修饰的数据与方法
--继承和多态暂时不了解
对象：
类-->抽象（数据类型）
对象-->实体（变量），其实就是定义了一个变量（Class）
定义：类名 对象名（Clock c1;）
访问成员：对象名 数据类型名（c1.hour）
对象名 方法名（c1.showtime()）
成员函数的实现：
返回值类型 类名:: 参数表
{
函数体；
}
带默认形参的的成员函数：
class Clock
{
public:
void setTime (int newH= 0, int newM=0, int newS=0) ;
...
} ;
内联成员函数（隐式，可以显式）：
class Clock {
public:
void setfime (int newH, int newM,int news ) ;void showTime ( )
{
cout<<hour<< " : "<<minute<<" :"<<second<<endl;
}
private:
int hour, minute, second;
};
构造函数和析构函数：
构造函数：
构造函数：在对象被创建时利用特定的值构造对象，将对象初始化成一个特定的状态
class Clock {
public:
clock () {
/*编译系统生成的隐含的默认构造函数*/
...
};
有参构造与无参构造：
class Clock {
public:
clock(); //无参构造
clock(int j = 0,int m = 0,int s = 0) //有参构造，带默认参数
{
hours = h;
minute = m;
second = s;
}
//使用参数列表初始化
clock(int j = 0,int m = 0,int s = 0) : hours(h),minute(m),second(s)
{
}
private:
int hours;
int minute;
int second;
};
使用参数列表意味着进行的是初始化，但是在构造方法里赋值仅仅是进行赋值
复制构造：利用引用传递的方法，用于使用一个类对象来进行构造
class Clock {
public:
clock(); //无参构造
clock(const Clock &other) //有参构造，带默认参数
{
hours = other.hours;
minute = other.minute;
second = other.second;
}
private:
int hours;
int minute;
int second;
};
析构函数：
析构函数与构造函数的作用正好相反,它用来完成对象被删除前的一些清理工作,也就是专门做扫尾工作的。析构函数是在对象的生存期即将结束的时刻被自动调用的。它的调用完成之后,对象也就消失了,相应的内存空间也被释放。
与构造函数相似，它的名称是类名前加~构成
class Clock {
public:
Clock(); //构造
~Clock(); //析构
private:
int hours;
int minute;
int second;
};