1. 类的访问属性：public，protect，privateC++中类的成员变量和函数都带有三种属性中的一种，假如没有特别声明，那么就默认是私有的（除了构造函数）。public表示是公开的，对象可以直接调用的变量或者函数；protect表示是保护性的，只有本类和子类函数能够访问（注意只是访问，本类对象和子类对象都不可以直接调用），而私有变量和函数是只有在本类中能够访问（有个例外就是友元函数，这个后面会详细说）。
class A
{
public:
A(int b):m_public(b),m_protected(1), m_private(2){}
int m_public;
protected:
int m_protected;
private:
int m_private;
};
int main( void )
{
A a(10);
cout<<a.m_public<<endl; //正确，可以直接调用
cout<<a.m_protected<<endl; //错误，不可以直接调用
cout<<a.m_private<<endl;//错误，不可能直接调用
}
而子类对父类的继承类型也有这三种属性，分别为公开继承，保护继承和私有继承。
class A
{
public:
A(int b):m_public(b),m_protected(1), m_private(2){}
int m_public;
protected:
int m_protected;
private:
int m_private;
};
class B: public A{} //公有继承
class C: protected A{} //保护继承
class D:private A{} //私有继承
public继承 public protected 不可用
protected继承 protected protected 不可用
private继承 private private 不可用
class A
{
public:
A(int b):m_public(b){}
int m_public;
};
class B:private A
{
public:
B(int num):A(num){}
};
int main()
{
B b(10);
cout<<b.m_public<<endl; //错误，无法直接调用私有成员
}
2. 类的四个默认函数：构造，拷贝构造，赋值，析构（这一点要背下来，面试直接被问了）
- 每当构建一个新的类，编译器都会给每个类生成以上四个默认的无参构造函数，并且这四个函数都是默认public的。
class A
{
public:
double m_a;
};
int main( void )
{
A a; //调用默认无参构造函数，此时m_a的值是不确定的，不能用
//离开主函数前调用析构函数，释放a的内存
}
但是一旦程序员自己定了带参数的构造函数，那么编译器就不会再生成默认的无参构造函数了，但是还是有默认的拷贝和赋值构造函数。因此假如只定义了有参数的构造函数，那么这个类就没有无参构造函数。
class A
{
public:
A(int i):m_a(i){}
int m_a;
};
int main( void )
{
A a; //错误！没有无参构造函数
A a1(5); // 调用了A中程序员定义的有参构造函数
A a2(6); // 调用了A中程序员定义的有参构造函数
A a3 = a1; //此处调用默认的拷贝构造函数
a2 = a1; //此处调用默认的赋值函数
}
class A
{
public:
A(int i, int* p):m_a(i), m_ptr(p){}int m_a;
int *m_ptr;
};
int main( void )
{
int m = 10, *p = &m;
A a1(3, p);
A a2 = a1; //a2 和 a1的m_ptr都指向了同一地址
*p = 100;
cout<<*(a2.m_ptr)<<endl; //输出为100
}
class A
{
public:
A(int b):m_public(b),m_protected(1), m_private(2){}
int m_public;
protected:
int m_protected;
private:
int m_private;
};
int main( void )
{
A a(10);
cout<<"a.m_public"<<endl; //正确，可以直接调用
cout<<a.m_protected<<endl; //错误，不可以直接调用
cout<<a.m_private<<endl;//错误，不可能直接调用
}
- 子类会继承父类定义的构造函数吗？
class A
{
public:
A(int b):m_public(b){}
int m_public;
};
class B:public A
{
};
int main()
{
B b; //出错，因为父类没有无参构造函数
}
class A
{
public:
A(int b):m_public(b){}
int m_public;
};
class B:public A
{
public:
B(int num):A(num){}
};
int main()
{
B b1; //出错，由于父类没有无参构造函数，因此B也不存在无参构造
B b2(5); //正确
}
-
构造函数的构造顺序：先构造基类，再构造子类中的成员，再构造子类
class A
{
public:
A(){cout<<"constructing A"<<endl;}
};
class B
{
public:
B(){cout<<"constructing B"<<endl;}
};
class C:public A
{
public:
B b;
A a;
int num;
C(int n):num(n){cout<<"constructing C"<<endl;}
};
int main()
{
C c(1);
}
- 假如把构造函数和析构函数定义成私有的会怎样？（被问的时候真的一脸懵，-_-//）
class A
{
public:
int m_public;
static A* getInstance(int num)
{
return new A(num);
}
private:
A(int b):m_public(b){}
};
int main()
{
A a1(4); //错误
A* pa = A::getInstance(5); //正确
}
class A
{
public:
int m_public;
static A* getInstance(int num)
{
return new A(num);
}
A(int b):m_public(b){}
private:
~A(){}
};
int main()
{
A a(5); //错误，因为系统无法自动调用析构函数
A *p_a = new A(5); //正确，此时p_a指向的是堆中的内存
}
- 构造函数的初始化列表（就是构造函数冒号后面的东西，叫初始化列表，需要与{}中的函数内容区分开）
常量成员
引用类型
没有默认构造函数的类类型
class A
{
public:
int m_a;
A(int num):m_a(num){}
};
class B
{
public:
const int m_const;
int &m_ref;
A a;
B(int num, int b):m_ref(b), m_const(1), a(num) //初始化列表
{
cout<<"constructing B"<<endl;
}
};
int main()
{
int n = 5;
B b(1, n);
}
- 隐式转换与explicit关键字的使用
class A
{
public:
int m_a;
A(int num):m_a(num){cout<<"constructing A"<<endl;}
};
void test(A a)
{
cout<<a.m_a+1<<endl;
}
int main()
{
A a1= 6; //此时等式右边的6隐式生成了一个以6为参数的A类对象
test(6); //输出7，入参也隐式生成了一个以6为参数的A类对象
cout<<a1.m_a<<endl; //输出6
}
class A
{
public:
int m_a;
explicit A(int num):m_a(num){cout<<"constructing A"<<endl;}
};
void test(A a) { cout<<a.m_a+1<<endl;
}
int main()
{
A a1= 6; //错误
test(6); //错误
}
3. 虚函数
虚函数是C++实现多态的方法。虚函数和普通函数没有什么区别，只有当用基类指针调用子类对象的方法时才能够真正发挥它的作用，也只有在这种情况下，才能真正体现出C++面对对象编程的多态性质。
先来了解一下绑定的概念。函数体与函数调用关联起来叫做绑定。
-
早绑定：早绑定发送在程序运行之前，也是编译和链接阶段。
class A
{
public:
int m_a;
A(int num):m_a(num){}
int add(int n)
{
return m_a + n;
}
};
int main()
{
A a(1);
cout<<a.add(5);
}
- 晚绑定：晚绑定发生在程序运行期间，主要体现在继承的多态方面。
class A
{
public:
int m_a;
A(int num):m_a(num){}
void virtual show()
{
cout<<"base function"<<endl;
}
};
class B:public A
{
public:
B(int n):A(n){}
void show()
{
cout<<"derived function"<<endl;
}
};
int main()
{
A *pa = new B(1);
pa->show(); //输出 derived function
}
父类和子类都定义了show方法，在继承的过程中，由于父类show方法是虚函数，而父类指针指向的是子类对象，所以会在子类对象中去找show函数的实现。假如子类中没有show，那么就还是会调用父类的show。
这个晚绑定的过程是通过虚指针实现的。只要一个类中声明了有虚函数，那么编译器就会自动生成一个虚函数表。虽然名字叫表，但本质是一个存放虚函数指针的函数指针数组。一个虚表对应一个指针。当该类作为基类，其派生类对基类的（一个或者多个）虚函数进行重写时，派生类的虚函数表中，相应的函数指针的值就会发生变化。
构造函数不能声明为虚函数。虚函数是晚绑定，一定是先有了基类对象，才会有对应的虚指针，再去本类或者子类对象中去找对应的实现。所以一定要先通过构造函数创建了对象，才能去实现虚函数的作用。
而析构函数，则常常被声明为虚函数。（记得当时面试官问我，析构函数能不能是虚的，我当时斩钉截铁得回答，不能！-_-//）
先看下面这个例子。
class A
{
public:
int m_a;
A(int num):m_a(num){cout<<"constructing A"<<endl;}
~A(){cout<<"destructing A"<<endl;}
};
class B:public A
{
public:
B(int n):A(n){cout<<"constructing B"<<endl;}
~B(){cout<<"destructing B"<<endl;}
};
int main()
{
A* pa= new B(1);
delete pa;
}
执行结果为：
可以看到是先构建了A对象，然后构建了B对象。可是却只析构了A对象，B对象的内存空间就泄漏了。
现在把A的析构函数置为虚函数的话，
class A
{
public:
int m_a;
A(int num):m_a(num){cout<<"constructing A"<<endl;}
virtual ~A(){cout<<"destructing A"<<endl;}
};
class B:public A
{
public:
B(int n):A(n){cout<<"constructing B"<<endl;}
~B(){cout<<"destructing B"<<endl;}
};
int main()
{
A* pa= new B(1);
delete pa;
}
class A
{
public:
int m_a;
A(int num):m_a(num){}
virtual void show()
{
cout<<"A::show()"<<endl;
}
virtual ~A(){}
};
class B:public A
{
public:
B(int n):A(n){}
void show()
{
cout<<"B::show()"<<endl;
}
~B(){}
};
int main()
{
A a(1); a.show(); //输出A::show()
B b(1); b.show(); //输出B::show()
}
4. 成员函数的重载、隐藏与覆盖
- 成员函数的重载
（2）函数名字相同
（3）参数不同 ，也可以仅仅是顺序不同
（4）virtual 关键字可有可无
class A
{
public:
int m_a;
A(int num):m_a(num){}
void show(int n){} //（1）
virtual void show(int n){} //(2) 错误！！不是重载，重复定义了（1），因为virtual关键字不能重载函数
void show(double d){} //（3）show函数的重载
void show(int a, double b){} //（4）show函数的重载
void show(double b, int a){} //(5)show函数的重载
void show(int a, double b) const {} //(6)show函数的重载，const关键可以作为重载的依据
void show(const int a, double b){} //（7）错误！！不是重载, 顶层const不可以作为重载的依据，重复定义了(6)
void show(int *a){} //(8)show函数的重载
void show(const int *a){} //（9）show函数的重载，只有底层const才可以作为重载的依据
void show(int * const a){} //(10) 错误！！不是重载，重复定义了(8),因为这里也使用了顶层const
};
- 成员函数的隐藏，这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数
class A
{
public:
void show(int a) {cout<<"A::show()"<<endl;}//（1）
};
class B:public A
{
public:
void show(){cout<<"B::show()"<<endl;} //（2）将（1）屏蔽了
};
-
假如在子类中仍旧需要用到基类的同名函数，就要用using关键字显式声明。
class A
{
public:
void show(int) {cout<<"A::show()"<<endl;}
};
class B:public A
{
public:
using A::show;
void show(){
show(0); //一定要在前面显式声明using A中的show函数，否则此句会编译错误
cout<<"B::show()"<<endl;
}
};
int main()
{
B b;
b.show();
}
- 成员函数的覆盖
（2）函数名字相同
（3）参数相同
（4） 基类函数必须有virtual 关键字这其实就是多态的实现过程。注意参数必须要完全一致。之前讲过，在此不再赘述。
5. inline关键字
定义在类中的成员函数默认都是内联的。内联函数和普通函数的区别在于：当编译器处理调用内联函数的语句时，不会将该语句编译成函数调用的指令，而是直接将整个函数体的代码插人调用语句处，就像整个函数体在调用处被重写了一遍一样。这有助于提高程序的运行效率。但是要注意inline函数仅仅是一个对编译器的建议，所以最后能否真正内联，看编译器的意思，它如果认为函数不复杂，能在调用点展开，就会真正内联，并不是说声明了内联就会内联，声明内联只是一个建议而已。这也是为什么虚函数可以是内连函数。因为仅仅是建议，当虚函数需要表现出多态性质的时候，编译器会选择不内连。6. 友元函数、友元类
类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。class A
{
public:
A(int n):m_a(n){}
friend class B; //声明B为A的友元类
private:
int m_a;
};
class B
{
public:
B(A a){cout<<a.m_a<<endl;} //由于B是A的友元类，所以可以直接调用a的私有m_a成员
};
int main()
{
A a(1);
B b = B(a); //输出1
}
7. 运算符的重载
-
首先要明确，有6个运算符是不可以被重载的。
. （成员访问运算符）
.*, ->* （成员指针访问运算符）
:: （域运算符）
sizeof （长度运算符）
?: （条件运算符）
# （预处理符号）
-
=, [] ,() ,-> 四个符号只能通过成员函数来重载，不能通过友元函数来定义
=，->, [], () 为什么不能重载为友元函数，是因为当编译器发现当类中没有定义这4个运算符的重载成员函数时，就会自己加入默认的运算符重载成员函数。而如果这四个运算符写成友元函数时会报错，产生矛盾。
-
不允许用户定义新的运算符作为重载运算符，不能修改原来运算符的优先级和结合性，不能改变操作对象等等限制
-
重载原则如下：
如果是一元操作，就用成员函数去实现
如果是二元操作，就尽量用友元函数去实现
如果是二元操作，但是对两个操作对象的处理不同，那么就尽可能用成员函数去实现
-
运算符的重载
class A
{
public:
A(int n):m_a(n){}
int m_a;
friend A operator+(A const& a1, A const & a2);
};
A operator+(A const& a1, A const & a2)
{
A res(0);
res.m_a = 1 + a1.m_a + a2.m_a;
return res;
}
int main()
{
A a1(1), a2(2);
A a3 = a1 + a2;
cout<<a3.m_a; //输出4
}
8. 再谈const关键字
-
常量指针指向常对象, 常对象只能调用其常成员函数
class A
{
public:
A(int n):m_a(n){}
int m_a;
void show(){cout<<"A::show()"<<endl;}
};
int main()
{
A a1(1);
const A a2(2);
a1.show(); //正确
a2.show(); //错误
}
假如增加const函数后，就可以正常运行。
class A
{
public:
A(int n):m_a(n){}
int m_a;
void show(){cout<<"A::show()"<<endl;}
void show() const{cout<<"A::show() const"<<endl;}
};
int main()
{
A a1(1);
const A a2(2);
a1.show(); //正确 输出A::show()
a2.show(); //正确 输出A::show() const，自动调用const函数
}
-
A const* 和const A*等价，允许用A* 赋值A const*，但是不允许用A const* 赋值A*
class A
{
public:
A(int n):m_a(n){}
int m_a;
void changeValue(int *p){cout<<"changeValue"<<endl;}
void changeValue2(int const *p){cout<<"changeValue2"<<endl;}
};
int main()
{
int n = 10;
int const *p_n_const = &n;
int *p_n = &n;
A a(1);
a.changeValue(p_n_const); //错误，无法把int const*类型，转成int *类型，但是反之可以
a.changeValue2(p_n); //正确，输出changeValue2
}