boost::signals mit verschiedenen parametern aufrufen

folgender code:

float product(float x, float y) { return x*y; }
float quotient(float x, float y) { return x/y; }
float sum(float x, float y) { return x+y; }
float difference(float x, float y) { return x-y; }

boost::signal<float (float x, float y)> sig;

sig.connect(&product);
sig.connect(&quotient);
sig.connect(&sum);
sig.connect(&difference);

std::cout << sig(5, 3) << std::endl; // Hier möchte ich in einer Schleife jeden Slot durchgehen und ihn mit verschiedenen Parametern aufrufen.

Geht das ? Wenn ja, wie ? Wenn nein, ist doch kake

eyMannWoSindMeineSlots schrieb:

Wenn nein, ist doch kake

Falsch formuliert. Vielleicht ist ja boost::signals nicht dafür gemacht. Was müsste ich mir dann anschauen?

l'abra d'or

eyMannWoSindMeineSlots schrieb:

Vielleicht ist ja boost::signals nicht dafür gemacht.

Genau. Du willst eigentlich nur einzelne Funktionsaufrufe:

cout << produkt(5,3) << summe(10, 4) << differenz(88,33) << endl;

Wenn ich dich richtig verstehe.

l'abra d'or schrieb:

Du willst eigentlich nur einzelne Funktionsaufrufe

Und die kapselt man am Besten mit boost::function.

Du willst also eigentlich so was:

std::list<boost::function<float(float, float)> > funcs;
funcs.push_back(&product);
funcs.push_back(&quotient);
funcs.push_back(&sum);
funcs.push_back(&difference);
std::for_each(funcs.begin(), funcs.end(), std::cout << (boost::lambda::_1)(5, 3) << "\n");

Wenn ich dich richtig verstehe.

eigentlich wollte ich mit boost::signals ein event system aufbauen.

ich dachte mir sowas in der art:

Object.addEvent(/*eventType*/ Event::CLICK, /*callback*/ doStuff, /*userdata*/data);

und in meiner Eventloop warte ich auf ein Klicksignal, falls eines ankommt rufe ich alle Click-Events des jeweiligen Objektes auf.

wennIchDichRichtigVersteh schrieb:

...

You know what I want!

Danke dir, genau das was ich haben will!
Bietet der Standard nicht std::function an? Sollte doch das selbe sein oder nicht?

l'abra d'or

Eigentlich willst du sehr wohl boost::signals! Dein Kommentar im ersten Post wies in eine komplett andere Richtung:

// Hier möchte ich in einer Schleife jeden Slot durchgehen und ihn mit verschiedenen Parametern aufrufen.

Keine Ahnung, was du damit gemeint hast...

Der Standard bietet binary_function an und die funktioniert bei solchen Dingen nicht richtig. boost::function ist daher im tr1 von C++ und vor allem in C++0x dabei. Wenn du sowieso C++0x benützt, kannst du auch die Lambda-Konstrukte vereinfachen.

Falls du dir wirklich ein event-System aufbauen willst, mach es halt so, wie es auch in der Boost-Lib gemacht wird:

template<typename Container>
struct aggregate_values
{
  typedef Container result_type;

  template<typename InputIterator>
  Container operator()(InputIterator first, InputIterator last) const
  {
    return Container(first, last);
  }
};

boost::signal<float (float, float), 
    aggregate_values<std::vector<float> > > sig;

sig.connect(&quotient);
sig.connect(&product);
sig.connect(&sum);
sig.connect(&difference);

std::vector<float> results = sig(5, 3);
std::copy(results.begin(), results.end(), 
    std::ostream_iterator<float>(cout, " "));