1. 函数形参默认值
（1） 建议函数（不仅仅是构造函数）形参默认值只在函数声明中指定；
（函数声明和定义写在同一个文件中，则函数声明、定义两者之一或两者都可指定形参默认值，两者都指定默认值时，默认值需相同；但函数声明写在头文件、定义写在源文件时，只能在函数声明中指定形参默认值。）
（2）函数参数默认值 “一默到底”；
（3）若在调用函数时传入参数，则相应参数会替换掉默认值；
（4）构造函数只能通过初始化列表对const成员变量进行初始化，不可在其函数体中使用赋值语句进行初始化；
（5）注意：C语言不支持函数形参有默认值的特性。
2. 隐式类型转换和explicit
2.1 构造函数隐式类型转换
class Animal {
public:
Animal() { // 无参构造函数
cout << "Animal()" << endl;
}
Animal(int age) :age_(age) { // 有参构造函数1
cout << "Animal(int age)" << endl;
}
Animal(int age, char gender) :age_(age), gender_(gender) { // 有参构造函数2
cout << "Animal(int age, char gender)" << endl;
}
private:
int age_;
char gender_;
};
void test() {
Animal animal0; // 无参构造函数
Animal animal1 = 10; // 有参构造函数1
Animal animal2 = { 20,'n' }; // 有参构造函数2
Animal animal3 = (30, 'n'); // 有参构造函数1，写法错误！！！
}运行结果：
如上示例，animal1和animal2的构造发生了隐式类型转换。
注意：Animal animal3 = (30, 'n')这种写法错误，因为逗号表达式的值为其中最后一个表达式的值，这里发生窄化转换（不同数值类型的转换），相当于使用n来初始化age，所以调用构造函数Animal(int age)。
2.2 explicit关键字
如何禁止调用构造函数时的隐式类型转换？使用explicit关键字修饰构造函数即可。
使用explicit修饰后，需要显式地指定初始化的类型。
如：
class Animal {
public:
explicit Animal(int age) :age_(age) {
cout << "Animal(int age)" << endl;
}
private:
int age_;
char gender_;
};
void test() {
Animal animal1 = 10; // 错误，禁止隐式类型转换。
Animal animal2 = static_cast<Animal>(10); // 显式地指定初始化的类型
Animal animal3 = Animal(10); // 显式地指定初始化的类型
}建议：
（1）单参数的构造函数声明为explicit；
（2）explicit只在函数声明时添加。
3. 常量成员函数
3.1 const修饰成员函数体
则该成员函数为“常量成员函数”，不可修改对象中的成员变量。
示例：
class Student {
public:
Student(int id) :id_(id) {
}
auto getId() const {
id_ += 3; // 错误。不可修改成员
return id_;
}
private:
int id_;
};3.2 const修饰返回值为引用的成员函数
则返回的引用不能被修改。
示例：
class Student {
public:
Student(int id) :id_(id) {
}
const auto& getId() const {
// id_ += 3; 错误。不可修改成员
return id_;
}
private:
int id_;
};
void test01() {
Student s0(16);
// s0.getId() += 3; 错误。不可修改返回的引用
cout << s0.getId() << endl;
}注意：该返回值为引用的成员函数被两个const修饰，
第一个const表示返回的引用不能被修改，第二个const表示函数体中不能修改对象成员。
3.3 const对象只能调用const成员函数，非const对象可调用const成员函数
示例：
class Student {
public:
Student(int id, string name) :id_(id),name_(name) {
}
int getId() const { // const成员函数
return id_;
}
string getName() { // 非const成员函数
return name_;
}
private:
int id_;
string name_;
};
void test01() {
const Student s0(16,"ABC"); // const对象
cout << s0.getId() << endl; // 正确。const对象可调用const成员函数
cout << s0.getName() << endl; // 错误。const对象不可调用非const成员函数
Student s1(20, "XYZ"); // 非const对象
cout << s1.getId() << endl; // 正确。非const对象可调用const成员函数
cout << s1.getName() << endl; // 正确。非const对象可调用非const成员函数
}（1）非const对象可调用const、非const成员函数；
（2）const对象只可调用const成员函数；
（3）const成员函数可被const、非const对象调用；
（4）非const成员函数只可被非const对象调用。
注意：普通函数（非类成员函数）不能用const修饰！
如下错误！
void func() const { // 错误。普通函数不能用const修饰
}4. mutable
则const成员函数可修改mutable修饰的成员变量。
class Student {
public:
Student(int id, string name) :id_(id),name_(name) {
}
void setId(int id) const { // 可修改mutable成员
id_ = id;
}
private:
mutable int id_;
string name_;
};5. this指针
（1）普通成员函数隐藏一个this指针，该指针指向调用函数的对象；
（2）this指针只能在普通成员函数中使用，全局函数、static函数不能使用this指针；
（3）非const成员函数，this指针是一个指向非const对象的指针常量；
（意思是：非const对象只可调用非const成员函数；并且this指针的指向不能改变）
6. static成员
（1）static全局变量：保存在静态区，作用域为当前文件，无法在其他文件使用（使用extern声明也无法使用）；
（2）static成员函数只能访问static成员变量；
（3）static成员变量在类内定义，类外初始化；
类外初始化时不必加static关键字。
如下：
class Student {
private:
int id_;
static int a_; // 类内定义static成员变量
static void setA(); // 类内定义static成员函数
}
/* 类外初始化static成员变量、函数 */
int Student::a = 10; // 初始化时不必加static关键字；不给初值则为0.
void Student::setA() {
a_ = 99; // 正确，static成员函数可访问static成员变量
// id_ = 88; // 错误，static成员函数不可访问非static成员变量
}
（4）static成员变量或函数属于类，为该类所有对象共享；
访问方式：
class Student {
public :
static int a;
static void setA();
};
int Student::a = 10;
void Student::setA() {
a = 99;
}
void test02() {
Student s0(20, "AAA");
Student::a; // 通过类访问static成员变量
s0.a; // 通过对象访问static成员变量
Student::setA(); // 通过类访问static成员函数
s0.setA(); // 通过对象访问static成员函数
}7. 拷贝构造函数
用一个已存在的对象初始化新对象，会调用拷贝构造函数。
（1）拷贝构造函数的第一个形参必须是该类类型的引用，可以没有其他参数；若有其他参数，则其他参数必须有默认值。如：
Student(const Student& s, int age = 18);（2）拷贝构造函数不建议使用explicit修饰；
8. 隐藏
概念：
派生类中有与基类同名（参数列表可不同）的成员函数，则基类中的该同名成员函数在派生类中不可见（不可调用）。
实例1：派生类中无与基类同名的成员函数。
class Person {
public:
void run() {
cout << "Person::run()" << endl;
}
void run(int a) {
cout << "Person::run(int a)" << endl;
}
};
class Student :public Person {
};
void test() {
Student s;
s.run(); // 正常调用
s.run(3); // 正常调用
}示例2：派生类中有与基类同名的成员函数，发生隐藏。
class Person {
public:
void run() {
cout << "Person::run()" << endl;
}
void run(int a) {
cout << "Person::run(int a)" << endl;
}
};
class Student :public Person {
public:
void run(string s) {
cout << "Student::run(string s)" << endl;
}
};
void test() {
Student s;
s.run("ABC"); // 正常调用
s.run(); // 不可调用基类的run()
s.run(3); // 不可调用基类的run(int)
}发生隐藏时，如何调用基类同名的成员函数？
方式1：在派生类的同名成员函数中调用基类的同名成员函数。（遵循访问权限规则）
class Student :public Person {
public:
void run() {
Person::run();
}
};方式2：C++ 11中using关键字可让基类同名成员函数在派生类中可见。（让基类的同名成员函数在派生类中以重载的方式使用，遵循访问权限规则）
注意： 使用using时只能指定函数名，无需参数列表。
class Person {
public:
void run() {
cout << "Person::run()" << endl;
}
void run(int a) {
cout << "Person::run(int a)" << endl;
}
};
class Student :public Person {
public:
void run(string s) {
cout << "Student::run(string s)" << endl;
}
public:
using Person::run; // 只能指定函数名
};
void test() {
Student s;
s.run(); // 可调用基类的run()
s.run(13); // 可调用基类的run(int)
}9. 虚函数相关
9.1 override 修饰派生类中的虚函数
建议在派生类虚函数后加关键字override，避免虚函数名、返回值类型、参数列表写错。
/*派生类中的虚函数*/
virtual void func() override {
cout << "Derive::func()" << endl;
}9.2 final 修饰基类中的虚函数
final修饰基类中的虚函数，禁止在派生类中重写。
/*基类中的虚函数*/
virtual void func() final {
cout << "Base::func()" << endl;
}9.3 建议将基类的析构函数写成虚函数
待补充。。
