einfaches Equals für typen?



  • was ist die kürzeste möglichkeit, ein template zu bauen, das feststellt, ob zwei typen gleich sind?



  • volkard schrieb:

    was ist die kürzeste möglichkeit, ein template zu bauen, das feststellt, ob zwei typen gleich sind?

    template<typename T, typename TT>
    bool IsEqual(T Type1, TT Type2)
    { return (typeid(Type1) == typeid(Type2)); }
    
    int main()
    {
        int    i, j;
        float  k;
    
            if(IsEqual(i, j))
                std::cout<<"type of i == type of j\n";
    
            if(!IsEqual(j, k))
                std::cout<<"type of j != type of k\n";
    
        return 0;
    }
    

    Ist das so Ok?

    mfg
    v R



  • wohl eher

    template<typename A, typename B>
    struct is_same
    {
      enum { result = 0; };
    };
    
    template<typename A>
    struct is_same<A, A>
    {
      enum { result = 1; };
    };
    

    Aber boost::is_same
    ist da wohl besser.

    die VC++6 Version sieht so aus:

    template<typename A>
    struct is_same_impl
    {
      template<typename B>
      struct inner
      {
        enum { result = 0; };
      };
    
      struct inner<A>
      {
        enum { result = 1; };
      };
    };
    
    template<typename A, typename B>
    struct is_same
    {
      enum { result = is_same_impl<A>::inner<B>::result; }
    };
    


  • Hmmm...mit nem struct und nem schoenen enum wollt ich's auch machen, aber mir
    liegt die generische Programmierung noch nicht so und so hab ich es nicht hin-
    bekommen :).

    Dafuer hab ich nich soviel Code wie du 😃

    mfg
    v R



  • virtuell Realisticer schrieb:

    Ist das so Ok?

    nein. habs zwar nicht gesagt, aber die auswertung sollte schon zur compilezeit sein, damit man das ergebnis in weiteren templates verwenden kann.



  • volkard schrieb:

    virtuell Realisticer schrieb:

    Ist das so Ok?

    nein. habs zwar nicht gesagt, aber die auswertung sollte schon zur compilezeit sein, damit man das ergebnis in weiteren templates verwenden kann.

    naja, ein Versuch wars wert 🙂

    mfg
    v R



  • Shade Of Mine schrieb:

    wohl eher

    template<typename A, typename B>
    struct is_same
    {
      enum { result = 0; };
    };
    
    template<typename A>
    struct is_same<A, A>
    {
      enum { result = 1; };
    };
    

    sehr schön. bravo.

    Aber boost::is_same
    ist da wohl besser.

    die VC++6 Version sieht so aus:

    template<typename A>
    struct is_same_impl
    {
      template<typename B>
      struct inner
      {
        enum { result = 0; };
      };
    
      struct inner<A>
      {
        enum { result = 1; };
      };
    };
    
    template<typename A, typename B>
    struct is_same
    {
      enum { result = is_same_impl<A>::inner<B>::result; }
    };
    

    warum?
    sieht mir danach aus, als sei es ein workaround, weil der msvc6 die schöne version nicht kann, oder?


Anmelden zum Antworten