Ist es möglich, zum Durchlaufen einer mpl::vector zur Laufzeit ohne Instanziierung der Typen, in den Vektor?

Generell würde ich boost::mpl::for_each<>() durchqueren boost::mpl::vector, aber dies erfordert einen Funktor mit einer template-Funktion erklärt, wie die folgenden:

template<typename T> void operator()(T&){T::staticCall();}

Mein problem mit diesem ist, dass ich nicht wollen, das Objekt T instanziiert werden durch for_each<>. Ich brauche nicht den parameter T in der operator() überhaupt. Gibt es eine Möglichkeit, dies zu erreichen, oder eine alternative zu for_each<> dass nicht die übergabe eines Objekts vom Typ T an die template-Funktion?

Optimal, ich möchte die operator () - definition wie folgt Aussehen:

template<typename T> void operator()(){T::staticCall();}

Und natürlich will ich nicht, dass T instanziiert werden überhaupt vor dem Anruf. Andere Tipps/Vorschläge sind auch willkommen.

InformationsquelleAutor Marcin | 2010-10-29

boost boost-mpl c++foreach vector

Interessante Frage! Soweit ich das beurteilen kann, zu Steigern.MPL scheint nicht zu geben einen solchen Algorithmus. Allerdings schreiben Sie Ihre eigenen, sollte nicht allzu schwierig sein, mit Iteratoren.

Hier ist eine mögliche Lösung:

#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/next_prior.hpp>
#include <boost/mpl/vector.hpp>

using namespace boost::mpl;


namespace detail {

template < typename Begin, typename End, typename F >
struct static_for_each
{
    static void call( )
    {
        typedef typename Begin::type currentType;

        F::template call< currentType >();
        static_for_each< typename next< Begin >::type, End, F >::call();
    }
};


template < typename End, typename F >
struct static_for_each< End, End, F >
{
    static void call( )
    {
    }
};

} //namespace detail


template < typename Sequence, typename F >
void static_for_each( )
{
    typedef typename begin< Sequence >::type begin;
    typedef typename end< Sequence >::type   end;

    detail::static_for_each< begin, end, F >::call();
}

[Die Namensgebung ist vielleicht nicht besonders gut gewählt, aber gut...]

Hier ist, wie würden Sie die Verwendung dieses Algorithmus:

struct Foo
{
    static void staticMemberFunction( )
    {
        std::cout << "Foo";
    }
};


struct Bar
{
    static void staticMemberFunction( )
    {
        std::cout << "Bar";
    }
};


struct CallStaticMemberFunction
{
    template < typename T >
    static void call()
    {
        T::staticMemberFunction();
    }
};


int main()
{
    typedef vector< Foo, Bar > sequence;

    static_for_each< sequence, CallStaticMemberFunction >(); //prints "FooBar"
}

Sehr nützliche Anleitungen hier. Danke.

InformationsquelleAutor Luc Touraille

14

Gerade erlebt die gleiche situation und, sofern verschiedene Lösung für das problem, das ich gerne teilen möchte. Es ist nicht so, dass offensichtliche, aber es nutzt einen vorhandenen Algorithmus. Die Idee ist die Verwendung von Zeigern statt.
```
typedef boost::mpl::vector<type1*, type2*> container;

struct functor
{
    template<typename T> void operator()(T*)
    {
        std::cout << "created " << typeid(T).name() << std::endl;
    }
};

int main()
{
    boost::mpl::for_each<container>(functor());
}
```
so, hier bekommen wir einen null-Zeiger, aber das ist uns egal, da wir nicht Vorhaben, Sie zu benutzen.

Wie gesagt, dass ist nicht offensichtlich in den code, und würde wahrscheinlich erfordern einige zusätzliche Kommentare, aber es noch löst Sie die Frage ohne das schreiben von zusätzlichem code.

Hinzugefügt

Ich denke Diego Sevilla schlug vor, etwas ähnliches.
- Das ist ziemlich smart. Sie können mpl::transform zu definieren, die den "Zeiger" - version on-the-fly: boost::mpl::for_each<boost::mpl::transform<MyTypes, boost::add_pointer<boost::mpl::_1> >::type>(Functor());
- Sie konnte auch nicht liefern-pointer, aber eine leere geben, die enthalten Art.
InformationsquelleAutor confucius
1

Gut, zunächst wird der statische Aufruf im code bedeutet, dass Ihr Objekt existieren. Vorher/nachher ist sinnlos, in dieser Hinsicht. Das einzige mal, "ich will nicht, dass T instanziiert an alle die vor dem Aufruf," sinnvoll ist, wenn T ist eine Vorlage. Es ist nicht, weil es nicht sein kann. Es ist wahr, dass es ist, dass die Linie, die bewirkt, dass das Objekt vorhanden ist, aber ich bin ziemlich sicher, dass es nicht nur dort existieren, sobald das Produkt zusammengestellt.

Zweitens, ich glaube nicht, dass es eine aktuelle Methode for_each ohne instanziieren. IMHO ist dies ein bug in MPL, verursacht durch eine fragwürdige Entscheidung, die operator(). Will nicht sagen, es ist falsch, denn ich kenne den Entwickler und er ist viel klüger, als ich bin, aber es scheint so, aus jetzt hier, dass Sie dies.

So, ich denke, Sie stecken mit remake eine for_each, dass Anrufe auf eine Vorlagen-Funktion, die nicht erforderlich ist, den parameter ein. Ich bin fast sicher, es ist möglich, aber auch ebenso sicher, es ist nicht bereitwillig verfügbar als vorgefertigte Komponente in MPL.

InformationsquelleAutor Edward Strange
1

Marcin, du hast sehr Recht. Ich habe mir überlegt, diese entlang und ich sehe nicht, eine einfache Lösung für dieses. Auch wenn Sie nicht schreiben Sie die leeren operator(), es wäre zumindest möglich, verwenden Sie einen Zeiger, der das nicht braucht, ein Tatsächliches Objekt zu existieren. Du musst Rollen Sie Ihre eigene Implementierung, wie es scheint.
- Ich denke, es ist keine "einfache" Lösung, weil die einfach die Lösung ist schon da: mit mpl::begin und mpl::end. Im Grunde müssen Sie durchqueren, es selbst. Genau wie Sie schreiben, sehr lange for(std::vector<int>::iterator it = v.begin() ... Dinge für Iteratoren. Schreiben Sie eine Funktion höherer Ordnung, um es zu vereinfachen, aber am Ende müssen Sie noch durchqueren es wie @Luc Touraille vorgeschlagen.
InformationsquelleAutor Diego Sevilla

Hier ist eine alternative Lösung, sehr inspiriert von Luc Touraille Antwort.

Dieser version erfolgt mit Metafunction Klassen anstelle von Funktionen, die ermöglicht die static_for_each genannt zu werden, auch außerhalb der Funktion Bereiche (nützlich, wenn der job muss völlig fertig am compile-Zeit, so dass Sie keine unnötigen Funktionen, die zur Laufzeit aufgerufen).

Außerdem gibt es mehr Interaktion Dank der first und last typedefs, so dass man Informationen aus der Schleife, wenn notwendig, ein wenig wie ein return arbeitet für eine Funktion.

Können Sie auch Zugriff auf die vorherigen iteration Ergebnis innerhalb jeder iteration mit dem zweiten template-parameter Previous an die metafunction Klasse F.

Schließlich können Sie die Daten zur loop-Prozess, der die Initial parameter template angegeben, wird als Wert der Previous parameter der ersten iteration.

# include <boost/mpl/begin_end.hpp>
# include <boost/mpl/next_prior.hpp>
# include <boost/mpl/apply.hpp>

namespace detail_static_for_each
{
  //Loop
  template<typename Begin, typename End, typename F, typename Previous>
  struct static_for_each
  {
  private:
    typedef typename Begin::type                                current_type;

  public:
    typedef typename boost::mpl::apply<F, current_type, Previous>::type             first;
    typedef typename static_for_each<typename boost::mpl::next<Begin>::type, End, F, first>::last   last;
  };

  //End of loop
  template<typename End, typename F, typename Last>
  struct static_for_each<End, End, F, Last>
  {
  public:
    typedef Last    first;
    typedef Last    last;
  };

} //namespace detail_static_for_each

//Public interface
template<typename Sequence, typename F, typename Initial = void>
struct  static_for_each
{
private:
  typedef typename boost::mpl::begin<Sequence>::type        begin;
  typedef typename boost::mpl::end<Sequence>::type          end;

  typedef typename detail_static_for_each::static_for_each<begin, end, F, Initial>  loop;

public:
  typedef typename  loop::first                 first;
  typedef typename  loop::last                  last;
};

Hier ist ein einfaches Beispiel, das beide gibt und ruft Daten :

# include <iostream>

# include <boost/type_traits/is_same.hpp>

# include <boost/mpl/if.hpp>
# include <boost/mpl/vector.hpp>

# include "static_for_each.hpp"

struct is_there_a_float                                                                                                                                                                                              
{                                                                                                                                                                                                                    
    template<typename currentItem, typename PreviousIterationType>                                                                                                                                                     
    struct apply                                                                                                                                                                                                       
    {                                                                                                                                                                                                                  
        typedef typename boost::mpl::if_< PreviousIterationType,                                                                                                                                                         
                                          PreviousIterationType,                                                                                                                                                         
                                          boost::is_same<float, currentItem> >::type    type;                                                                                                                        
    };                                                                                                                                                                                                                 
};

struct  test                                                                                                                                                                                                         
{                                                                                                                                                                                                                    
    typedef boost::mpl::vector< char, long, long, double, float, int, char > sequence;                                                                                                                                 

    typedef static_for_each<sequence, is_there_a_float, boost::false_type>::last    found;                                                                                                               
};

int     main(void)                                                                                                                                                                                                   
{                                                                                                                                                                                                                    
    std::cout << std::boolalpha << test::found::value << std::endl;                                                                                                                                                    

    return (0);                                                                                                                                                                                                        
}

Diese Eigenschaften macht die Verwendung von static_for_each ähnlich wie die Nutzung der gemeinsamen Laufzeit von Schleifen (while, for, BOOST_FOREACH ...) wie können Sie interagieren direkt mit der Schleife.

Soweit ich sagen kann, Sie nur neu implementiert, mpl::Falten. Das wichtigste Merkmal mpl::for_each ist, dass es funktioniert zur Laufzeit (gut, die iteration erfolgt zur compile-Zeit, aber es ruft runtime-Operationen), und ich nahm an, der OP wollte dieses Verhalten. Sonst, er, hätte einen der zahlreichen compile-Zeit-algorithmen zur Verfügung gestellt von MPL.
Ich Stimme mit dir zu tun. Diese Antwort war mehr gedacht als " bonus-Informationen als direkte Antwort.

InformationsquelleAutor Drax

Mochte ich (bis-gestimmt habe) die Lösung mit Zeiger und eigene definiert *_for_each Funktion. Hier ist eine alternative mit type-wrapper für T, wenn das Ziel ist zu vermeiden, Objekterstellung, bis es benötigt wird.

template<typename T>
struct Wrapper
{
  typedef T type;
};

struct Functor
{
  template<typename T> void operator()(T t)
  {
    T::type obj(1);
    T::type::static_fuc();
  }
};

struct T1
{
  T1(int a) : m_a(a) { }
  int m_a;
  static inline void static_fuc() { }
};
struct T2
{
  T2(int a) : m_a(a) { }
  int m_a;
  static inline void static_fuc() { }
};

void fun()
{
  namespace mpl=boost::mpl;
  typedef mpl::vector<Wrapper<T1>,Wrapper<T2> > t_vec;
  mpl::for_each<t_vec>(Functor());
}

InformationsquelleAutor Mrnell

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.