Sende en funksjon som pointer mellom to klasser

[zckumling]

Hei

 

Jeg sliter litt med å forstå hvordan jeg kan sende en funksjon som peker eller referanse mellom to klasser..

 

class FremmedKlasse
{
public:
FremmedKlasse() {};
~FremmedKlasse() {};
void process(double& x, double(*function)(double) )
{
x = function(x);
}
};


class Hovedklasse
{
private:
FremmedKlasse fremmedklasse;

public:
Hovedklasse() {};
~Hovedklasse() {};

double foo(double y)
{
return 2.0*y;
}

void test(double z) )
{
z = fremmedklasse.process(z, foo )
cout << z << endl;
}
};

 

 

Dette går tydeligvis ikke.. hvordan går jeg frem for å få dette til å fungere?

På forhånd takk for alle som gidder å hjelpe.. hehe

 

- John

Endret 26. juni 2010 av zckumling

[GeirGrusom]

Du må enten bruke pointer-to-member eller en funksjon definert utenfor klassen, ettersom funksjoner inne i klasser bruker thiscall fremfor stdcall, cdecl osv.

 

typedef double (*function)(double y);

double foo(double y)
{
 return y * y;
}

class MyClass
{
public:
 double Perform(function func, double y)
 {
   return func(y);
 }
};

 

Jeg er litt usikker på pointer-to-member for jeg har aldri brukt det før, men tror det er noe slikt:

 

class Klasse
{
public:
 double SomeFunc(double y)
 {
   return y * y;
 }
};

typedef double (Klasse::* function) (double y);

int main()
{
 Klasse k;
 function fn = k.*SomeFunc;
 cout << fn(100);
}

[Zolo]

Funksjons pekere Denne forklarer hvertfall hvordan det kan gjøres. Men er en god del arbeod for å sende funkjsoner fra en klasse.

[TheMaister]

Bør vel være mulig å sende functor-objekter med std::bind eller noe?

 

#include <iostream>
#include <functional>

using namespace std;

class TestClass
{
  public:
     void foo(int a)
     {
        cout << "Foo calling: val is " << a << endl;
     }
};

template<class T>
void callmember(T functor)
{
  functor();
}

int main()
{
  TestClass foo;
  callmember(bind(&TestClass::foo, foo, 10));

  return 0;
}

 

Er ikke sikker på om dette er C++0x, men.

 

Member pointer blir fort veldig klumsete.

 

typedef void (TestClass::* fun)(int a);
TestClass bar;

fun func = &TestClass::foo;
(bar.*func)(10);

 

Er kanskje enklere med static wrappers (C style), selv om det er ganske inelegant.

class TestClass
{
  public:
     void foo(int a)
     {
        cout << "Foo calling: val is " << a << endl;
     }
     static void foo_wrap(TestClass& self, int a)
     {
        self.foo(a);
     }
};


int main()
{
  TestClass bar;

  void (*func)(TestClass&, int) = &TestClass::foo_wrap;
  func(bar, 10); // OOP C-style, haeh :3

  return 0;
}

Endret 28. juni 2010 av TheMaister

[SweetMaryJane]

Litt avhengig av hvor kjapt du trenger dette til å gå, kan du bruke ferdige løsninger:

http://www.codeproject.com/KB/cpp/FastDelegate.aspx

 

Det er ikke en løsning som er vakker å se på, og den følger så vidt jeg vet ingen standard, men skal funke med de fleste compilers.

[TheMaister]

Høhø. C++0x er litt skummelt.

 

template<typename T, typename TObj, typename... arg>
auto callmember(T function, TObj obj, arg... args) -> decltype((obj->*function)(args...))
{
  return (obj->*function)(args...);
}


int main()
{
  TestClass bar;
  callmember(&TestClass::foo, &bar, 10);
  callmember(&TestClass::add, &bar, 100);
  cout << callmember(&TestClass::get, &bar) << endl;

  return 0;
}

[Zolo]

Funksjons pekere Denne forklarer hvertfall hvordan det kan gjøres. Men er en god del arbeod for å sende funkjsoner fra en klasse.

 

Har hvertfall sendt member functions inn til andre klasser ved å benytte functor template fra dette dokumentet. Er lenge siden..