Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » mem_fun (für Männer :))

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
08.12.2003, 21:09 Uhr
(un)wissender
Niveauwart


Ich wollte mal versuchen eine Memberfunktion als normale Funkion(Funktionenobjekt) zu kapseln, aber ich bin wohl zu verwirrt.
Was mache ich falsch und was tue ich hier überhaupt??


C++:
#include <iostream>
using namespace std;

//Das Funktionsobjekt
template <typename retValue, typename className>
class my_mem_fun_t {
    public:
        typedef retValue(className::*function)();
        
        my_mem_fun_t(function fnc) : m_fnc(fnc) {}
        
        retValue operator()(className *name)
        {            
            //Was genau hier schreiben?
            return 0;
        }
    
    private:
        function m_fnc;    
};

//Die Funktion
template <typename retValue, typename className>
my_mem_fun_t<retValue, className>
my_mem_fun(retValue(className::*function)())
{
    return my_mem_fun_t<retValue, className>(function);
}

//Testklasse.
class Dummy {
    public:
        void test();  
};

void Dummy::test()
{
    cout << "test!!" << "\n";        
}

int main()
{
    Dummy dum;
    //Wie aufrufen?
    my_mem_fun(&Dummy::test)(dum);
    return 0;
}



Danke!
--
Wer früher stirbt ist länger tot.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
09.12.2003, 09:54 Uhr
(un)wissender
Niveauwart


Für alle die die Antwort interessiert, so geht es:
(hilfreich war: Memberfunktionen )


C++:
#include <iostream>
using namespace std;

//Das Funktionsobjekt
template <typename retValue, typename className>
class my_mem_fun_t {
    public:
        typedef retValue(className::*function)();
        
        my_mem_fun_t(function fnc) : m_fnc(fnc) {}
        
        retValue operator()(className &name)
        {                      
            return (name.*m_fnc)();  //für pointer ->* nutzen!                    
        }
    
    private:
        function m_fnc;    
};

//Die Funktion
template <typename retValue, typename className>
my_mem_fun_t<retValue, className>
my_mem_fun(retValue(className::*function)())
{
    return my_mem_fun_t<retValue, className>(function);
}

//Testklasse.
class Dummy {
    public:
        void test();  
};

void Dummy::test()
{
    cout << "test!!" << "\n";        
}

int main()
{
    Dummy dum;    
    my_mem_fun(&Dummy::test)(dum);
    //my_mem_fun_t<void, Dummy> mm = my_mem_fun(&Dummy::test);
    //mm(dum);
    return 0;
}



Gruß
--
Wer früher stirbt ist länger tot.

Dieser Post wurde am 09.12.2003 um 09:55 Uhr von (un)wissender editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
09.12.2003, 09:56 Uhr
virtual
Sexiest Bit alive
(Operator)



C++:
template <typename retValue, typename className>
class my_mem_fun_t {
    public:
        typedef retValue(className::*function)();

        my_mem_fun_t(function fnc) : m_fnc(fnc) {}

        retValue operator()(className *name)
        {
            (name->*m_fnc)();
        }

    private:
        function m_fnc;
};
...
int main()
{
    Dummy dum;
    //Wie aufrufen?
    my_mem_fun(&Dummy::test)(&dum);
    return 0;
}


Sollte gehen. Was verstehst Du denn nicht?
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
09.12.2003, 10:11 Uhr
(un)wissender
Niveauwart


Hehe, ich war mit meiner Lösung etwas schneller, aber danke.

Mein Problem war der korrekte Aufruf einer Memberfuntion als Pointer, nämlich das hier:


C++:
return (name.*m_fnc)();  //für pointer ->* nutzen!



Aber jetzt ist wieder alles gut, die C++-Syntax verwirrt mich halt immer noch leicht.

Heißt .* oder ->* eigentlich irgendwie? (Spezieller Name)
--
Wer früher stirbt ist länger tot.

Dieser Post wurde am 09.12.2003 um 10:13 Uhr von (un)wissender editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
09.12.2003, 10:15 Uhr
virtual
Sexiest Bit alive
(Operator)


Nein, das sind ja jeweils zwei Operatoren. Bisher gibt es noch keinen namen dafür, IMHO. Für den rchten (->*) für ich sinnigerweise "Sterndeuter-Operator" vorschlagen.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
09.12.2003, 10:20 Uhr
(un)wissender
Niveauwart


Mal dem guten Stroustrup vorschlagen...
--
Wer früher stirbt ist länger tot.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: