Frage zu mem_fun_t und mem_fun_ref_t

Programmierer

#include <iostream>
#include <functional>
#include <algorithm>
using namespace std;

class Klasse{
	private:
		int Wert;
	public:
		Klasse(int Wert):Wert(Wert){}

		int Schreibe(void){
			printf("%i \n", Wert);
			return Wert;
		}
};

int main (int argc,char** argv)
{
	Klasse* Array[] = {new Klasse(1),new Klasse(2),new Klasse(3)};

	for_each(Array,
			 Array+3,
			 mem_fun_ref_t<int,Klasse>(&Klasse::Schreibe) // <== geht nicht
			 );
    return 0;
}

Hallo,
kann mir jemand genau erklären warum mem_fun_t geht und mem_fun_ref_t nicht?
Es sollte doch (zumindest in diesem Fall) kein Unterschied machen ob eine Methode über einen Zeiger oder eine Referenz aufgerufen wird.
Hier hab ich den Code von mem_fun_ref_t mitkopiert:

template <class _Ret, class _Tp>
class mem_fun_ref_t : public unary_function<_Tp,_Ret> 
{
	public:
		explicit mem_fun_ref_t (_Ret (_Tp::*__pf)()) : _M_f(__pf)
		{}
		_Ret operator()(_Tp& __r) const 
		{ 
			return (__r.*_M_f)();
		}
	private:
		 _Ret (_Tp::*_M_f)();
};

Dankeschön

MFK

Programmierer schrieb:

kann mir jemand genau erklären warum mem_fun_t geht und mem_fun_ref_t nicht?

Weil du da ein Array von Zeigern hast.

Programmierer

Warum geht dann das?

#include <algorithm>
#include <functional>
using namespace std;

class Klasse
{
	private:
		int Wert;
	public:		
		Klasse(int Wert):Wert(Wert)
		{}
		int Methode(void)
		{
			return 0;
		}
};

int main(int argc,char** d)
{
	Klasse* Array[] = {new Klasse(1),new Klasse(2)};

	mem_fun_ref_t <int,Klasse> Obj(&Klasse::Methode);

	Obj(*Array[0]);

	return 0;
}

Simon2

Programmierer schrieb:

...
kann mir jemand genau erklären warum ... mem_fun_ref_t nicht geht?...

Weil's keine Beine hat.

Merke: "Geht nicht" ist keine Fehlerbeschreibung.
und Merke2: Der Compiler versucht üblicherweise zu sagen, was ihm missfällt.

Gruß,

Simon2.

Dravere

#include <algorithm> 
#include <functional> 
using namespace std; 

class Klasse 
{ 
    private: 
        int Wert; 
    public:        
        Klasse(int Wert):Wert(Wert) 
        {} 
        int Methode(void) 
        { 
            return 0; 
        } 
}; 

int main(int argc,char** d) 
{ 
    Klasse* Array[] = {new Klasse(1),new Klasse(2)}; 

    mem_fun_ref_t<int, Klasse> ObjRef(&Klasse::Methode); 
    mem_fun_t<int, Klasse> ObjPtr(&Klasse::Methode);

    ObjRef(*Array[0]); // <- Referenz wird übergeben!
    ObjPtr(Array[0]);  // <- Zeiger wird übergeben!

    return 0; 
}

Ist das so schwer zu verstehen?

Grüssli