집 >백엔드 개발 >C#.Net 튜토리얼 >배워야 한다! C++에서 다형성 메커니즘을 구현하기 위한 기본 조건
배워야 한다! C++에서 다형성 메커니즘을 구현하기 위한 기본 조건
- php是最好的语言원래의
- 2018-07-24 14:11:022206검색
C++의 다형성 메커니즘을 구현하는 방법 실행 다형성을 구현하는 메커니즘은 기본 클래스의 함수 앞에 virtual 키워드를 추가하고 파생 클래스에서 함수를 다시 작성하는 것입니다. 런타임 기능의 개체입니다.
C++ 다형성의 구현 및 원리
C++의 다형성은 한 문장으로 요약할 수 있습니다. 기본 클래스의 함수 앞에 virtual 키워드를 추가하고, 파생 클래스에서 함수를 다시 작성하면 런타임이 기반 클래스가 됩니다. on 해당 함수를 호출할 객체의 실제 유형입니다. 객체 유형이 파생 클래스인 경우 파생 클래스의 함수를 호출하고, 객체 유형이 기본 클래스인 경우 기본 클래스의 함수를 호출합니다.
1: virtual 키워드로 선언된 함수를 가상 함수라고 합니다. , 가상 함수는 클래스 함수의 멤버여야 합니다.
2: 가상 함수가 있는 클래스에는 가상 테이블이라는 1차원 가상 함수 테이블이 있습니다. 클래스의 개체에는 가상 테이블의 시작 부분을 가리키는 가상 포인터가 있습니다. 가상 테이블은 클래스에 해당하고 가상 테이블 포인터는 개체에 해당합니다.
3: 다형성은 인터페이스의 다중 구현이며 객체 지향의 핵심입니다. 클래스 다형성과 함수 다형성으로 구분됩니다.
4: 다형성은 동적 바인딩과 결합된 가상 함수로 구현됩니다.
5: 순수 가상 함수는 가상 함수에 = 0을 더한 것입니다.
6: 추상 클래스는 하나 이상의 순수 가상을 포함하는 클래스를 나타냅니다. 기능.
순수 가상 함수: virtual void fun()=0, 즉 추상 클래스입니다! 이 함수는 하위 클래스에서 구현되어야 합니다. 즉, 이름이 먼저 있고 내용이 없으며 내용이 파생 클래스에서 구현됩니다.
먼저 예제를 살펴보겠습니다
#include <iostream> #include <stdlib.h>using namespace std;
class Father
{public: void Face()
{ cout << "Father's face" << endl;
} void Say()
{ cout << "Father say hello" << endl;
}
};class Son:public Father
{public:
void Say()
{ cout << "Son say hello" << endl;
}
};int main()
{
Son son;
Father *pFather=&son; // 隐式类型转换
pFather->Say(); return 0;
}출력 결과는 다음과 같습니다.
Father say hello
main() 함수에서 먼저 Son 클래스의 객체 son을 정의한 다음 Father 클래스를 가리키는 포인터 변수 pFather를 정의합니다. 그런 다음 이것을 사용하십시오. 변수는 pFather->Say()를 호출합니다. 많은 사람들이 이 상황을 C++의 다형성과 혼동하는 경향이 있는 것으로 추정됩니다. son은 실제로 Son 클래스의 객체이므로 Son의 Say를 호출해야 합니다. 클래스를 생성하고 "Son say hello"”를 출력하지만 결과는 그렇지 않습니다.
컴파일 관점에서:
컴파일할 때 C++ 컴파일러는 각 클래스가 호출하는 함수(비가상 함수)의 주소를 결정해야 합니다. Son 클래스 객체 son의 주소를 pFather에 할당하면 C++ 컴파일러는 이때 변수 pFather가 Father 객체의 주소를 갖고 있다고 생각합니다. 메인 함수에서 pFather->Say(가 실행될 때) 호출되는 것은 당연히 Father 객체의 Say 함수입니다
메모리 관점에서 보면
Son 클래스 객체의 메모리 모델은 다음과 같습니다. 위
Son 클래스의 객체를 생성할 때 먼저 Father 클래스의 생성자를 호출하여 생성해야 합니다. Father 클래스의 객체를 호출한 다음 Son 클래스의 생성자를 호출하여 생성의 자체 부분을 완료합니다. , 이로써 완전한 Son 클래스 객체를 분리합니다. Son 클래스 객체를 Father 타입으로 변환할 때, 그 객체는 위 그림에서 "Father 객체가 점유하고 있는 메모리"인 원래 객체의 전체 메모리 모델 중 상위 절반으로 간주됩니다. 유형 변환 사용 객체 포인터가 해당 메소드를 호출할 때 당연히 해당 메소드가 위치한 메모리에서 메소드를 호출하므로 "Father Say hello"를 출력하는 것이 논리적입니다.
많은 사람들이 생각하는 것처럼 위 코드에서 pFather는 실제로 Son 클래스의 객체를 가리킨다는 것을 알고 있습니다. 따라서 이 결과를 얻으려면 다음을 사용해야 합니다. 가상 기능.
이전 출력 결과는 컴파일 시 객체가 호출한 함수의 주소를 컴파일러가 이미 결정했기 때문입니다. 이 문제를 해결하려면 런타임 바인딩을 사용해야 합니다. 컴파일러가 런타임 바인딩을 사용할 때 실행되는 함수의 유형을 결정합니다. 컴파일러가 런타임에 바인딩을 사용하도록 하려면 기본 클래스에서 함수를 선언할 때 virtual 키워드를 사용해야 합니다. 기본 클래스에서 virtual로 설정되면 함수는 모든 파생 클래스에서 virtual이 되며 명시적으로 virtual로 선언할 필요가 없습니다.
코드를 약간 변경하여 실행 결과를 살펴보세요
#include <iostream> #include <stdlib.h>using namespace std;
class Father
{public: void Face()
{ cout << "Father's face" << endl;
} virtual void Say()
{ cout << "Father say hello" << endl;
}
};class Son:public Father
{public:
void Say()
{ cout << "Son say hello" << endl;
}
};int main()
{
Son son;
Father *pFather=&son; // 隐式类型转换
pFather->Say(); return 0;
}실행 결과:
Son say hello
결과가 "Son say hello"인 것으로 확인되었습니다. 즉, 개체 유형에 따라 올바른 함수가 호출됩니다. , 가상일 때 뒤에서 무슨 일이 일어나는지 Say()를 선언하면 됩니다.
컴파일러는 컴파일 중에 Father 클래스에 가상 함수가 있음을 발견합니다. 이때 컴파일러는 가상 함수를 포함하는 각 클래스에 대해 가상 테이블(즉, vtable)을 생성합니다. 이 배열에는 각 가상 함수의 주소가
那么如何定位虚表呢？编译器另外还为每个对象提供了一个虚表指针(即vptr)，这个指针指向了对象所属类的虚表，在程序运行时，根据对象的类型去初始化vptr，从而让vptr正确的指向了所属类的虚表，从而在调用虚函数的时候，能够找到正确的函数，对于第二段代码程序，由于pFather实际指向的对象类型是Son，因此vptr指向的Son类的vtable，当调用pFather->Son()时，根据虚表中的函数地址找到的就是Son类的Say()函数.
正是由于每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了虚表指针的正确初始化是非常重要的，换句话说，在虚表指针没有正确初始化之前，我们不能够去调用虚函数，那么虚表指针是在什么时候，或者什么地方初始化呢？
答案是在构造函数中进行虚表的创建和虚表指针的初始化，在构造子类对象时，要先调用父类的构造函数，此时编译器只“看到了”父类，并不知道后面是否还有继承者，它初始化父类对象的虚表指针，该虚表指针指向父类的虚表，当执行子类的构造函数时，子类对象的虚表指针被初始化，指向自身的虚表。
总结(基类有虚函数的):
1:每一个类都有虚表
2:虚表可以继承，如果子类没有重写虚函数，那么子类虚表中仍然会有该函数的地址，只不过这个地址指向的是基类的虚函数实现，如果基类有3个虚函数，那么基类的虚表中就有三项(虚函数地址)，派生类也会虚表，至少有三项，如果重写了相应的虚函数，那么虚表中的地址就会改变，指向自身的虚函数实现，如果派生类有自己的虚函数，那么虚表中就会添加该项。
3：派生类的虚表中虚地址的排列顺序和基类的虚表中虚函数地址排列顺序相同。
这就是c++中的多态性，当c++编译器在编译的时候，发现Father类的Say()函数是虚函数，这个时候c++就会采用晚绑定技术，也就是编译时并不确定具体调用的函数，而是在运行时，依据对象的类型来确认调用的是哪一个函数，这种能力就叫做c++的多态性，我们没有在Say()函数前加virtual关键字时，c++编译器就确定了哪个函数被调用，这叫做早期绑定。
c++的多态性就是通过晚绑定技术来实现的。
c++的多态性用一句话概括就是:在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数，如果对象类型是派生类，就调用派生类的函数，如果对象类型是基类，就调用基类的函数。
虚函数是在基类中定义的，目的是不确定它的派生类的具体行为，例如:
定义一个基类:class Animal //动物，它的函数为breathe()
再定义一个类class Fish //鱼。它的函数也为breathe()
再定义一个类class Sheep //羊，它的函数也为breathe()
将Fish，Sheep定义成Animal的派生类，然而Fish与Sheep的breathe不一样，一个是在水中通过水来呼吸，一个是直接呼吸，所以基类不能确定该如何定义breathe，所以在基类中只定义了一个virtual breathe，它是一个空的虚函数，具体的函数在子类中分别定义，程序一般运行时，找到类，如果它有基类，再找到它的基类，最后运行的是基类中的函数，这时，它在基类中找到的是virtual标识的函数，它就会再回到子类中找同名函数，派生类也叫子类，基类也叫父类，这就是虚函数的产生，和类的多态性的体现。
这里的多态性是指类的多态性。
函数的多态性是指一个函数被定义成多个不同参数的函数。当你调用这个函数时，就会调用不同的同名函数。
一般情况下(不涉及虚函数)，当我们用一个指针/引用调用一个函数的时候，被调用的函数是取决于这个指针/引用的类型。
当设计到多态性的时候，采用了虚函数和动态绑定，此时的调用就不会在编译时候确定而是在运行时确定。不在单独考虑指针/引用的类型而是看指针/引用的对象的类型来判断函数的调用，根据对象中虚指针指向的虚表中的函数的地址来确定调用哪个函数
现在我们看一个体现c++多态性的例子，看看输出结果:
#include <iostream> #include <stdlib.h>using namespace std;
class CA
{
public:
void f()
{
cout << "CA f()" << endl;
}
virtual void ff()
{
cout << "CA ff()" << endl;
f();
}
};
class CB : public CA
{
public :
virtual void f()
{
cout << "CB f()" << endl;
}
void ff()
{
cout << "CB ff()" << endl;
f();
CA::ff();
}
};
class CC : public CB
{
public:
virtual void f()
{
cout << "C f()" << endl;
}
};
int main()
{
CB b;
CA *ap = &b;
CC c;
CB &br = c;
CB *bp = &c;
ap->f();
cout << endl;
b.f();
cout << endl;
br.f();
cout << endl;
bp->f();
cout << endl;
ap->ff();
cout << endl;
bp->ff();
cout << endl; return 0;
}输出结果:
CA f()CB f()C f()C f()CB ff()CB f()CA ff()CA f()CB ff()C f()CA ff()CA f()
相关推荐：
C++ 비디오 튜토리얼_무료 C++ 튜토리얼 온라인 학습
위 내용은 배워야 한다! C++에서 다형성 메커니즘을 구현하기 위한 기본 조건의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!