标签: 多态

1. “ ++ ”和“ -- ”的重载 运算符“ ++ ”和“ -- ”的重载要区分前置和后置两种形式。如果不区分前置和后置，则使用 operator++() 或 operator—() 即可，否则要使用 operator++() 或 operator-- （）重载前置运算符，使用 operator++(int) 或 operator-- （ int ）来重载后置运算符，调用时，参数 int 被传递值 0 。 #include iostream using namespace std; class A { public : A( int x = 0):n( x ){} int getn() { return n; } A operator++ (); A operator-- ( int ); private : int n; }; A A :: operator++ () { ++n; return * this ; } A A :: operator-- ( int ) { n--; return * this ; } int main() { A ob(3); cout "ob.n= " ob.getn() endl; ++ ob; cout "ob.n= " ob.getn() endl; ob. operator-- (0); cout "ob.n=" ob.getn() endl; system( "pause" ); return 0; } 声明和定义后置“ ++ ”或“ -- ”等运算符重载，必须含有参数形式，在调用时一般指定实参为 0 2. 赋值运算符“ = ”重载 对于任何一个类，如果没有用户自定义的赋值运算函数，系统会自动地生成一个默认的赋值运算函数，以完成数据成员之间的复制。 例如： X X::operator=(const X source) { 类对象成员之间的赋值语句 } 一旦类 X 的两个对象 ob1 和 ob2 已创建，就可以用 ob1=ob2 进行赋值了。通常情况下，默认的赋值运算符函数可完成赋值任务，但在某些特殊的情况。类如，类中有一指针类的形式，如果使用默认的赋值运算符函数就会产生指针悬挂的错误。此时，就必须显式地定义一个赋值运算符重载函数，使参与赋值的两个对象有各自的存储空间。 #include iostream #include string using namespace std; class Internet { public : char *name; char *url; Internet( char * name , char * url ) { this -name = new char ; this -url = new char ; if ( this -name) { strcpy( this -name, name ); } if ( this -url) { strcpy( this -url, url ); } } Internet( Internet temp ) { this -name = new char ; this -url = new char ; if ( this -name) { strcpy( this -name, temp .name); } if (url) { strcpy( this -url, temp .url); } } ~Internet() { delete url; } Internet operator= ( Internet temp ) { delete this -url; this -name = new char ; this -url = new char ; if ( this -name) { strcpy( this -name, temp .name); } if ( this -url) { strcpy( this -url, temp .url); } return * this ; } }; int main() { Internet a( "pxc" , "www.pxc.jx.cn" ); Internet b = a; cout b.name endl b.url endl; Internet c( "Tsinghua" , "www.tsinghua.edu.cn" ); b = c; cout b.name endl b.url endl; system( "pause" ); return 0; } 在上述代码中，在类对象还未存在的情况下，赋值过程通过拷贝构造函数进行；当对象已经存在，赋值过程就通过赋值运算符重载函数进行。 在进行赋值运算符“ = ”的重载时，要注意赋值运算符只能重载为运算符成员函数，不能重载为友元运算符函数，而且赋值运算符重载后不能被继承。 3 ．下标运算符“ (T2); 其中， T 是定义下标运算符的类， T2 表示下标，其可以是任意类型，如整型，字符型或某个类。 T1 是数组运算的结果，可以是任意类型，但为了能对数组赋值，一帮将其声明为引用形式。在实际的程序中，可以通过下面两种方式来调用下标运算符： X 或 x.operator ; } int operator ; } ~IntArray() { delete = 0; cout "a = " a endl; a. operator (3)= " a endl; cout "a = " ; a. operator[] (6) = 6; system( "pause" ); return 0; } 下标越界则返回 error 。 C++ 不允许把下标运算符函数作为外部函数来定义，只能是非静态的成员函数。 4. 类类型转换 类类型转换是指某个对象的数据类型为类，而不是标准的数据类型。在 C++ 中，标准的数据类型和类类型转换有三种方法。 （1） 通过构造函数转换：可以将标准类型转换为类类型，但不能将类类型转换为标准类型； （2） 通过类类型转换函数转换：要将类类型转换为标准数据类型时，需要采用显示类型转换，定义类类型转换函数； （3） 通过运算符重载实现类型转换：可以实现标准类型的数据与类对象之间的运算。 C++ 中定义一个类的类型转换函数的形式为： 类名 ：： operator type() { Return type 类型的数据 } 其中 type 为要转换的目标类型，通常是标准类型。使用类类型转换函数时要注意： （1） 此函数的功能是将类的对象转换为类型为 type 的数据，它既没有参数，也没有返回类型，但在函数体中必须返回具有 type 类型的一个数据； （2） 类类型转换函数只能定义为类的成员函数； （3） 一个类内可以定义多个类类型转换函数，编译器会根据操作数的类型自动选择一个合适的类类型转换函数与之匹配。但在可能出现二义性时，应显式地使用类类型转换函数进行转换。 在实际的使用中，使用最多的还是运算符重载来实现类型的转换，转换运算符的声明方式比较特别。 #include iostream using namespace std; class Test { public : int a; Test( int a = 0) { cout this ":" " 载入构造函数 " a endl; Test ::a = a ; } Test( Test temp ) { cout " 拷贝构造函数 " endl; Test ::a = temp .a; } ~Test() { cout this ":" " 析构函数 " this -a endl; cin.get(); } operator int () { cout this ":" " 转换运算符函数 " this -a endl; return Test ::a; } }; int main() { Test b(99); cout "b 内存地址： " b endl; cout ( int )b endl; system( "pause" ); return 0; } 在上述代码中，利用转换运算符将 Test 类的对象强制转换为 int 类型并输出，此时观察转换运算符函数的运行状态，发现并没有产生临时对象，虽然它带有 return 语句，但它与普通函数并不相同。

1. 运算符重载的定义 运算符重载也是实现多态的一个重要手段。运算符重载实现的是编译时的多态，即静态多态性。 C++ 预定义的运算符只针对基本数据类型，而对于自定义数据类型，比如类，却没有类似的运算符。 运算符函数定义的一般形式： 返回类型说明符 operator 运算符符号 ( 参数列表 ) { 函数体 } 2. 运算符重载的特点 运算符重载使用关键字 operator 关键字对重载函数进行标识和定义。运算符有 3 种形式，即前缀、后缀、中缀。它们的 operator 表示形式如下表。 运算符重载时参数个数必须固定。重载函数的参数个数与标准运算符一致，即对于一元运算符（前缀和后缀形式），重载函数有且只有一个参数；对于二元运算符（中缀形式），重载函数有且只有两个参数。 运算符重载针对类对象操作，即重载函数的参数至少有一个属于 class 类型。 #includeiostream using namespace std; class Add { public: int operand; Add() { operand = 0; } Add(int value) { operand = value; } }; Add operator+(Add a, int b) { Add sum; sum.operand = a.operand + b; return sum; } int main() { Add a(5), b; b = a + 8; cout "the sum is: " b.operand endl; system("pause"); return 0; } 3. 运算符重载的形式 运算符的重载形式有两种：一种是重载为类的成员函数，另一种是重载为类的友元函数。对于每一种重载形式，由于运算符不同，可以分为双目运算符和单目运算符的实现。 3.1 运算符重载为类的成员函数 当运算符重载为类的成员函数，称为运算符成员函数。实际使用时，总是通过该类的对象访问重载的运算符。运算符成员函数在类内声明，在类外定义，一般形式为： 返回类型 operator 运算符 ( 参数列表 ) 在类外定义的一般形式为： 返回类型 类名：： operator 运算符 ( 参数表 ) { 函数体 } 3.1.1 双目运算符重载为成员函数 左操作数是访问该重载运算符的对象本身的数据，此时成员运算符函数只有一个参数。如： class X { X operator+(X ob); } 双目运算符重载为成员函数后，就可以在主函数或者其他类中调用。在 C++ 中，一般有显式和隐式两种调用方法。 （1）显式调用：对象名 .operator 运算符号（参数列表），如 aa.operator+(bb); （2）隐式调用：对象名 重载的运算符号 对象名，如 aa+bb ； #includeiostream using namespace std; class A { public: A(int x = 0):n(x) { } int getn() { return n; } A operator+(A a); private: int n; }; A A::operator+(A a) { A temp; temp.n = n + a.n; return temp; } int main() { A ob1(1), ob2(3), ob3, ob4; ob3 = ob1 + ob2; ob4 = ob1.operator+(ob2); cout "ob3.n= " ob3.getn() endl; cout "ob4.n= " ob4.getn() endl; system("pause"); return 0; } 3.1.2 单目运算符重载为成员函数 单目运算符重载为成员函数时，操作数是访问该重载运算符对象本身的数据，由 this 指针指出 , 此时成员运算符函数没有参数。如 Class X { X operator++(); } 与双目运算符的重载类似，单目运算符重载为成员函数后，在调用时也有显式和隐式两种。 （1） 显式调用：对象名 .operator 运算符号 () ，如 a.operator++(); （2） 隐式调用：重载的运算符号 对象名，如 ++a; #includeiostream using namespace std; class A { public: A(int x = 0) { n = x; } int getn() { return n; } A operator++(); private: int n; }; A A::operator++() { ++n; return *this; } int main() { A ob(1); ++ob; cout "ob.n= " ob.getn() endl; ob.operator++(); cout "ob.n=" ob.getn() endl; system("pause"); return 0; } 3.2 运算符重载为类的友元函数 将重载的运算符成员函数定义为类的友元函数，称为友元运算符函数。它不是类的成员，在类内声明原型，在类外定义函数本身。由于友元运算符不是类的成员函数，不属于任何一个类对象，所以没有 this 指针。因此重载双目运算符时要与 2 个参数，重载单目运算符时要一个参数。友元运算符函数在类内声明的一般形式为： friend 返回类型 operator 运算符 ( 参数表 ) 在类外定义的一般形式为： 返回类型 operator 运算符 ( 参数表 ) { 函数体 } 3.2.1 双目运算符重载为友元函数 双目运算符重载为友元函数时，由于没有 this 指针，所以两个操作数都要通过友元运算符函数的参数指出。与运算符重载为类的成员函数类似，双目运算符重载为友元函数后，调用也有显式和隐式两种方法。 （1） 显式调用： operator 运算符号（参数 1 ，参数 2 ），如 operator+(a,b); （2） 隐式调用，如 a+b; #includeiostream using namespace std; class A { public: A(int x = 0, int y = 0):a(x),b(y){} int geta() { return a; } int getb() { return b; } friend A operator+(A p, A q); private: int a, b; }; A operator+(A p, A q) { A temp; temp.a = p.a + q.a; temp.b = p.b + q.b; return temp; } int main() { A ob1(1, 2), ob2(3, 4), ob3, ob4; ob3 = ob1 + ob2; ob4 = operator+(ob1, ob2); cout "ob3.a= " ob3.geta() endl; cout "ob4.a= " ob4.geta() endl; system("pause"); return 0; } 因为友元运算符函数不属于某一个类，在类外定义友元函数不需要加类名和域运算符。双目运算符重载为友元函数和双目运算符重载为成员函数的根本区别在于其操作数的个数不同，前者需要指定 2 个参数，而后者定义时只需要一个参数。 3.2.2 单目运算符重载为友元函数 与单目运算符重载为成员函数不同，单目运算符重载为友元函数时，由于没有 this 指针，所以操作数要通过友元运算符函数的参数指出。调用也分为显式和隐式两种。 （1） 显式： operator 运算符号 ( 参数 ), 如 operator++(a); （2） 隐式：对象名 重载的运算符号 对象名 , 如 ++a; #includeiostream using namespace std; class A { public: A(int x=0):n(x){} int getn() { return n; } friend A operator++(A a); private: int n; }; A operator++(A a) { ++a.n; return a; } int main() { A ob(3); cout "ob.n=" ob.getn() endl; ++ob; cout "ob.n=" ob.getn() endl; operator++(ob); cout "ob.n=" ob.getn() endl; system("pause"); return 0; } 在将运算符重载为友元函数时，除运算符 = () [] - 不能用友元函数重载外，其余运算符都可以重载。此外，使用友元函数重载单目运算符“ ++ ”和“ -- ”时，由于要改变数自身的值，所以应采用引用参数传递操作数，否则会出现错误。 4. 运算符成员函数与友元运算符函数比较 （ 1 ）对于双目运算符，运算符成员函数是类的成员，带有 this 指针，只需 1 个参数；而友元运算符函数不是类的成员，不带 this 指针，参数必须是 2 个。对于单目运算符，成员运算符函数不带参数，而友元运算符函数必须带 1 个参数； （ 2 ）双目运算符可被重载为友元函数，也可以重载为成员函数，但在运算符的左操作数是一个标准数据类型而右操作数是对象的情况下，必须将它重载为友元函数，原因是标准数据类型的数据不能产生对重载运算符的调用； （ 3 ）运算符成员函数与友元运算符函数都可以显式和隐式方式调用； 总的来说，将运算符重载为成员函数或是友元函数，要根据实际情况和使用习惯决定。一般而言，对于双目运算符重载为友元函数较好，若运算符的操作数特别是左操作数需要进行类型转换，必须重载为友元运算符函数。若一个运算符需要修改对象的状态，则选择运算符成员函数较好。

抽象类是一种特殊的类，它提供了统一的操作界面。建立抽象类是为了多态地使用抽象类的成员函数。抽象类是包含纯虚函数的类。 1. 纯虚函数 当在基类中不能为虚函数给出一个有意义的实现时，可以将其声明为纯虚函数。纯虚函数的实现可以留给派生类完成。纯虚函数的作用是为派生类提供一个一致的接口。一般来说，一个抽象类带有至少一个纯虚函数。 纯虚函数的定义形式： virtual 函数类型 函数名 ( 参数表 )=0 纯虚函数与普通函数定义的不同在于书写形式上加了“ =0 ”，说明在基类中不用定义该函数的函数体，它并不表示函数返回值为 0 ，只起形式上的作用。 #includeiostream using namespace std; class Point { protected: int x0, y0; public: Point(int i = 0, int j = 0) { x0 = i; y0 = j; } virtual void set() = 0; virtual void draw() = 0; }; class Line :public Point { protected: int x1, y1; public: Line(int i = 0, int j = 0, int m = 0, int n = 0) :Point(i, j) { x1 = m; y1 = n; } void set() { cout "Line::set() called " endl; } void draw() { cout "Line::draw() calles " endl; } }; class Ellipse :public Point { public: Ellipse(int i = 0, int j = 0, int p = 0, int q = 0) :Point(i, j) { x2 = p; y2 = q; } void set() { cout "Ellipse::set() called "; } void draw() { cout "Ellipse::draw() called "; } protected: int x2, y2; }; void drawobj(Point *p) { p-draw(); } void setobj(Point *p) { p-set(); } int main() { Line *lineobj = new Line; Ellipse *elliobj = new Ellipse; drawobj(lineobj); drawobj(elliobj); cout endl; setobj(lineobj); setobj(elliobj); cout "\n Redraw the obj...\n"; drawobj(lineobj); drawobj(elliobj); system("pause"); return 0; } 类 Line 和 Ellipse 都有公有继承自类 Point ，该程序要实现多态，就必须定义 set() 和 draw() 函数为虚函数 2. 抽象类 包含纯虚函数的类称为抽象类。抽象类是一种特殊的类，是为了抽象和设计的目的建立的，处于继承层次结构的较上层。抽象类是不能创建对象的，在实际中强调一个类是抽象类，可以将该类的构造函数声明为保护的访问控制权限。 抽象类的主要作用是将有关的类组织在一个继承层次结构中，由抽象类为他们提供一个公共的根，相关的子类是从这个根派生出来的。抽象类刻画了一组子类的操作接口的通用语义，这些语义也传给子类。一般而言，抽象类只描述这组子类的共同的操作接口，而完整的实现留给子类。 使用抽象类要注意的问题： (1)抽象类只能做其他类的基类，不能创建抽象类的对象，因为它的纯虚函数没有定义功能； (2)抽象类不能用作参数类型、函数的返回值或者显式转换类型； (3)可以声明抽象类的对象指针或对象引用，从而可以访问派生类对象成员，实现动态联编； (4)若派生类中没有给出抽象类的所有纯虚函数的函数体，派生类仍然是一个抽象类；

1. 多态 多态是人类思维方式的一种直接模拟，多态性是指不同对象接收到相同的消息时，根据对象类的不同而产生不同的动作。多态性提供了同一个接口可以用多种方法进行调用的机制，从而可以通过相同的接口访问不同的函数。就是同一个函数名称，作用在不同的对象上将产生不同的行为。 多态从实现的角度来讲可以划分为两类：编译时的多态和运行时的多态。前者是在编译过程中确定了同名操作的具体操作对象，而后者是在程序运行过程中才动态地确定操作所针对的具体对象。这种确定操作的具体对象过程就是联编。联编是指计算机程序自身彼此关联的过程，即把一个标识符名和一个存储地址联系在一起的过程。在面向对象上来讲，就是把一条消息和一个对象的方法结合起来的过程。按照联编进行阶段的不同，分为：静态联编和动态联编，它们分别对应着多态的两种实现方式。 1.1 多态的引入 #includeiostream using namespace std; class Animal { public: void sleep() { cout "Animal sleep...." endl; } void breath() { cout "Animal breath..." endl; } }; class Fish:public Animal { void breath() { cout "Fish breath...." endl; } }; int main() { Fish fh; Animal *an = fh; an-breath(); system("pause"); return 0; } 在上述代码中，主函数定义了一个 Fish 类的对象 fh, 接着定义了一个指向 Animal 类的指针变量 an ，将 fh 的地址赋给了指针变量 an ，然后利用该变量调用 breath() 。这种情况很容易和 C++ 的多态性混淆 ,fh 是 Fish 类的对象，应该调用 Fish 的 breath() ，但是结果却不是这样的。 这是因为 C++ 编译器在编译的时候，要确定每个对象调用的函数地址，这称为早期绑定。当 Fish 类的对象 fh 的地址赋给 an 时， C++ 编译器进行了类型转换，编译器认为变量 an 保存的就是 Animal 对象的地址。所以在主函数调用的是 Animal 对象的 breath() 函数。此时， Fish 创建的对象 fh 在内存中的存储如下图所示。 在构造 Fish 类的对象时，系统首先要调用 Animal 的构造函数去构造 Animal 类的对象，然后才调用 Fish 类的构造函数完成自身部分的构造。因此，当将 Fish 类的对象转换为 Animal 类型时，该对象就被认为是原对象整个内存模型的上半部分，也就是图中“ Animal 的对象所占的内存”。当利用类型转换完成后的对象指针去调用它的方法时，是调用它所在的内存中的方法。 2 ．函数重载 由静态联编支持的多态性称为编译时的多态性或静态多态性，也就是说，确定同名操作的具体对象的过程是在编译过程中完成的。可以用函数重载和运算符重载来实现编译时的多态性。 函数重载也称为多态函数，是实现编译时的多态性的形式之一。函数重载时，函数名相同，但是函数所带的参数个数或数据类型不同。函数重载分为两种情况： 参数个数或类型有所差别的重载； 函数的参数完全相同但属于不同的类； 当函数的参数完全相同但属于不同的类时，为了让编译器正确区分调用哪个类的同名函数，可以采用以下两种方法： 用对象名区别：在函数名前面加上对象名来限制； 用类名和作用域运算符加以区别； 3. 虚函数 由动态联编支持的多态性称为运行时的多态性或者动态多态性，也就是说同名操作的具体操作对象的过程是在运行过程中完成的。在 C++ 中，可以用虚函数来实现运行时的多态。虚函数是实现运行时多态的一个重要方式，是重载的另一种形式，实现的是动态重载，即函数调用与函数体之间的联系是在运行时建立的，也就是动态联编。 #includeiostream using namespace std; class Animal { public: void sleep() { cout "Animal sleep...." endl; } virtual void breath() { cout "Animal breath..." endl; } }; class Fish:public Animal { void breath() { cout "Fish breath...." endl; } }; int main() { Fish fh; Animal *an = fh; an-breath(); system("pause"); return 0; } 实事上，当将基类中的成员函数 breath() 声明为虚函数时，编译器在编译的时候发现 Animal 类中有虚函数，此时编译器会为每个包含虚函数的类创建一个虚表，该表是一个一维数组，在这个数组中存放每个虚函数的地址。上述代码中 Animal 类和 Fish 类都包含了一个虚函数 breath() ，因此编译器会为这两个类分别建立一个虚表。 当 Fish 类的 fh 对象构造完成后，其内部的虚表指针也就被初始化为指向 Fish 类的虚表。在类型转换后，调用 an-breath() ，由于 an 实际上指向的是 Fish 类的对象，该对象内部的虚表指针指向的是 Fish 类的虚表，因此最终调用的是 Fish 类的 breath() 函数。 下边说明使用派生类对象指针时应注意的问题： （1）声明为指向基类对象的指针可以指向它的公有派生类的对象，但不允许指向它的私有派生类的对象； （2）允许声明为指向基类对象的指针指向它的公有派生类的对象，但不允许将一个声明为指向派生类对象的指针指向基类的对象； （3）声明为指向基类对象的指针，当其指向它的公有派生类对象时，只能直接访问派生类中从基类继承下来的成员，不能直接访问公有派生类中定义的成员。要想访问，可以将基类指针用显式类型转换方式转换为派生类指针。 虚函数可以很好地实现多态，使用时要注意以下的问题： （1）虚函数的声明只能出现在类函数原型的声明中，不能出现在函数体实现的时候，而且基类中只有保护成员或公有成员才能被声明为虚函数； （2）在派生类中重新定义虚函数时，关键字 virtual 可以写可以不写，但是在容易引起混乱的地方，应该写上关键字； （3）动态联编只能通过成员函数来调用或通过指针、引用来访问虚函数，如果以对象名的形式来访问虚函数，将采用静态联编。 在派生类中重新定义基类中的虚函数，是函数重载的另一种形式，但是它与函数重载有如下区别： （1）一般的函数重载，要求其函数的参数或参数类型必须有所不同，函数的返回类型也可以不同； （2）重载一个虚函数时，要求函数名、返回类型、参数个数、参数类型和参数的顺序必须与基类中的虚函数的原型完全相同； （3）如果仅返回类型不同，其余相同，则系统会给出错误的信息； （4）如果函数名相同，而参数个数、参数的类型或者参数顺序不同，系统认为是普通的函数重载，虚函数的特性将被丢失。 3.1 多级继承和虚函数 多级继承可以看作是多个单继承的组合，多级继承的虚函数与单继承的虚函数的调用相同，一个虚函数无论被继承多少次，仍保持其虚函数的特性，与继承的次数无关。 #includeiostream using namespace std; class Base { public: virtual ~Base() {}; virtual void func() { cout "Base func..." endl; } }; class Derived1 :public Base { public: void func() { cout "Derived1 func..." endl; } }; class Derived2 :public Derived1 { public: void func() { cout "Derived2 func..." endl; } }; void test(Base b) { b.func(); } int main() { Base bobj; Derived1 d1Obj; Derived2 d2Obj; test(bobj); test(d1Obj); test(d2Obj); system("pause"); return 0; } 在上述代码中，定义了一个多级继承，在基类中定义了虚函数 func() ，在主函数调用该函数时，不同类创建的对象其调用的函数是不同的，即实现了多态“一个接口，多种实现”的功能。上述代码中在析构函数前加上关键字 virtual 进行说明，则该析构函数就称为虚析构函数。 使用虚析构函数时，要注意以下两点： （1）只要基类的析构函数被声明为虚析构函数，则派生类的析构函数无论是否使用 virtual 关键字进行声明，都自动成为虚函数； （2）如果基类的析构函数为虚函数，则当派生类未定义析构函数时，编译器所生成的析构函数也为虚函数； 一般来说，在程序中最好把基类的析构函数声明为虚函数。这将使所有派生类的析构函数自动成为虚函数 。这样，如果程序中用 delete 运算符准备删除一个对象，而 delete 运算符的操作对象是指向派生类对象的基类指针，系统会调用相应类的析构函数；否则系统会只执行基类的析构函数，而不执行派生类的析构函数，从而可能导致异常发生。 所以专业的编程人员一般习惯声明虚析构函数，即使基类不需要虚析构函数，也显式地定义一个函数体为空的虚析构函数，以保证在撤销动态存储空间时能得到正确的处理。 构造函数不能声明为虚函数，这是因为在执行构造函数时类对象还未完全建立过程，当然谈不上函数与类对象的关联。