1.把子类对象作为父类对象使用：
1.1 前提：继承方式必须公有。
1.2 将子类对象用作父类对象。
1.2.1 将子类对象赋值给父类对象。
1.2.2 将父类引用指向子类对象。（即用派生类对象初始化基类引用）
1 #include <iostream>
2 using namespace std;
3
4 class Base{
5 public:
6 Base(){}
7 Base(int b):_b(b){}
8 void func(){cout<<"b:"<<_b<<endl;}
9 Base& fun(Base& b);
10 protected:
11 int _b;
12
13 };
14 class Derived:public Base{
15 public:
16 Derived(){}
17 Derived(int d,int b):_d(d),Base(b){}
18 void func();
19 // void func(){cout<<"d:"<<_d<<" b:"<<_b<<endl;}
20 protected:
21 int _d;
22 };
23 void Derived::func(){cout<<"d:"<<_d<<" b:"<<_b<<endl;}
24 Base& fun(Base& b){Derived* p=new Derived;return *p;}
25 Base* fun(Base* b){Derived* p=new Derived;return b;}
26
27 int main(int argc, const char * argv[]) {
28
29 //----------------------------------------------------------------------------
30 //----------------------------------------------------------------------------
31 //1.将派生类对象赋值给基类对象。赋值完成后，等号左边的对象，依然是父类对象。
32 Derived d(4,5);
33 Base b;
34 b=d;
35 d.func();
36 //----------------------------------------------------------------------------
37 //----------------------------------------------------------------------------
38 //2.基类引用指派生类
39 //(1).派生类对象用于初始化基类引用。
40 // Derived d(4,5);
41 // Base& b=d;
42 // b.func();
43 // d.func();
44 //----------------------------------------------------------------------------
45 //----------------------------------------------------------------------------
46 //(2).派生类对象被传递给一个函数，接受基类对象的引用。
47 // Derived d;
48 // Base& b=fun(d);
49 // delete &b;
50 //----------------------------------------------------------------------------
51 //----------------------------------------------------------------------------
52 //(3).派生类从返回类型的函数返回基类引用。
53 // Derived d;
54 // Base& b=fun(d);
55 // delete &b;
56 //----------------------------------------------------------------------------
57 //----------------------------------------------------------------------------
58 //3.基类指针指派生类。
59 //(1).派生类对象的地址分配给基类指针。
60 // Derived d(1,4);
61 // Base* b=&d;
62 // d.func();
63 // b->func();
64 //----------------------------------------------------------------------------
65 //----------------------------------------------------------------------------
66 //(2).派生类指针被分配给基类指针。
67 // Derived d(1,4);
68 // Derived * d2=&d;
69 // Base* b2=d2;
70 // b2->func();
71 //----------------------------------------------------------------------------
72 //----------------------------------------------------------------------------
73 //(3).派生类对象的地址传递给接受基类对象的指针的函数。
74 // Derived d(1,3);
75 // Base* b=fun(&d);
76 // b->func();
77 // delete b;
78 //----------------------------------------------------------------------------
79 //----------------------------------------------------------------------------
80 //当父类指针指向子类对象时，不能通过父类调用子类扩展函数。
81 //另一方面，基类对象不能用作派生类对象。
82 return 0;
83 }
2. 基类指针指向派生类
3. 向下类型转换：将基类的指针或者引用转化为派生类的指针和引用。
实现形式：强转。
目的：通过基类指针或者引用访问到派生类的成员
Point* p=&c;//指针p”指向”的对象”真实身份”为派生类
Point& q=c;//基类引用q”指向”的对象”真实身份”为派生类。
((Circle*)p)->print();
((Circle&)p).print();//向下类需转换
问题：
Point* p=&pp;//pp为基类对象，指针p“指向”的对象“真实身份”基类。((Circle*)p)->print();
有可能出现的问题，输出结果不正确。
向下类型转换不会出现问题：基类指针或者引用“指向”的对象，“真 实身份”为派生类。
1 //#include <iostream>
2 //using namespace std;
3 ////如果一个基类指针指向派生类对象，它可以进行类型转换来访问派生类的成员。这就是所谓的向下转型。然而向下转型是一件危险的做法，因为基类指针可能不实际指向一个对象在派生类，然后程序员任务它是。
4 //class Base{
5 //public:
6 // Base(){}
7 // Base(int _b):b(_b){}
8 //protected:
9 // int b;
10 //};
11 //class Derived:public Base{
12 //public:
13 // Derived(){}
14 // Derived(int _d,int _b):d(_d),Base(_b){}
15 // void func();
16 //protected:
17 // int d;
18 //};
19 //void Derived::func(){cout<<"d:"<<d<<" b:"<<b<<endl;}
20 //
21 //int main(int argc, const char * argv[]) {
22 // Derived(3,4);
23 // Base* b=new Derived;
24 // //b->func(); //不可以
25 // ((Derived*)b)->func();//可以
26 // return 0;
27 //}
28 #include <iostream>
29 using namespace std;
30
31 class Base{
32 public:
33 Base(){}
34 Base(int _b):b(_b){}
35 void func(){cout<<"Base class function..."<<endl;}
36 protected:
37 int b;
38 };
39
40 class Derived:public Base{
41 public:
42 Derived(){}
43 Derived(int _d,int _b):d(_d),Base(_b){}
44 void func(){cout<<"Derived class function..."<<endl;}
45 protected:
46 int d;
47 };
48
49 void foo(Base& b){b.func();}//Base class function...
50 int main(int argc, const char * argv[]) {
51 Derived d;
52 Base b;
53 Base* p=&d;
54 Base& br=d;
55 b=d;
56 b.func();//Base class function...
57 d.func();//Derived class function...
58 p->func();//Base class function...
59 foo(br);
60 br.func();//Base class function...
61 return 0;
62 }
子类构造：
Base声明：
#include <stdio.h>
#include "iostream"
#include "cstring"
using namespace std;
class Base{
public:
Base(int a=0,char* s=(char*)""):id(a) {
if (!s) {
name=NULL;
}else{
name=new char[strlen(s)+1];
strcpy(name, s);
}
cout<<"基类默认构造函数"<<endl;
}
Base(Base& b){
id=b.id;
if (!b.name) {
delete [] name;
name=NULL;
}
else{
name=new char[strlen(b.name)+1];
strcpy(name, b.name);
}
cout<<"基类拷贝构造"<<endl;
}
~Base(){
if (name!=NULL) {
delete [] name;
name=NULL;
}
cout<<"基类析构"<<endl;
}
Base& operator=(Base&);
friend ostream& operator<<(ostream& out,Base&);
protected:
int id;
char* name;
};
Base实现：
1 #include "Base.hpp"
2 Base& Base::operator=(Base& b){
3 if (this!=&b) {
4 id=b.id;
5 delete [] name;
6 if (!b.name) {
7 name=NULL;
8 }else{
9 name=new char[strlen(b.name)+1];
10 strcpy(name, b.name);
11 }
12 }
13 cout<<"基类赋值重载"<<endl;
14 return *this;
15 }
16 ostream& operator<<(ostream& out,Base& b){
17 out<<"Base id:"<<b.id<<endl;
18 return out;
19 }
Derived声明：
1 #include <stdio.h>
2 #include "Base.hpp"
3 #include "cstring"
4 #include "iostream"
5 using namespace std;
6 class Derived:public Base{
7 public:
8 Derived(int a=0,char* s=(char*)"",float x=0,char* t=(char*)""):Base(a,s),f(x){
9 if (!t) {
10 label=NULL;
11 }else{
12 label=new char[strlen(t)+1];
13 strcpy(label, t);
14 }
15 cout<<"派生类拷贝构造"<<endl;
16 }
17 ~Derived(){
18 // delete [] label;
19 cout<<"派生类析构"<<endl;
20 }
21 Derived& operator=(Derived&);
22 friend ostream& operator<<(ostream& out,Derived&);
23 private:
24 float f;
25 char* label;
26 };
Derived实现：
1 #include "Derived.hpp"
2 Derived& Derived::operator=(Derived& d){
3 if (this!=&d) {
4 delete [] label;
5 label=NULL;
6 Base::operator=(d);
7 f=d.f;
8 if (!d.label) {
9 label=NULL;
10 }else{
11 label=new char[strlen(d.label)+1];
12 strcpy(label, d.label);
13 }
14 cout<<"派生类赋值重载"<<endl;
15 }
16 return *this;
17 }
18 ostream& operator<<(ostream& out,Derived& d){
19 out<<(Base&)d;
20 out<<"Derived f:"<<d.f<<endl;
21 out<<"Derived label:"<<d.label<<endl;
22 return out;
23 }
main函数：
1 #include <iostream>
2 #include "Base.hpp"
3 #include "Derived.hpp"
4 using namespace std;
5
6 int main(int argc, const char * argv[]) {
7
8 Derived d1;
9 Derived d2(d1);
10 return 0;
11 }
时间： 2024-08-05 19:32:01