C++多态与this指针问题

Posted 2023-04-29

#include <iostream>
using namespace std;
class animal

public:
animal();
virtual void show();
*ptclass;

class fish:public animal

public:
void show();
*prclass;

animal::animal()

ptclass=this;//这里的this指针到底是指向基类对象还是子类对象？为什么在主函数用ptclass->show得出的结果是animal?那根据多态不就意味着this指向的是子类对象
this->show();//那既然this指向的是子类对象，为什么直接用this->show输出结果是animal？好矛盾


void animal::show()

cout<<"animal"<<endl;


void fish::show()

cout<<"fish"<<endl;

fish f;
int main()

ptclass->show();
return 0;

程序输出结果为animal
fish

参考技术A 这里有一个知识点：
在类的构造函数中，调用虚函数，则该函数将失去虚函数的特性。
你在 animal类的构造函数中调用 show 函数，虽然show是虚函数，但因为是在构造函数中调用，所以失去了虚函数的特性，等价于 animal::show()。

为什么在构造函数内调用虚函数，会失去虚函数的特性？
原因是由虚函数的工作原理造成的。

调用虚函数，首先根据虚函数表查询到对应的函数地址，然后再调用。
而虚函数表指针，是在类型的构造函数进入时完成的。
根据构造函数执行的顺序，基类先构造，然后是派生类。
也就是说，基类的构造函数执行时，虚函数表指针 可能 并没有被正确的设置。追问

那此时我构造函数中的this是指向子类的咯？

追答

this 指针 永远指向本类的对象..

通过this指针，在非构造/析构函数内，调用虚函数时，取决于对象的虚函数表指针。

追问

不对吧，如果this永远指向本类对象，那么我的main函数中的ptclass->show();不可能会输出fish 的啊！！按你的说法animal 的构造函数中ptclass=this（按你的说法这个this此时指向的是animal），那么在main函数中那不就应该输出animal了？

追答

this 指针是 在成员函数内部才有的.. 

this指针永远指向本类的对象，通过this指针，在非构造/析构函数内调用虚函数时，取决于对象的虚函数表指针。

给你一段代码，希望对你有帮助

#include <stdio.h>
class A 
public:
virtual void func_a() 
int m_data;
;
class B 
public:
virtual void func_b() 
printf("B: address of this 0x%p\\n", this);

;
class C : public A, public B 
public:
virtual void func_b() 
B::func_b();
printf("C: address of this 0x%p\\n", this);

;
int main() 
C *pc = new C();
printf("pc 0x%p\\n", pc);
B *pb = pc;
printf("pb 0x%p\\n", pb);
pb->func_b();
delete pc;

$ clang -o test test.cpp -lc++

$ ./test

pc 0x0x7fcc52c03930

pb 0x0x7fcc52c03940

B: address of this 0x0x7fcc52c03940

C: address of this 0x0x7fcc52c03930

追问

你就回答我上面提的问题哪里错了嘛，这样我还是不能信服啊

参考技术B 构造和析构的时候this指针是父类的，其它时候是子类的。这是因为构造时子类还没构造出来，析构的时候子类已经没有了。本回答被提问者采纳

C++中继承与多态

C++中的继承与多态是比较重要的一点，大致来讲解一下继承与多态的特点。继承是子类运用基类的成员以及成员函数，继承的方式分为public,protected以及private，今天主要讲解的是多态，多态是基类函数必有virtual。且是父类的指针指向子类的对象，例如：

#include <iostream>

#include <string>

using namespace std;

//

class A

{

public:

A()

{

cout << "A()" << endl;

}

~A()

{

cout << "~A()" << endl;

}

virtual void fun1()

{

cout << "A::fun1()" << endl;

}

virtual void fun2()

{

cout << "A::fun2()" << endl;

}

int a;

};

class A1:public A

{

public:

A1()

{

cout << "A1()" << endl;

}

~A1()

{

cout << "~A1()" << endl;

}

virtual void fun1()

{

cout << "A1::fun1()" << endl;

}

void fun2()

{

cout << "A1::fun2()" << endl;

}

int a1;

};

void show(A *pb)

{

pb->fun1();

}

int main()

{

A a;

A1 a1;

show(&a1);

/*a1.fun1();*/

/*cout << sizeof(a1) <<endl;*/

getchar();

return 0;

}

show 函数中调用父类的指针将会产生父类的函数，调用子类的指针就将会产生子类的函数，这就是多态。

本文出自 “局部和static变量” 博客，请务必保留此出处http://10810512.blog.51cto.com/10800512/1754279