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

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少写了一个函数更离谱

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

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= 函数略了 ?

跳转到最佳答案楼层

傻眼貓咪

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

GeraldIAD

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

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

人造人

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= 函数略了 ?

傻眼貓咪

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;
}

GeraldIAD

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

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