重写 CAST 运算符（我认为它被称为向下转型）

Question

我是 c++ 的新手，我遇到了一个对其他人来说可能很容易解决的小问题。我有一个 class A 和一个扩展 class A 的 class B。我有一个对象 A，我们称它为 a1。我想使用以下语法将 a1 向下转换为类型 B class："B b1=(B)a1;"

 class IAmortizabil
 {
 public:
     virtual double getAmortizare()=0;
 };



 class Utilaj : public IAmortizabil{
 protected:
     float valInventar;
     char codUtilaj[10];
     char *denUtilaj;
     int anIntrFunct;
     int durataNormata;

 public:

     Utilaj(){
         denUtilaj=NULL;
         valInventar=0;
         anIntrFunct=0;
         durataNormata=0;
     }

     Utilaj(char *codUtilaj, char *denUtilaj, float valInventar, int      anIntrFucnt, int durataNormata){
         strcpy(this->codUtilaj, codUtilaj);
         this->denUtilaj=new char[strlen(denUtilaj)+1];
         strcpy(this->denUtilaj, denUtilaj);
         this->valInventar=valInventar;
         this->anIntrFunct=anIntrFucnt;
         this->durataNormata=durataNormata;
     }

     Utilaj(Utilaj &u)
     {
         strcpy(codUtilaj, u.codUtilaj);
         denUtilaj = new char[strlen(u.denUtilaj) + 1];
         strcpy(denUtilaj, u.denUtilaj);
         valInventar = u.valInventar;
         anIntrFunct = u.anIntrFunct;
         durataNormata = u.durataNormata;
     }


     friend ostream &operator<<(ostream &iesire, Utilaj &u)
     {
         iesire << " cod utilaj " << u.codUtilaj << endl;
         iesire << "denumire utilaj " << u.denUtilaj << endl;
         iesire << "valoare inventar " << u.valInventar << endl;
         iesire << "an intrare in functiune " << u.anIntrFunct << endl;
         iesire << " durata normata " << u.durataNormata << endl;
         return iesire;
     }

     Utilaj operator=(Utilaj &u)
     {
         strcpy(codUtilaj, u.codUtilaj);
         if (denUtilaj != NULL)
             delete[]denUtilaj;
         denUtilaj = new char[strlen(u.denUtilaj) + 1];
         strcpy(denUtilaj, u.denUtilaj);
         valInventar = u.valInventar;
         anIntrFunct = u.anIntrFunct;
         durataNormata = u.durataNormata;
         return *this;
     }



     double getAmortizare()
     {
         cout << '\n';
         if (durataNormata != 0)
             return valInventar / durataNormata;
         else {
             cout << "Durata normata este 0=>eroare";
             return 0;
         }
     }


     ~Utilaj(){
         if(denUtilaj!=NULL){
             delete[]denUtilaj;
         }
     }
 };


 class Strung :public Utilaj
 {
 protected:
     int nrBucati;

 public:
     Strung() :Utilaj()
     {
         nrBucati = 0;
     }
     Strung(char *_codUtilaj, char *_denUtilaj, float _valInventar, int _an, int _durata, int _nrBucati) :Utilaj(_codUtilaj, _denUtilaj, _valInventar, _an, _durata)
     {
         nrBucati = _nrBucati;
     }

     Strung(Strung &s) :Utilaj(static_cast< Utilaj&>(s))
     {
         nrBucati = s.nrBucati;
     }

         };

编辑：添加了我的 classes 可能有帮助。我不知道这里是什么 "the way to do it" 但我的老师希望他们这样，与他争论是没有意义的。

Answer 1

在 C++ 中，您可以使用 dynamic_cast 将指向基类型的指针转换为指向派生类型的指针，假设它首先指向派生类型。

class A
{
};

class B : public A
{
};

int main()
{
    A * a = new B();
    B * b = dynamic_cast<B*>(a);

    if( b == nullptr )
    {
        // Error - "a" was not a "B" object
    }

    return 0;
}

当你在 C++ 中看到 (sometype)Object 时，那是 C 风格的强制转换，并不是启蒙之道。这等同于 C++ 重新解释转换并且可能非常危险。它当然不应该在 dynamic_cast 就足够的地方使用。

另外，在C++中，当你有一个多态类型时，你必须使用一个指针。您不会强制转换对象的实例，而是强制转换指向该对象的指针。

请 Google "dynamic_cast" 和 "reinterpret_cast" 以便更好地理解两者。

重写 CAST 运算符（我认为它被称为向下转型）

Overriding CAST operator (i think it is called downcasting)

c++

downcast