Question

我对c ++很新，我遇到了一个小问题，对其他人来说可能很容易。我有一个A类和一个扩展A类的B类。我有一个对象A，我们称之为a1。我想使用以下语法将a1向下转换为B类：“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;
     }

         };

编辑：加入我的课程也许有帮助。我在这里什么都不知道“这样做的方法”，但我的老师想要他们这样，与他争论是没有意义的。

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

当你看到（sometype）对象，在C ++中，这是一个C风格的演员，而不是启蒙的方式。这相当于C ++重新解释强制转换，可能非常危险。当然，不应该在dynamic_cast足够的地方使用它。

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

请谷歌“dynamic_cast”和“reinterpret_cast”以便更好地了解这两者。

覆盖CAST运算符（我认为它被称为向下转换）

1 个答案: