C++ 如何访问子实例 #包括 班级家长 { 公众： 父项（） { } }; 类子：公共父类 { 公众： child（） { } }; 班主任 { 公众： 无效视图（父视图a） { printf（“查看父实例”）； } 无效视图（子视图b） { printf（“查看子实例”）； } }; int main（） { 家长*ptr； 我的主人； ptr=新生儿； mymaster.view（*ptr）； 返回0； }

输出：“查看父实例” 我从父类创建指针。然后我将指针声明为子类型。当我运行mymaster.view（*ptr），这总是转到第一个视图函数（无效视图（父级a）），如何使其转到（无效视图（子级b））。谢谢

类型

*（parent*）

是

parent

，因此调用的方法是

查看（parent）

。如果要调用

视图（子项）

，则需要在传入前将指针强制转换为

子项*

您正在反向使用OOP。您不需要定义多个方法来了解如何使用每种特定类型的子类，您只需要定义一个方法来遵守父类提供的契约，子类在内部做自己的事情。

类型

*（父类*）

是

父类

，因此被调用的方法是

视图（父类）

。如果要调用

视图（子项）

，则需要在传入前将指针强制转换为

子项*

---

您正在反向使用OOP。您没有定义多个知道如何使用每种特定类型的子类的方法，而是定义了一个可以遵守父类提供的契约的方法，子类在内部做自己的事情。

ptr

是指向父对象的指针。 如果要调用

视图（子）

函数，需要将

子对象传递给函数调用

或者，您可以将其强制转换为
子对象
指针

#include<stdio.h>

class parent
{
public:
    parent()
    {
    }
};

class child : public parent
{
public:
    child()
    {
    }
};

class master
{
public:
    void view(parent a)
    {
        printf("view parent instances");
    }
    void view(child b)
    {
        printf("view child instances");
    }
};

int main()
{
    parent *ptr;
    master mymaster;

    ptr = new child;

    mymaster.view(*ptr);

    return 0;
}

但是您可能会遇到各种其他问题。
ptr
是指向父对象的指针。
如果要调用
视图（子）
函数，需要将
子对象传递给函数调用

或者，您可以将其强制转换为
子对象
指针

#include<stdio.h>

class parent
{
public:
    parent()
    {
    }
};

class child : public parent
{
public:
    child()
    {
    }
};

class master
{
public:
    void view(parent a)
    {
        printf("view parent instances");
    }
    void view(child b)
    {
        printf("view child instances");
    }
};

int main()
{
    parent *ptr;
    master mymaster;

    ptr = new child;

    mymaster.view(*ptr);

    return 0;
}

但是，您可能会遇到各种其他问题。
编译器根据最佳选择决定匹配方法

编译器发现变量的类型为
parent
，因此调用匹配方法。
编译器根据最佳选择决定匹配方法

编译器发现变量的类型为
parent
，因此它调用匹配方法。
通过一点重构和稍微不同的方法，您可以使用
virtual
函数。这使派生类中的函数能够在使用如下指针调用时使用

mymaster.view(*(child*)ptr);

#包括
班级家长
{
公众：
父项（）
{
}
虚拟void视图（）
{
printf（“查看父项”）；
}
};
类子：公共父类
{
公众：
child（）
{
}
虚拟void视图（）
{
printf（“查看子项”）；
}
};
班主任
{
公众：
无效视图（父*a）
{
a->view（）；
}
};
int main（）
{
家长*ptr；
我的主人；
ptr=新生儿；
mymaster.view（ptr）；
返回0；
}

这将输出“查看子对象”。没有
virtual
关键字的相同代码将输出“查看父项”。请注意，关键字只需要在父类中，但为了清晰起见，也经常在派生类中使用

on virtual函数很好地解释了这种情况：

虚拟函数“延迟”解析。如果所讨论的函数是
基类中的“virtual”，最派生类的实现
根据对象的实际类型调用函数的
引用，而不管声明的指针类型或
参考资料。如果它不是“虚拟的”，则该方法将“早期”解决，并且
调用的函数是根据声明的
指针或引用

由于此处对象的实际类型是子对象，因此虚拟函数确保调用子对象的功能，即使指针是父对象。
通过一些重构和稍微不同的方法，您可以使用
虚拟
函数。这使派生类中的函数能够在使用如下指针调用时使用

mymaster.view(*(child*)ptr);

#包括
班级家长
{
公众：
父项（）
{
}
虚拟void视图（）
{
printf（“查看父项”）；
}
};
类子：公共父类
{
公众：
child（）
{
}
虚拟void视图（）
{
printf（“查看子项”）；
}
};
班主任
{
公众：
无效视图（父*a）
{
a->view（）；
}
};
int main（）
{
家长*ptr；
我的主人；
ptr=新生儿；
mymaster.view（ptr）；
返回0；
}

这将输出“查看子对象”。没有
virtual
关键字的相同代码将输出“查看父项”。请注意，关键字只需要在父类中，但为了清晰起见，也经常在派生类中使用

on virtual函数很好地解释了这种情况：

虚拟函数“延迟”解析。如果所讨论的函数是
基类中的“virtual”，最派生类的实现
根据对象的实际类型调用函数的
引用，而不管声明的指针类型或
参考资料。如果它不是“虚拟的”，则该方法将“早期”解决，并且
调用的函数是根据声明的
指针或引用

由于此处对象的实际类型是子对象，因此v