继承与重载

# Method Override:方法重载

虚函数

构造函数中调用虚函数,虚函数表现为该类中虚函数的行为,即在父类构造函数中调用虚函数,虚函数的表现就是父类定义的函数的表现。

#include <iostream>
class A {
public:
A() : mG(0) {}
virtual ~A() {}
virtual void f(int x = 1) {
g();
std::cout << x << "";
std::cout << mG << std::endl;
}
protected:
virtual void g() {
mG = 1;
}
int mG;
};
class B : public A {
public:
B() : A() {}
virtual ~B() {}
virtual void f(int x = 2) {
g();
std::cout << x << "";
std::cout << mG << std::endl;
}
protected:
virtual void g() {
mG = 2;
}
};
int main()
{
A* a = new B;
a->f();
return 0;
}

构造函数调用顺序

(1)任何虚拟基类的构造函数按照他们被继承的顺序构造 (2)任何非虚拟基类的构造函数按照他们被继承的顺序构造 (3)任何成员对象的函数按照他们声明的顺序构造

(4)类自己的构造函数

我们看一个测试类:

```class A { public: A ():m_iVal(0){test();} virtual void func() { std::cout<test(); return 0; }

输出结果为:0 1 2,B 继承自 A, 先 A 构造函数,输出 0,然后 B 构造函数,B 的 test 继承自 A,然后找 func 函数找到 B 自己的,所以输出 1,然后 p->test()再执行一次,输出 2。
C++派生类构造函数调用顺序(详解)
我们来看下面一段代码:
class B1
{
public:
B1(int i) {cout<<"constructing B1 "<<i<<endl;}
};
class B2
{
public:
B2(int j) {cout<<"constructing B2 "<<j<<endl;}
};
class B3
{
public:
B3( ){cout<<"constructing B3 _"<<endl;}
};
class C: public B2, public B1, public B3
{
public:
C(int a, int b, int c, int d):B1(a),memberB2(d),memberB1(c),B2(b){}
private:
B1 memberB1;
B2 memberB2;
B3 memberB3;
};
void main( )
{ C obj(1,2,3,4); }
运行后的结果如下:
constructing B2 2
constructing B1 1
constructing B3 _
constructing B1 3
constructing B2 4
constructing B3 _
为什么会有以上的结果?
众所周知构造函数的执行次序如下:
调用基类构造函数,调用顺序按照他们的继承时声明的顺序。
调用内嵌成员对象的构造函数,调用顺序按照他们在类中声明的顺序。
派生类的构造函数体中的内容。
析构函数的调用顺序相反。
那么再来看以上的例子就很容易理解了。B2、B1、B3 是 C 的基类,按照上述的顺序,我们先要构造基类,然后才是子对象,最后是其本身的构造函数所以先要执行这三个类的构造函数。在构造时按照他们在类中的顺序,首先调用 B2 的构造函数
B2(int j) {cout<<"constructing B2 "<<j<<endl;}
由于在默认参数列表
C(int a, int b, int c, int d):B1(a),memberB2(d),memberB1(c),B2(b){}
中,将 b 的值传给了 B2 的构造函数,b 为 2,故打印出:
constructing B2 2
接下来要构造的是 B1 了。显然在 C 的默认参数构造列表中将 a 的值传给了 B1,
所以打印出:
constructing B1 1
B3 在构造时没有传递参数,调用 B3( ){cout<<"constructing B3 _"<<endl;}
打印出:
cout<<"constructing B3 _
这时基类的构造函数已经执行完毕,接着该处理内嵌成员对象的构造函数了。
我们看到 C 类有三个对象:B1 memberB1;B2 memberB2;B3 memberB3;,按照构造函数的调用顺序,我们需要按照他们在类中声明的顺序来分别构造 memberB1、memberB2、 memberB3。在默认的参数列表中,用 c 来构造了 memberB1,用 d 来构造 memberB2,
故打印出:
constructing B1 3
constructing B2 4
constructing B3 _
最后调用本身的构造函数,由于函数体为空,故什么也没有打印出来。
总结下来,我们必须明确的是当一个类继承与基类,并且自身还包含有其他类的成员对象的时候,构造函数的调用顺序为:调用基类的构造函数->调用成员对象的构造函数->调用自身的构造函数。构造函数的调用次序完全不受构造函数初始化列表的表达式中的次序影响,与基类的声明次数和成员对象在函数中的声明次序有关。再如:
#include<iostream.h>
class A
{
protected:
char c;
public:
A(char ch)
{
c=ch;
cout<<"c="<<c<<endl;
cout<<"类 A 构造函数被调用"<<endl;
}
~A()
{
cout<<"类 A 析构函数被调用"<<endl;
}
};
class B
{
protected:
int i;
public:
B(int j)
{
i=j;
cout<<"i="<<i<<endl;
cout<<"类 B 构造函数被调用"<<endl;
}
~B()
{
cout<<"类 B 析构函数被调用"<<endl;
}
};
class C:public A,B
{
private:
int k;
public:
C(char ch,int ii,int kk):A(ch),B(ii),k(kk)
{
cout<<"k="<<k<<endl;
cout<<"类 C 构造函数被调用"<<endl;
}
~C()
{
cout<<"类 C 析构函数被调用"<<endl;
}
};
void main()
{
C A('B',10,15);
}
输出结果:
c=B
类 A 构造函数被调用
i=10
类 B 构造函数被调用
k=15
类 C 构造函数被调用类 C 析构函数被调用类 B 析构函数被调用类 A 析构函数被调用
# 虚函数
虚函数为了重载和多态的需要,在基类中是由定义的,即便定义是空,所以子类中可以重写也可以不写基类中的函数!纯虚函数在基类中是没有定义的,必须在子类中加以实现,很像 java 中的接口函数!

class Cman { public: virtual void Eat(){……}; void Move(); private: }; class CChild : public CMan { public: virtual void Eat(){……}; private: }; CMan m_man; CChild m_child; //这才是使用的精髓,如果不定义基类的指针去使用,没有太大的意义 CMan *p ; p = &m_man ; p->Eat(); //始终调用CMan的Eat成员函数,不会调用 CChild 的 p = &m_child; p->Eat(); //如果子类实现(覆盖)了该方法,则始终调用CChild的Eat函数 //不会调用CMan 的 Eat 方法;如果子类没有实现该函数,则调用CMan的Eat函数

p->Move(); //子类中没有该成员函数,所以调用的是基类中的

## 纯虚函数
引入原因:
1、同“虚函数”;
2、在很多情况下,基类本身生成对象是不合情理的。例如,动物作为一个基类可以派生出老虎、孔雀等子类,但动物本身生成对象明显不合常理。
//纯虚函数就是基类只定义了函数体,没有实现过程定义方法如下
// virtual void Eat() = 0; 直接=0 不要 在 cpp 中定义就可以了
//纯虚函数相当于接口,不能直接实例话,需要派生类来实现函数定义
//有的人可能在想,定义这些有什么用啊,我觉得很有用
//比如你想描述一些事物的属性给别人,而自己不想去实现,就可以定
//义为纯虚函数。说的再透彻一些。比如盖楼房,你是老板,你给建筑公司
//描述清楚你的楼房的特性,多少层,楼顶要有个花园什么的
//建筑公司就可以按照你的方法去实现了,如果你不说清楚这些,可能建筑
//公司不太了解你需要楼房的特性。用纯需函数就可以很好的分工合作了
虚函数和纯虚函数区别
观点一:
类里声明为虚函数的话,这个函数是实现的,哪怕是空实现,它的作用就是为了能让这个函数在它的子类里面可以被重载,这样的话,这样编译器就可以使用后期绑定来达到多态了
纯虚函数只是一个接口,是个函数的声明而已,它要留到子类里去实现。
class A{
protected:
void foo();//普通类函数
virtual void foo1();//虚函数
virtual void foo2() = 0;//纯虚函数
}
观点二:
虚函数在子类里面也可以不重载的;但纯虚必须在子类去实现,这就像 Java 的接口一样。通常我们把很多函数加上 virtual,是一个好的习惯,虽然牺牲了一些性能,但是增加了面向对象的多态性,因为你很难预料到父类里面的这个函数不在子类里面不去修改它的实现
观点三:
虚函数的类用于“实作继承”,继承接口的同时也继承了父类的实现。当然我们也可以完成自己的实现。纯虚函数的类用于“介面继承”,主要用于通信协议方面。关注的是接口的统一性,实现由子类完成。一般来说,介面类中只有纯虚函数的。
观点四:
错误:带纯虚函数的类叫虚基类,这种基类不能直接生成对象,而只有被继承,并重写其虚函数后,才能使用。这样的类也叫抽象类。
虚函数是为了继承接口和默认行为
纯虚函数只是继承接口,行为必须重新定义
# 虚基类
虚基类主要解决在多重继承时,基类可能被多次继承,虚基类主要提供一个基类给派生类,如:

class B

{

};

class D1:public B

{

};

class D2:public B

{

};

class C:public D1,public D2

{

};

这里C在D1,D2上继承,但有两个基类,造成混乱。因而使用虚基类,即:

classB

{

};

class D1:virtual public B

{

};

class D2:virtual publicB

{

};

class C:public D1,public D2

```

虚基类的初始化与一般多继承的初始化在语法上是一样的,但构造函数的调用次序不同. 派生类构造函数的调用次序有三个原则: (1)虚基类的构造函数在非虚基类之前调用; (2)若同一层次中包含多个虚基类,这些虚基类的构造函数按它们说明的次序调用; (3)若虚基类由非虚基类派生而来,则仍先调用基类构造函数,再调用派生类的构造函数.

使用虚基类应该注意: (1) 一个类可以在一个类族中既被用作虚基类,也被用作非虚基类。

(2) 在派生类的对象中,同名的虚基类只产生一个虚基类子对象,而某个非虚基类产生各自的子对象。

(3) 虚基类子对象是由最远派生类的构造函数通过调用虚基类的构造函数进行初始化的。

(4) 最远派生类是指在继承结构中建立对象时所指定的类。

(5) 派生类的构造函数的成员初始化列表中必须列出对虚基类构造函数的调用;如果未列出,则表示使用该虚基类的缺省构造函数。

(6) 从虚基类直接或间接派生的派生类中的构造函数的成员初始化列表中都要列出对虚基类构造函数的调用。但仅仅用建立对象的最远派生类的构造函数调用虚基类的构造函数,而该派生类的所有基类中列出的对虚基类的构造函数的调用在执行中被忽略,从而保证对虚基类子对象只初始化一次。

(7) 在一个成员初始化列表中同时出现对虚基类和非虚基类构造函数的调用时,虚基类的构造函数先于非虚基类的构造函数执行。

静态联编:在程序链接阶段就可以确定的调用。动态联编:在程序执行时才能确定的调用。

  1. this 指针的用处: 一个对象的 this 指针并不是对象本身的一部分,不会影响 sizeof(对象)的结果。this 作用域是在类内部,当在类的非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说,即使你没有写上 this 指针,编译器在编译的时候也是加上 this 的,它作为非静态成员函数的隐含形参,对各成员的访问均通过 this 进行。例如,调用 date.SetMonth(9) <===> SetMonth(&date, 9),this 帮助完成了这一转换 2. this 指针的使用: 一种情况就是,在类的非静态成员函数中返回类对象本身的时候,直接使用 return this;另外一种情况是当参数与成员变量名相同时,如 this->n = n (不能写成 n = n)。3. this 指针程序示例: this 指针存在于类的成员函数中,指向被调用函数所在的类实例的地址。根据以下程序来说明 this 指针 #include class Point { int x, y; public: Point(int a, int b) { x=a; y=b;} void MovePoint( int a, int b){ x+=a; y+=b;} void print(){ cout<<"x="<<x<<"y="<<y<<endl;} }; void main( ) { Point point1( 10,10); point1.MovePoint(2,2); point1.print( ); } 当对象 point1 调用 MovePoint(2,2)函数时,即将 point1 对象的地址传递给了 this 指针。MovePoint 函数的原型应该是 void MovePoint( Point this, int a, int b);第一个参数是指向该类对象的一个指针,我们在定义成员函数时没看见是因为这个参数在类中是隐含的。这样 point1 的地址传递给了 this,所以在 MovePoint 函数中便显式的写成: void MovePoint(int a, int b) { this->x +=a; this-> y+= b;} 即可以知道,point1 调用该函数后,也就是 point1 的数据成员被调用并更新了值。即该函数过程可写成 point1.x+= a; point1. y + = b;4. 关于 this 指针的一个经典回答: 当你进入一个房子后,你可以看见桌子、椅子、地板等,但是房子你是看不到全貌了。对于一个类的实例来说,你可以看到它的成员函数、成员变量,但是实例本身呢?this 是一个指针,它时时刻刻指向你这个实例本身 1. this 指针的用处: 一个对象的 this 指针并不是对象本身的一部分,不会影响 sizeof(对象)的结果。this 作用域是在类内部,当在类的非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说,即使你没有写上 this 指针,编译器在编译的时候也是加上 this 的,它作为非静态成员函数的隐含形参,对各成员的访问均通过 this 进行。例如,调用 date.SetMonth(9) <===> SetMonth(&date, 9),this 帮助完成了这一转换 2. this 指针的使用: 一种情况就是,在类的非静态成员函数中返回类对象本身的时候,直接使用 return this;另外一种情况是当参数与成员变量名相同时,如 this->n = n (不能写成 n = n)。3. this 指针程序示例: this 指针存在于类的成员函数中,指向被调用函数所在的类实例的地址。根据以下程序来说明 this 指针 #include class Point { int x, y; public: Point(int a, int b) { x=a; y=b;} void MovePoint( int a, int b){ x+=a; y+=b;} void print(){ cout<<"x="<<x<<"y="<<y<<endl;} }; void main( ) { Point point1( 10,10); point1.MovePoint(2,2); point1.print( ); } 当对象 point1 调用 MovePoint(2,2)函数时,即将 point1 对象的地址传递给了 this 指针。MovePoint 函数的原型应该是 void MovePoint( Point this, int a, int b);第一个参数是指向该类对象的一个指针,我们在定义成员函数时没看见是因为这个参数在类中是隐含的。这样 point1 的地址传递给了 this,所以在 MovePoint 函数中便显式的写成: void MovePoint(int a, int b) { this->x +=a; this-> y+= b;} 即可以知道,point1 调用该函数后,也就是 point1 的数据成员被调用并更新了值。即该函数过程可写成 point1.x+= a; point1. y + = b;4. 关于 this 指针的一个经典回答: 当你进入一个房子后,你可以看见桌子、椅子、地板等,但是房子你是看不到全貌了。对于一个类的实例来说,你可以看到它的成员函数、成员变量,但是实例本身呢?this 是一个指针,它时时刻刻指向你这个实例本身