C++ Ist es möglich, einen Objekttyp in eine Funktion zu übergeben, die verglichen werden soll?

Question

Ich habe eine Situation, wo ich herausfinden muss, ob ein abgeleitetes Objekt in einem Vektor innerhalb eines anderen Objekts gespeichert ist, und diese Funktion zu funktionieren. Ich kann keinen Weg finden, genau das zu tun, was ich will, oder festzustellen, ob es möglich ist. Ich habe eine Lösung, die funktioniert, die ich einschließe, aber es wäre sauberer, wenn es eine direkte Methode gibt, um das Ziel zu erreichen.

Dies ist im Wesentlichen, was ich tun möchte:

class IFruit 
{ 
public: 
    virtual ~IFruit(){}; 
}; 
class Apple : public IFruit {}; 
class Banana : public IFruit {}; 
class Orange : public IFruit {}; 

class FruitBowl 
{ 
public: 
    bool HasFruit(datatype?? FruitType) 
    { 
     for (auto iter : m_Fruit) 
     { 
      if (typeof(iter) == typeof(FruitType)) 
      { 
       return (true); 
      } 
     } 
     return (false); 
    } 

    vector< IFruit* > m_Fruit; 
}; 

int main() 
{ 
    FruitBowl Snacks; 
    Snacks.m_Fruit.push_back(new Banana); 
    Snacks.m_Fruit.push_back(new Apple); 
    Snacks.m_Fruit.push_back(new Orange); 

    if (Snacks.HasFruit(Orange)) 
    { 
     cout << "There is an orange available"; 
    } 

    return (0); 
} 

Dies ist eine Abhilfe ist, dass das Ziel erreicht, aber es hat den zusätzlichen Schritt den Rückruf zu schaffen, die ich auszurotten lieben würde:

#include <vector> 
#include <iostream> 
#include <functional> 
using namespace std; 

class IFruit 
{ 
public: 
    virtual ~IFruit(){}; 
}; 
class Apple : public IFruit {}; 
class Banana : public IFruit {}; 
class Orange : public IFruit {}; 

class FruitBowl 
{ 
public: 
    bool HasFruit(function< bool(IFruit*) > fnCompareFruitType) 
    { 
     for (auto iter : m_Fruit) 
     { 
      if (fnCompareFruitType(iter)) 
      { 
       return (true); 
      } 
     } 
     return (false); 
    } 

    vector< IFruit* > m_Fruit; 
}; 

int main() 
{ 
    FruitBowl Snacks; 
    Snacks.m_Fruit.push_back(new Banana); 
    Snacks.m_Fruit.push_back(new Apple); 
    Snacks.m_Fruit.push_back(new Orange); 

    if (Snacks.HasFruit([](IFruit* TestFruit){ return (dynamic_cast< Orange* >(TestFruit) != nullptr); })) 
    { 
     cout << "There is an orange available"; 
    } 

    return (0); 
} 

Answer 1

Sie keinen Typ als Runtime-Funktion Parameter übergeben können, aber Sie eine als Kompilierung Template-Parameter einer Funktion Vorlage verwenden können:

#include <vector> 
#include <iostream> 
#include <algorithm> 

class IFruit 
{ 
public: 
    virtual ~IFruit(){}; 
}; 
class Apple : public IFruit {}; 
class Banana : public IFruit {}; 
class Orange : public IFruit {}; 

class FruitBowl 
{ 
public: 
    template <typename T> 
    bool HasFruit() 
    { 
     return std::any_of(m_Fruit.begin(), m_Fruit.end(), 
          [](IFruit* fruit) { 
           return dynamic_cast<T*>(fruit) != nullptr; 
          }); 
    } 

    std::vector< IFruit* > m_Fruit; 
}; 


int main() 
{ 
    FruitBowl Snacks; 
    Snacks.m_Fruit.push_back(new Banana); 
    Snacks.m_Fruit.push_back(new Apple); 
    Snacks.m_Fruit.push_back(new Orange); 

    if (Snacks.HasFruit<Orange>()) 
    { 
     std::cout << "There is an orange available"; 
    } 
} 

Answer 2

Für mich wäre Lösung, eine Enum für alle "Fruit-Typen" zu machen und es als Parameter-Datentyp zu verwenden. Sie können einen Vergleich machen dann

Answer 3

So etwas wie das?

#include <iostream> 
#include <vector> 
using namespace std; 

class IFruit { 
    public: 
    virtual  ~IFruit(void) { } 
} ; 

class Apple : public IFruit { }; 
class Banana : public IFruit { }; 
class Orange : public IFruit { }; 

class FruitBowl : public vector<IFruit *> { 
    public: 
    template <typename T> bool HasFruit(void) const { 
     for (auto i : vector<IFruit *>(*this)) { 
      if (typeid(*i) == typeid(T)) return true; 
     } 
     return false; 
    } 
} ; 

int 
main(int, char **) 
{ 
    FruitBowl b; 

    b.push_back(new Apple); 
    b.push_back(new Banana); 
// b.push_back(new Orange); 

    if (b.HasFruit<Orange>()) // thanks M.M.! 
     cout << "found one" << endl; 
    else 
     cout << "no oranges" << endl; 

    return 0; 
} 

Vielleicht gibt es eine sexierere Möglichkeit, den Anruf zu tätigen? (Orange *)0 ist irgendwie hässlich.

Answer 4

Vielleicht:

#include<vector> 
#include<iostream> 
#include<typeinfo> 
#include<memory> 

using namespace std; 

class IFruit 
{ 
public: 
    virtual ~IFruit(){}; 
}; 
class Apple : public IFruit {}; 
class Banana : public IFruit {}; 
class Orange : public IFruit {}; 

class FruitBowl 
{ 
public: 
    //uses tempalte to accept any type 
    template<typename FruitType> 
    bool HasFruit(FruitType fruit) 
    { 
     for (auto iter : m_Fruit) 
     { 
      if (typeid(* iter).hash_code() == typeid(fruit).hash_code()) 
      { 
       return (true); 
      } 
     } 
     return (false); 
    } 

    std::vector<IFruit*> m_Fruit; 
}; 

int main() 
{ 
    FruitBowl Snacks; 
    Snacks.m_Fruit.push_back(new Banana); 
    Snacks.m_Fruit.push_back(new Apple); 
    Snacks.m_Fruit.push_back(new Orange); 

    if (Snacks.HasFruit(Orange())) 
    { 
     cout << "There is an orange available"; 
    } 
    else{ 
     cout<<"No fruit available"; 
    } 

    return (0); 
} 

Live- Demo: http://coliru.stacked-crooked.com/a/37a3e1b4f5567775