[已解决]有关父类向子类转换，对象和指针的不同

GeraldIAD

已知下面代码，则选项中最可能不合理的是：
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连编译都过不了
很有疑问，请求帮助

最佳答案

月排行榜 / 总排行榜

人造人

2022-4-24 21:27:17

GeraldIAD 发表于 2022-4-24 21:04
不是 子类向父类 向上转换是完全没问题的
这里讨论 父类向子类转换 对象和指针的两种情况
你这答非所问 ...

显然，两个都是错误的，但是D要比F错的更离谱
对于F，只要添加一个函数，一个 operator= 函数，就是对的
但是对于D，一个子类里面有一个完整的父类，但是一个父类里面可没有包含子类
把父类的指针转换成子类的指针，错的要比F少写了一个函数更离谱

这种题目没意思，错就错了，还要在错误中比较出一个 ‘最’ 来，没意思

1. class Car {
   
2. public:
   
3.    Car( ){ /*略*/ }
   
4.    void doFunc( ) { /*略*/ };   
   
5.    //其它略
   
6. };
   
7. class MTCar:public Car {
   
8. public:
   
9.    MTCar( ){ /*略*/ }
   
10.    void newFunc( ) { /*略*/ }
    
11.    //其它略
    
12.    const MTCar operator=(const Car &c) {
    
13.        return MTCar();
    
14.    }
    
15. };
    
16. class Foo {
    
17. public:
    
18.    Foo(Car * pobj=nullptr):mp(pobj){ }
    
19.    void func(Car & obj){
    
20.       obj.doFunc( );
    
21.    }
    
22. private:
    
23.    Car * mp;
    
24.    //其它略
    
25. };
    
26. 
    
27. int main() {
    
28.     MTCar mc;
    
29.     Car c;
    
30.     mc = c;
    
31.     return 0;
    
32. }
    

复制代码

这里写的 “ //其它略”
也就是说他把 operator= 函数略了 ?

跳转到最佳答案楼层

傻眼貓咪

儿子继承爸爸，儿子是儿子，爸爸是爸爸，是两个不同的人啊。
一个是 MTCar，另一个是 Car

GeraldIAD

傻眼貓咪 发表于 2022-4-24 18:48
儿子继承爸爸，儿子是儿子，爸爸是爸爸，是两个不同的人啊。
一个是 MTCar，另一个是 Car

不是 子类向父类 向上转换是完全没问题的
这里讨论 父类向子类转换 对象和指针的两种情况
你这答非所问啊

人造人

GeraldIAD 发表于 2022-4-24 21:04
不是 子类向父类 向上转换是完全没问题的
这里讨论 父类向子类转换 对象和指针的两种情况
你这答非所问 ...

显然，两个都是错误的，但是D要比F错的更离谱
对于F，只要添加一个函数，一个 operator= 函数，就是对的
但是对于D，一个子类里面有一个完整的父类，但是一个父类里面可没有包含子类
把父类的指针转换成子类的指针，错的要比F少写了一个函数更离谱

这种题目没意思，错就错了，还要在错误中比较出一个 ‘最’ 来，没意思

1. class Car {
   
2. public:
   
3.    Car( ){ /*略*/ }
   
4.    void doFunc( ) { /*略*/ };   
   
5.    //其它略
   
6. };
   
7. class MTCar:public Car {
   
8. public:
   
9.    MTCar( ){ /*略*/ }
   
10.    void newFunc( ) { /*略*/ }
    
11.    //其它略
    
12.    const MTCar operator=(const Car &c) {
    
13.        return MTCar();
    
14.    }
    
15. };
    
16. class Foo {
    
17. public:
    
18.    Foo(Car * pobj=nullptr):mp(pobj){ }
    
19.    void func(Car & obj){
    
20.       obj.doFunc( );
    
21.    }
    
22. private:
    
23.    Car * mp;
    
24.    //其它略
    
25. };
    
26. 
    
27. int main() {
    
28.     MTCar mc;
    
29.     Car c;
    
30.     mc = c;
    
31.     return 0;
    
32. }
    

复制代码

这里写的 “ //其它略”
也就是说他把 operator= 函数略了 ?

傻眼貓咪

GeraldIAD 发表于 2022-4-24 21:04
不是 子类向父类 向上转换是完全没问题的
这里讨论 父类向子类转换 对象和指针的两种情况
你这答非所问 ...

既然你已经非常清楚答案了，那为什么需要问呢？你的解答已经是答案了啊。

1. #include <iostream>
   
2. 
   
3. class Car {
   
4. public:
   
5.     Car() { /*略*/ }
   
6.     void doFunc() { /*略*/ };
   
7.     //其它略
   
8. };
   
9. class MTCar :public Car {
   
10. public:
    
11.     MTCar() { /*略*/ }
    
12.     void newFunc() { /*略*/ }
    
13.     //其它略
    
14. };
    
15. class Foo {
    
16. public:
    
17.     Foo(Car* pobj = nullptr) :mp(pobj) { }
    
18.     void func(Car& obj) {
    
19.         obj.doFunc();
    
20.     }
    
21. private:
    
22.     Car* mp;
    
23.     //其它略
    
24. };
    
25. 
    
26. int main() {
    
27.     MTCar mc;
    
28.     Car c;
    
29.     // mc = c;
    
30.     c = mc; // <----------- 注意这里 -----------
    
31.     return 0;
    
32. }

复制代码

GeraldIAD

傻眼貓咪 发表于 2022-4-24 22:00
既然你已经非常清楚答案了，那为什么需要问呢？你的解答已经是答案了啊。

emm不是不是 我之前没懂
看四楼才明白