Mir macht mal wieder die STL zu schaffen. Die Folgenden Zeilen liefern mir komische Fehler:

void print_help() {
	std::wcout << L"Hilfe:\tshutdown\t- Fährt den Server herunter\n"
		   << L"\thelp\t- Zeigt das Hilfemenü\n";
}

std::map<std::wstring, void ()> command_table;
command_table.insert(std::make_pair(L"help", print_help));

error C2752: 'std::tr1::_Remove_reference<_Ty>' : more than one partial specialization matches the template argument list (irendwo in <type_traits>)

error C2528: 'abstract declarator' : pointer to reference is illegal

error C2528: 'type' : pointer to reference is illegal

Bin wohl wirklich blind...

warning C4180: qualifier applied to function type has no meaning; ignored	(diesmal in <map>)

command_table[L"help"] = print_help;

error C3853: '=': re-initializing a reference or assignment through a reference-to-function is illegal

#include <string>
#include <iostream>
#include <map>

void print_help() {
	std::wcout << L"Hilfe:\tshutdown\t- Fährt den Server herunter\n"
			   << L"\thelp\t- Zeigt das Hilfemenü\n";
}

int main() {
	std::map<std::wstring, void (*)()> command_table;
	command_table.insert(std::make_pair(L"help", print_help));
}

Sind die 3 Fehler. Ich benutze Visual C++ Express 2010.

Schreibe ich void () bekomme ich noch die Warnung, schreibe ich nur void (*)() bekomme ich nur die 3 Fehler.

Hier sind ja auch STL-Probleme aufgeführt:

http://blogs.msdn.com/vcblog/archive/2009/05/25/stl-breaking-changes-in-visual-studio-2010-beta-1.aspx

Die haben irgendwas mit den neuen Rvalue-Referenzen und Perfect Forwarding zerschossen, denke ich. Och menno...

#include <string>
#include <iostream>
#include <map>

void print_help (int) {
	std::wcout << L"Hilfe:\tshutdown\t- Fährt den Server herunter\n"
			   << L"\thelp\t- Zeigt das Hilfemenü\n";
	}

template <typename T, typename R>
struct fun_ptr : std::unary_function<T, R> {
	fun_ptr(R (*param)(T))
		: ptr(param) {
	};

	R operator()(T p) {
		return ptr(p);
	}

private:
	R (*ptr)(T);
};

int main() {
	typedef fun_ptr<int, void> fun;

	std::map<std::wstring, fun> p;
	fun f(print_help);
	p.insert(std::make_pair(L"help", f));
}

Geht das kürzer? Und vor allem: dass ich Funktionen benutzen kann, die keinen Parameter nehmen?

#include <string> 
#include <iostream> 
#include <map> 

void print_help() { 
    std::wcout << L"Hilfe:\tshutdown\t- Fährt den Server herunter\n" 
               << L"\thelp\t- Zeigt das Hilfemenü\n"; 
} 

int main() { 
    std::map<std::wstring, void (*)()> command_table; 
    command_table.insert(std::make_pair(L"help", &print_help)); 
	return 0;
}

Früher funktionierte dies nicht:

void (*f)() = &print_help;
	(*f)();

Anscheiend haben Sie doch in C++0x sinnvolles hinzugefügt.

Edit: Dein letztes Beispiel ist doch für C++98 vollkommen konform? Es funktionier auf jeden Fall in VS 2008, auch wenn man doch lieber das schreiben sollte:

void (*f)() = print_help;
f();

command_table[L"help"] = &print_help;

typedef void(*funcPtr)();

std::map<std::wstring, funcPtr> command_table;

command_table.insert(std::make_pair(L"help", &print_help)); // & ist notwendig

command_table[L"help"]();

Getestet in VS 2010.

Nochmal eine kurze Nachfrage...
Wofür steht das L vor dem "Test" String?
Weiß nämlich nicht, wie ich mir eine Antwort ergooglen könnte ^^

Eine Zeichenkette mit dem Präfix L, wie etwa

L"help"

ist eine Zeichenkette von WideChars. Ihr Typ ist

const wchar_t[]

I[...]Ob man nun vor der Funktion '&' schreibt oder nicht ist bei Nicht-Elementfunktion doch AFAIK egal[...]

Nein, ist es nicht. Wie bei allen Dingen für die man eine Referenz haben will, muss man auch bei Funktionen den Referenzoperator davor schreiben.

Wie wäre es denn mit function Objekten?

> Nein, ist es nicht. Wie bei allen Dingen für die man eine Referenz haben will, muss man auch bei Funktionen den Referenzoperator davor schreiben.

Ich will ja keine Referenz, sondern einen Zeiger. Und Funktionen bilden da eigentlich eine Ausnahme, wo man den Adress-Operator nicht angeben muss. In meinen anderen VS 2008-Implementierungen habe ich es auch so gemacht, und ich glaube mich zu erinnern, dass in "Die C++ Programmiersprache" ein ähnliches Beispiel zu finden war. Oder ich habe da noch eine gewaltige Wissenslücke gehabt.

Auf jeden Fall danke für die Hilfe!

Oder ich habe da noch eine gewaltige Wissenslücke gehabt.

Nein, so wie Arrayausdrücke beim kleinsten Anzeichen von Gefahr in einen Zeiger umgewandelt werden, werden (lvalue-)Funktionsausdrücke ebenso implizit in Funktionszeiger umgewandelt wenn nötig (4.3). Zusätzlich wird - was hier bei make_pair eine Rolle spielt - eine Funktionsargument als Funktionszeiger deduziert (14.8.2.1/2 2. Alt).