多接口inhertience。从一个铸造到另一个

Question

考虑下面的一组类/接口的：

class IFish{ 
public: 
virtual void eat() = 0; 
} 

class IFriendly{ 
public: 
virtual void protect() = 0; 
} 

class IAggresive{ 
public: 
virtual void attack(Point inDest) = 0; 
} 

class CDolphin : public IFish, IFriendly{ 
eat... 
protect.... 
} 

class CShark : public IFish, IAggresive{ 
eat.... 
attack... 
} 

现在我有以下类

void CDiver 
{ 

Void shouldRunAway(IFish* fish) 
{ 
//??? 
} 

} 

我的问题是，从鱼参数可以“shouldRunAway”摘录无论是IAggresive还是IFreindly（如果它们是这些中的任何一个......）是否有某种类型的演员可以帮忙？

Answer 1

扩展在什么Drakosha贴，你会dynamic_cast的IFISH的指针到IAggressive指针并检查是否为空或不是。喜欢这个;

#include <iostream> 

class IFish { 
public: 
    virtual void eat() = 0; 
}; 

class IFriendly { 
public: 
    virtual void protect() = 0; 
}; 

class IAggressive { 
public: 
    virtual void attack() = 0; 
}; 

class Dolphin : public IFish, public IFriendly { 
public: 
    virtual void eat() { 
     std::cout << "Dolphin::eat()\n"; 
    } 

    virtual void protect() { 
     std::cout << "Dolphin::protect()\n"; 
    } 
}; 

class Shark : public IFish, public IAggressive { 
public: 
    virtual void eat() { 
     std::cout << "Shark::eat()\n"; 
    } 

    virtual void attack() { 
     std::cout << "Shark::attack()\n"; 
    } 
}; 

class Diver { 
public: 
    void shouldRunAway(IFish *fish) { 
     if (dynamic_cast<IAggressive *>(fish) != NULL) { 
      std::cout << "Run away!\n"; 
     } else { 
      std::cout << "Don't run away.\n"; 
     } 
    } 
}; 

int main(int argc, char *argv[]) { 
    Dolphin dolphin; 
    Shark shark; 
    Diver diver; 

    diver.shouldRunAway(&dolphin); 
    diver.shouldRunAway(&shark); 

    return 0; 
} 

Answer 2

看看dynamic_cast。

Answer 3

接口定义什么类确实，而不是什么是。你不应该把它们用作“是”的关系。在你的情况下，最好在IFish界面中定义一个IsDangerous（）方法。

在这种情况下，铸造是在C++中可能的，但是这将是糟糕的设计。

Answer 4

，如果这是Java中，你可以这样做：

if(fish instanceof IAggressive) 
    runAway(); 

或许有一些C++相同呢？我听说过很多关于RTTI的信息。有帮助吗？

JRH

Answer 5

你可以使用访问者模式，如果你不喜欢的dynamic_cast

#include <iostream> 

class Diver; 

class IFish { 
public: 
    virtual void eat() = 0; 
    virtual void visit(Diver*) = 0; 
}; 

class IFriendly { 
public: 
    virtual void protect() = 0; 
}; 

class IAggressive { 
public: 
    virtual void attack() = 0; 
}; 

class Diver { 
public: 
    void shouldRunAway(IFish *fish) { 
     fish->visit(this); 
    } 

    void runAway() 
    { 
     std::cout << "Run away!\n"; 
    } 

    void dontRunAway() 
    { 
     std::cout << "Don't run away!\n"; 
    } 
}; 

class Dolphin : public IFish, public IFriendly { 
public: 
    virtual void eat() { 
     std::cout << "Dolphin::eat()\n"; 
    } 

    virtual void protect() { 
     std::cout << "Dolphin::protect()\n"; 
    } 

    virtual void visit(Diver* diver) 
    { 
     diver->dontRunAway(); 
    } 
}; 

class Shark : public IFish, public IAggressive { 
public: 
    virtual void eat() { 
     std::cout << "Shark::eat()\n"; 
    } 

    virtual void attack() { 
     std::cout << "Shark::attack()\n"; 
    } 

    virtual void visit(Diver* diver) 
    { 
     diver->runAway(); 
    } 
}; 

int main(int argc, char *argv[]) { 
    Dolphin dolphin; 
    Shark shark; 
    Diver diver; 

    diver.shouldRunAway(&dolphin); 
    diver.shouldRunAway(&shark); 

    return 0; 
}