die Identifizierung der Art

In meiner Anwendung gibt es eine Hierarchie, in denen nur die Klassen, die am Ende der Vererbungskette sind nicht abstrakte Klassen. Auch gibt es einige Verwendung von boost::variant. Ich möchte eine Funktion schreiben, die einen Zeiger und einen Typ und sagt aus, ob das Objekt gehört zu diesem Typ.

Beispielsweise

#define IsA(nodeptr, type)   ( checkType<type>(nodeptr) ) 

template<typename Type, bool isAbstract, typename PtrType >
class CheckType
{
    bool operator()( PtrType* ptr ) { return ( typeid(*ptr) == typeid(Type) ); }
};

template<typename Type, typename PtrType >
class CheckType < Type, true, PtrType >
{
    bool operator()( PtrType* ptr ) { return ( dynamic_cast<Type*>(ptr) != NULL ); }
};

template<typename Type, BOOST_VARIANT_ENUM_PARAMS(typename T) >
class CheckType< Type, false, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
{
    bool operator()( boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>* ptr ) 
    { 
        return ( ptr->type() == typeid(Type) ); 
    }
}

template< typename Type, typename PtrType >
bool checkType( PtrType* nodePtr )
{
    CheckType<Type, boost::is_abstract<PtrType>::value, PtrType> check;
    return check(nodePtr);
}

Nun, wenn es eine boost-Variante, ich möchte herausfinden, ob die boost-Variante speichert diesen bestimmten Typ. Kann mir jemand helfen mit, dass? Ich will nicht, um einen zusätzlichen parameter, um herauszufinden, ob es ist die eine Variante. Auch für die Suche nach dem Abstraktheit, ich bin mit boost::is_abstract..

Dank,
Gokul.

  • funktioniert dynamic_cast nicht füllen die Rechnung für Sie?
  • Wir wollen typeid Ort der dynamic cast, wo immer möglich. Boost::Variant funktioniert nicht mit dynamischen cast
InformationsquelleAutor Gokul | 2010-04-21
  1. 4

    Nun, es gibt zwei direkt-Versionen dieser:

    return (boost::get<Type*>(v) != 0);

    Und so:

    return ( v.type() == typeid(Type) );

    Ich bin nicht sicher, wie Sie Sie zu behandeln, die mit Ihrer Vorlage überladen sauber, aber Sie könnten so etwas tun:

    template< typename Type, bool TypeisAbstract, bool TypeIsVariant,
          typename ptrType >
bool checkType( ptrType* t)
{
    return ( typeid(*t) == typeid(Type) );
}

template< typename Type, typename ptrType >
bool checkType<Type, true, false, ptrType>( ptrType* t)
{
    return ( dynamic_cast<Type*>(t) != NULL );
}

template< typename Type>
bool checkType<Type, false, true, ptrType>(const boost::variant& v)
{
    return ( v.type() == typeid(Type) );
}
    • Ich will es tun, ohne eine template-parameter, um zu sagen, ob es eine Variante...
    • oh! ich überblickte die type () - Funktion in der Variante Dank
    InformationsquelleAutor Joseph Lisee
  2. 2

    Der sauberste Weg, um mit Boost.Variant ist normalerweise die Verwendung eines Besuchers.

    template <class Type>
class TypeChecker: boost::static_visitor<>
{
public:
  explicit TypeChecker(bool& result): mResult(result) {}

  template <class T>
  void operator()(const T& t) const { mResult = dynamic_cast<const Type*>(&t); }

private:
  bool& mResult;
};

    Dann können Sie wickeln Sie es:

    template <class Type, class Variant>
bool checkType(const Variant& v)
{
  bool result = false;
  boost::apply_visitor(TypeChecker<Type>(result), v);
  return result;
}

    Die verwendet werden können, etwa so:

    int main(int argc, char* argv[])
{
  typedef boost::variant<Dog,Cat,Kid> variant_type;

  variant_type var = /**/;

  if (checkType<Animal>(var))
  {
  }
  else
  {
  }
}

    Dies ist jedoch nicht der OO-Weg, und weder ist es die Variante Weg.

    Eine bessere Idee wäre, um die volle Leistung von Boost.Variant:

    struct DoIt: boost::static_visitor<>
{
  void operator()(const Animal& animal) const {}
  void operator()(const Kid& kid) const {}
};


int main(int argc, char* argv[])
{
  typedef boost::variant<Dog,Cat,Kid> variant_type;

  variant_type var = /**/;

  boost::apply_visitor(DoIt(), var);
}

    Beachten Sie, wie die static_visitor Konzept natürlich behandelt der Vererbung.

    • Ich denke, Besucher können nicht für den genauen Zweck hier, wie ich will, um mit jeder Variante
    • Wenn Sie einen Blick auf die erste Lösung, da nur operator() implementiert, in der Besucher ein template ein, dann funktioniert es mit jeder Variante 🙂
    InformationsquelleAutor Matthieu M.
Schreibe einen Kommentar