有关父类向子类转换，对象和指针的不同
已知下面代码，则选项中最可能不合理的是：class Car {
public:
Car( ){ /*略*/ }
void doFunc( ) { /*略*/ };
//其它略
};
class MTCar:public Car {
public:
MTCar( ){ /*略*/ }
void newFunc( ) { /*略*/ }
//其它略
};
class Foo {
public:
Foo(Car * pobj=nullptr):mp(pobj){ }
void func(Car & obj){
obj.doFunc( );
}
private:
Car * mp;
//其它略
};
D.
Car c;
MTCar* pmc=(MTCar*)(&c);
F.
MTCar mc;
Car c;
mc=c;
其它选项已经排除，请问如何分辨D与F？都是父类向子类转换，D中用指针转换，F中用对象赋值（转换）
答案给的是D，但是我发现F连编译都过不了
很有疑问，请求帮助 儿子继承爸爸，儿子是儿子，爸爸是爸爸，是两个不同的人啊。
一个是 MTCar，另一个是 Car 傻眼貓咪 发表于 2022-4-24 18:48
儿子继承爸爸，儿子是儿子，爸爸是爸爸，是两个不同的人啊。
一个是 MTCar，另一个是 Car
不是 子类向父类 向上转换是完全没问题的
这里讨论 父类向子类转换 对象和指针的两种情况
你这答非所问啊{:5_96:} GeraldIAD 发表于 2022-4-24 21:04
不是 子类向父类 向上转换是完全没问题的
这里讨论 父类向子类转换 对象和指针的两种情况
你这答非所问 ...
显然，两个都是错误的，但是D要比F错的更离谱
对于F，只要添加一个函数，一个 operator= 函数，就是对的
但是对于D，一个子类里面有一个完整的父类，但是一个父类里面可没有包含子类
把父类的指针转换成子类的指针，错的要比F少写了一个函数更离谱
这种题目没意思，错就错了，还要在错误中比较出一个 ‘最’ 来，没意思
class Car {
public:
Car( ){ /*略*/ }
void doFunc( ) { /*略*/ };
//其它略
};
class MTCar:public Car {
public:
MTCar( ){ /*略*/ }
void newFunc( ) { /*略*/ }
//其它略
const MTCar operator=(const Car &c) {
return MTCar();
}
};
class Foo {
public:
Foo(Car * pobj=nullptr):mp(pobj){ }
void func(Car & obj){
obj.doFunc( );
}
private:
Car * mp;
//其它略
};
int main() {
MTCar mc;
Car c;
mc = c;
return 0;
}
这里写的 “ //其它略”
也就是说他把 operator= 函数略了 ?
本帖最后由 傻眼貓咪 于 2022-4-24 22:02 编辑
GeraldIAD 发表于 2022-4-24 21:04
不是 子类向父类 向上转换是完全没问题的
这里讨论 父类向子类转换 对象和指针的两种情况
你这答非所问 ...
既然你已经非常清楚答案了，那为什么需要问呢？你的解答已经是答案了啊。
#include <iostream>
class Car {
public:
Car() { /*略*/ }
void doFunc() { /*略*/ };
//其它略
};
class MTCar :public Car {
public:
MTCar() { /*略*/ }
void newFunc() { /*略*/ }
//其它略
};
class Foo {
public:
Foo(Car* pobj = nullptr) :mp(pobj) { }
void func(Car& obj) {
obj.doFunc();
}
private:
Car* mp;
//其它略
};
int main() {
MTCar mc;
Car c;
// mc = c;
c = mc; // <----------- 注意这里 -----------
return 0;
} 傻眼貓咪 发表于 2022-4-24 22:00
既然你已经非常清楚答案了，那为什么需要问呢？你的解答已经是答案了啊。
emm不是不是 我之前没懂
看四楼才明白
页:
[1]