Pointer to member function

error C2475: 'test::fiska' : forming a pointer-to-member requires explicit use of the address-of operator ('&') and a qualified name

Prøv sæt '&' inden din fiska... altså test::&fiska

kig evt. på http://linuxquality.sunsite.dk/articles/memberpointers/
Hilsen Chadi
Mit lykketal er 2959

eller her: http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/dnarvc/html/msdn_pointer.asp
Hilsen Chadi
Mit lykketal er 2959

For at kalde en normal function der er member i en class, skal man udover adddressen på funktionen (som med en pointer til en almindelig funktion) have en pointer til et object, dvs en instans af class'en, det er det der bliver til "this" i funktionen.

Hvis man f.ex har:

class MyClass
{
int x;
public:
int inc()
{ retur x++;}
};

int (*ptr2member)();

int main(void)
{
MyClass x, y;
ptr2member = x.inc;
ptr2member();

return 0;
}

Her skal kompileren vide om det er x.x eller y.x der skal tælles op i MyClass::inc(), det kan den ikke se ud fra en pointer til en funktion alene.

Hvordan gør man så?

I dit eksempel kan man lave memberFunction() om til en static member funktion:

static void memberFunction()

Det vil gå godt da den ikke skal bruge nogen variabler i class'en, en static funktion kan kun kalde andre static funktioner og have access til static variable i class'en. Static varible i en class er fælles med alle instanser af class'en.

Hvis du kun skal have en instans af class'en kan du lave en static pointer i class'en der peger på dette object og som bliver initieret i constructoren. Vha. denne pointer kan du så få adgang til de ikke static member functioner og variabler.
(Jeg tror at det er det der kaldes singleton, men jeg ved ikke ret meget om C++)

F.ex:

#include <iostream.h>
#include <conio.h>

class MyClass
{
int x;
static MyClass *Me;
public:
MyClass()
{
if(Me == 0)
Me = this;
else
cout << "Du kan kun lave en instans af mig!" << endl;
x = 0;
}
static int inc()
{
return Me->x++;
}
};

MyClass *MyClass::Me = 0;

int (*ptr2member)();

MyClass x;

int main(void)
{
ptr2member = x.inc;
cout << "Counter: " << ptr2member() << endl;
cout << "Counter: " << ptr2member() << endl;

return 0;
}

Ideen var at det skulle være rigmelig dynamisk, men ser på det. Ind til da, mange tak for et fyldestgørende svar.
I mellemtiden kunne du lave din kommentar om til et svar : )

Hvis du prøver at beskrive lidt mere om hvad det er du forsøger at opnå, kan det være jeg/vi kan hjælpe med at finde en løsning.

Problemet med at lave svar er, at du så vil føle dig fristet til at give mig up's, det vil jeg gerne undgå.

Hvis du prøver at beskrive lidt mere om hvad det er du forsøger at opnå, kan det være jeg/vi kan hjælpe med at finde en løsning.

Problemet med at lave svar er, at du så vil føle dig fristet til at give mig up's, det vil jeg gerne undgå.

Egentlig skal jeg have en kædet liste af pointere til funktioner i forskellige classes.

Jeg er begyndt at overveje om man skulle indskrænke sig til at lave pointere til classes istedet, og så have en bestemt funktion der bliver kørt hver gang i denne class. Dette kunne gøres ved at have en standard class man arver fra, som har en virtual funktion. Dem der arver fra denne har så en funktion som går ind og overtager dennes plads. (se kode)
Dette giver dog ikke så mange muligheder som pointeren direkte til funktionen der skal køres, men håber det er nok. Ellers må jeg lave funktionerne der skal peges på statiske som du snakkede om. Havde bare håbet på at der var en måde at gøre det på med en normal funktion i en normal klasse.

Thomas B

(Kode eksempel)

#include <iostream>
using namespace std;

class Base
{
public:
virtual void Dosome()
{
cout << "Base\\n\\n";
}
};


class derivedClass : public Base
{
public:
void Dosome()
{
cout << "Derived\\n\\n";
}
};

Base *ptr;

void main()
{
ptr = new derivedClass;
ptr->Dosome();
}

Problemet med at lave svar er, at du så vil føle dig fristet til at give mig up's, det vil jeg gerne undgå.

?

Et hurtigt forsøg med en linket liste af "pointere" til funktioner i forskellige instanser af en class.
Spørg endelig hvis der er noget du ikke forstår, det er måske lidt langhåret.

#include <iostream>

class MyClass
{
public:
  MyClass()
  {
    MyVar = 0;
  }
  enum FuncIdx
  {
    FuncInc,
    FuncDec
  };

  int Inc()
  {
    return MyVar++;
  }
  int Dec()
  {
    return MyVar--;
  }
  int Disp(FuncIdx Idx)
  {
    switch(Idx)
    {
      case FuncInc:
        return Inc();
      case FuncDec:
        return Dec();
    }
    return -1;
  }
private:
  int MyVar;
};

class LinkClass *List;

class LinkClass
{
public:
  LinkClass *Next;
  LinkClass(MyClass *Obj, MyClass::FuncIdx Idx)
  {
    Next = List;
    List = this;
    ObjPtr = Obj;
    Func = Idx;
  };
  int DoIt()
  {
    return ObjPtr->Disp(Func);
  }
private:
  MyClass::FuncIdx Func;
  MyClass *ObjPtr;
};

MyClass A, B;

int main(void)
{
  // Build the linked list
  LinkClass aaa(&A, MyClass::FuncDec);
  LinkClass bbb(&A, MyClass::FuncDec);
  LinkClass foo(&A, MyClass::FuncInc);
  LinkClass bar(&A, MyClass::FuncInc);
  LinkClass baz(&A, MyClass::FuncInc);
  LinkClass two(&B, MyClass::FuncDec);
  LinkClass one(&B, MyClass::FuncInc);

  // Run thru the list, note we do them in reverse order (last first)
  LinkClass *l;
  for(l = List; l; l = l->Next)
     std::cout << l->DoIt() << std::endl;

  return 0;
}

Man kan også gøre det vha. functions pointere:

#include <iostream>

class MyClass
{
public:
  MyClass()
  {
    MyVar = 0;
  }
  int Inc()
  {
    return MyVar++;
  }
  int Dec()
  {
    return MyVar--;
  }
  static int Inc(MyClass *Obj)
  {
    return Obj->Inc();
  }
  static int Dec(MyClass *Obj)
  {
    return Obj->Dec();
  }
private:
  int MyVar;
};

class LinkClass *List;

class LinkClass
{
public:
  LinkClass *Next;
  LinkClass(MyClass *Obj, int (*FuncToCall)(MyClass *Obj))
  {
    Next = List;
    List = this;
    ObjPtr = Obj;
    FuncPtr = FuncToCall;
  };

  int Func()
  {
    return FuncPtr(ObjPtr);
  }
private:
  int (*FuncPtr)(MyClass *Obj);
  MyClass *ObjPtr;
};

MyClass A, B;

int main(void)
{
  // Build the linked list
  LinkClass aaa(&A, &MyClass::Dec);
  LinkClass bbb(&A, &MyClass::Dec);
  LinkClass foo(&A, &MyClass::Inc);
  LinkClass bar(&A, &MyClass::Inc);
  LinkClass baz(&A, &MyClass::Inc);
  LinkClass two(&B, &MyClass::Dec);
  LinkClass one(&B, &MyClass::Inc);

  // Run thru the list, note we do them in reverse order (last first)
  LinkClass *l;
  for(l = List; l; l = l->Next)
     std::cout << l->Func() << std::endl;

  return 0;
}