ich habe ein Problem mit folgendem:

Auch wenn der Code gerade mit Fehlern übersäht ist, lass ich ihn gerade einfach mal so stehen, denn man kann ganz gut erkennen was ich probiere, oder?

Ich versuche die address der Methode des Objektes zu übergeben...

#include <iostream>
#include <cstring>

using namespace std;
class addr
{
	public:

		void setPrint(char* s)
		{
			printf("%s", s);
		}
};

void funct(void methoder(void*))
{
	methoder("good morning");
}

int main (int argc, char * const argv[]) {

	Py_Initialize();

	addr* t = new addr;
	funct(&t->setPrint);
    return 0;
}

Ich danke für jeden Tipp...

...
Ich danke für jeden Tipp...

Na, dann will ich Dir mal einen geben: Beschreibe, welches Problem Du hast. :p
Ansonsten: zu "pointer to member function" gibt's eigentlich hier im Forum und auch sonst im Netz eine ganze Menge.

Gruß,

Simon2.

Ich sehe bisher immer nur dass überall alle möglichen Beispiele mit den Namespaces laufen, also Beispiel Addr::MemberFunction

Und das so etwas als Argument übergeben wird. Ist es nicht möglich das von Objekt zu Objekt unterschiedlich zu machen?

Ich möchte nämlich etwas in dem Objekt speichern und je nachdem was drinsteht, die Objekte einzeln ansprechen und extern die Member aufrufen, aber wie gesagt, je nachdem was die Objekte drinhaben. So wie es mir scheint, bezieht sich aber die Beispielpalette nur auf die ganzen Klassen selbst, und nicht auf Objekte, oder seh ich das falsch?

Danke für die tipps und Links.

Ich sehe bisher immer nur dass überall alle möglichen Beispiele mit den Namespaces laufen, also Beispiel Addr::MemberFunction

Und das so etwas als Argument übergeben wird. Ist es nicht möglich das von Objekt zu Objekt unterschiedlich zu machen?

Nein. Wenn du 1000 Objekte einer Klasse erstellst, hast du ja schließlich nicht tausendmal die Methode im Speicher. Die Adresse der Methode ist für alle Objekte dieselbe. Du brauchst zum Aufruf immer das Objekt.

suchst du eher eine Lösung mit Polymorphie?

#include <iostream>
#include <string>

// pure virtual class
class BasePrinter {
public:
    virtual ~BasePrinter() {}
    virtual void print(const std::string& str) = 0;
};

class StandardPrinter: public BasePrinter {
public:
    void print(const std::string& str) {
        // mit std::cout schreiben wir auf STDOUT
        std::cout << str << std::endl;
    }
};

class ErrorPrinter: public BasePrinter {
public:
    void print(const std::string& str) {
        // mit std::cerr schreiben wir auf STDERR
        std::cerr << str << std::endl;
    }
};

// test
void func(BasePrinter* p)
{
    if(!p) return;
    p->print("meine ausgabe");
}

int main()
{
    BasePrinter* _out = new StandardPrinter();
    BasePrinter* _err = new ErrorPrinter();

    func(_out); // gibt "meine ausgabe" auf STDOUT aus
    func(_err); // gibt "meine ausgabe" auf STDERR aus

    delete _out;
    delete _err;
}

meinst du so etwas?

Ich danke dir, das ist echt ein super Codeschnippsel zum verstehen.

Ich suche nur noch die Möglichkeit direkt die Adresse von der Methode printf zu übergeben. Geht das irgendwie?

Ich suche nur noch die Möglichkeit direkt die Adresse von der Methode printf zu übergeben. Geht das irgendwie?

int (*f) (const char* , ...);
f = &std::printf;

Macht aber nicht viel Sinn, wenn du ja die Funktion schon kennst, die du aufrufen willst.

In dem Falle bräuchte ich aber die Methode des Objektes

Und da meckert der Compiler rum wenn ich schreibe &myclass->mymethod
und das übergeben möchte hm...

Hi!

In dem Falle bräuchte ich aber die Methode des Objektes

Und da meckert der Compiler rum wenn ich schreibe &myclass->mymethod
und das übergeben möchte hm...

lies die links.

&myclass::mymethod

DonnerCobra schrieb:

Hallo!

Ich sehe bisher immer nur dass überall alle möglichen Beispiele mit den Namespaces laufen, also Beispiel Addr::MemberFunction

Und das so etwas als Argument übergeben wird. Ist es nicht möglich das von Objekt zu Objekt unterschiedlich zu machen?

Ich möchte nämlich etwas in dem Objekt speichern und je nachdem was drinsteht, die Objekte einzeln ansprechen und extern die Member aufrufen, aber wie gesagt, je nachdem was die Objekte drinhaben. So wie es mir scheint, bezieht sich aber die Beispielpalette nur auf die ganzen Klassen selbst, und nicht auf Objekte, oder seh ich das falsch?

Danke für die tipps und Links.

MFK hatte aber einen sehr guten Hinweis. Danke dir.. gut zu wissen.

#include <iostream>

class Standard
{
public:
    void print(const char* str) {
        std::cout << str << std::endl;
    }
};

class Error
{
public:
    void print(const char* str) {
        std::cerr << str << std::endl;
    }
};

template<typename T>
void funct(void (T::*member)(const char*))
{
    T obj; // objekt erzeugen
    (obj.*member)("hallo welt");
}

int main()
{
    funct(&Standard::print);
    funct(&Error::print);
}

das was in C# oder C++/CLI delegates machen.

vielleicht ist ja was brauchbares dabei