Question

class Product
{
...
}

class Perishable : public : Product
{
 public:
 int getday();

}


int main()
{
   Product *temp;
   //due to some coding
   //temp could point to either Perishable object or Product object that is determine           //during runtime
   cout<< ((Perishable*)temp)->getday() ;// is there other way to achieve this typecasting seems dangerous

此代码的问题是，如果temp指向Product对象，temp-＆gt; getday（）将无效，我不知道如何防止这种情况发生。如果由于某些情况，我只允许在Peris中使用getday（）而不在Product中，我怎样才能检查temp是指向易腐物体还是Product对象？

一些帮助将不胜感激/

}

Answer 1

“此代码的问题在于，如果temp指向Product对象，temp-＆gt; getday（）将无效，我不知道如何防止这种情况发生。”

根据问题的精神，如果您绝对不想在其他答案中提到的Product类中声明/实现getday（），则可以使用动态强制转换来确定变量的运行时类型，以及如果你有一个Perishable实例，那么只调用getday（）：

  Product* pPerishable = new Perishable;
  Product* pProduct = new Product;
  Perishable * pActualPerishable;

  pActualPerishable= dynamic_cast<Perishable *>(pPerishable );
  //pActualPerishable will not be null because it is of type Perishable at run time

  pActualPerishable = dynamic_cast<Perishable*>(pProduct );
  //pActualPerishable will be null because you are trying to cast a runtime base type to a derived type.

因此，尝试将变量动态转换为Perishable，如果成功，则表示您可以调用getday（）。请注意，这不再是多态的，但在运行时确定类型有其用途，尤其是如果您无法控制正在处理的对象的接口。

Answer 2

我认为你需要的是：

class Product 
{ 
public:  
    virtual int getday() = 0;  
}  

class Perishable : public : Product 
{  
public:  
    virtual int getday();  
}

通过此更改，您现在可以执行此操作：

cout  << temp->getday();

Answer 3

如果getDay是virtual类中的Product函数，那么您不需要强制转换。你可以简单地写下这个：

cout<< temp->getday();

如果temp指向Product类型的对象，则会调用Product:getDay。如果temp指向Perishable类型的对象，则Perishable::getDay如果在Perishable中覆盖，则会调用Product::getDay，否则将调用{{1}}。

这就是运行时多态性的工作原理。

Answer 4

这与多态性有什么关系？我假设getDay（）也在Product中定义？如果是这样，那么这就是继承和多态的整个目的。你应该可以打电话了

TEMP-＆GT; getday（）;根本不用担心演员阵容。只要temp确实是Product或其衍生产品之一，并且getDate（）在Product中定义为virtual，就不需要任何强制转换。

示例：

class Product
{
public:
   virtual int getday();
};

class Perishable: public Product
{
public:
  virtual int getday();   
};

int main()
{
   Product *temp; //= you should be getting the new from some factory method somewhere.

   //Polymorphism will handle making sure that the right function is called here.
   cout<< temp->getday();
}

Answer 5

有几种方法，例如：

class Product
{
    int getday() { return ... ; } // -1 for example or any invalid value
}

class Perishable : public : Product
{
public:
    int getday();
}

或

class Product
{
    virtual int getday() = 0;
}

class Perishable : public : Product
{
public:
    virtual int getday(); // You must implement this somewhere
}

Answer 6

多态性需要一个虚拟基本方法，然后覆盖子类中的方法，如下所示：

class Product
{
   virtual int getday(); // You could also make this pure abstract
}

class Perishable : public Product
{
 public:
 int getday();
}

class NonPerishable : public Product
{
 public:
 int getday();
}


int main()
{
   Product *temp;
   temp = new Perishable();       
   cout << temp->getday(); // Perishable::getday()

   temp = new NonPerishable();       
   cout << temp->getday(); // NonPerishable::getday()

}

Answer 7

class Product 
{ 
... 
} 

class Perishable : public : Product 
{ 
 public: 
 int getday(); 

} 


int main() 
{ 
   Product *temp; 
   //due to some coding 
   //temp could point to either Perishable object or Product object that is determine           //during runtime 

   Product *pObj = dynamic_cast<Perishable *>(temp);
   if(!temp)
   {
       temp->getday();   //temp is containing Perishable Object.
   }
   else {
       //it is Product Obj;
   }
}

这个概念被称为RTTI。要查找对象temp类型的名称，您还可以使用typeid（temp）:: name（）但这只会返回temp指向的对象的类型..它不会进行类型转换你这样使用dynamic_cast。

c ++基本多态性

7 个答案: