ich hatte den Plan, durch zwei unterschiedliche Member die Mehrdeutigkeit zwischen const und non-const-Versionen von Methoden zu unterscheiden:

template<typename Ret, typename C, typename... Args, typename... Injectors>
	class_& def_nonconst(char const* name, Ret(C::*fn)(Args...), meta::type_list<Injectors...> policies = no_injectors())
	{
		return def(name, fn, policies);
	}

	template<typename Ret, typename C, typename... Args, typename... Injectors>
	class_& def_const(char const* name, Ret(C::*fn)(Args...) const, meta::type_list<Injectors...> policies = no_injectors())
	{
		return def(name, fn, policies);
	}

Leider scheitert die const-Variante daran, dass Methodenzeiger offenbar implizit in in const-Methodenzeiger konvertiert werden können. Ich bin fast überzeugt, dass es keine Möglichkeit gibt, da etwas zu machen, aber vielleicht fällt euch doch noch etwas total gutes dazu ein?

Viele Grüße,
decimad

template<typename Ret, typename C, typename... Args>
class_& def_nonconst( Ret(C::*fn)(Args...) )
{
	return def(name, fn, policies);
}

template<typename Ret, typename C, typename... Args>
class_& def_const( Ret(C::*fn)(Args...) const )
{
	return def(fn);
}

Ret(C::* const fn)(Args...)

?

static_cast<int(Klasse::*)() const>(&Klasse::Methode);

löst die Mehrdeutigkeit auf... Ist das normal, dass ohne einen "Namen" für die Sache das const dahinter stehen darf?

static_cast<int(Klasse::* const)()>(&Klasse::Methode);

kompiliert nicht... Ich wundere mich gerade irgendwie...

#include <iostream>

using namespace std;

struct test {
    void foo() { std::cout << "foo\n"; }
    void foo() const { std::cout << "foo const\n"; }
};

template< typename Ret, typename... Args, typename C >
void do_const( Ret (C::*func)(Args... ) const)
{
    test t;
    (t.*func)();
}

template< typename Ret, typename... Args, typename C >
void do_nonconst( Ret (C::*func)(Args... ))
{
    test t;
    (t.*func)();
}

int main()
{
    do_const( &test::foo );
    do_nonconst( &test::foo );

    return 0;
}

Allerdings hat für mich vorhin alles so ausgesehen, als würde 2013RC genau hier bei do_const eine Mehrdeutigkeit anmäkeln, darum habe ich mich hier gemeldet. Ich kann das erst morgen wieder nachprüfen, leider.

Bitte nicht falsch verstehen, ich will nicht rumnörgeln, ist reine Neugier.

Viele Grüße

#include <iostream>

class test_class
{
public:
    void test(int) const { std::cout << "const\n"; }
	void test(int)       { std::cout << "nonconst\n";  }
};

template<typename FnType>
int def(FnType fn)
{
	test_class t;
	(t.*fn)(4);
	return 2;
}

template< typename... Args >
struct meth_cast {
	template< typename Class, typename Ret >
	static auto cast_const( Ret(Class::*fn)(Args...) const )-> decltype(fn)
	{
		return fn;
	}

	template< typename Class, typename Ret >
	static auto cast_nonconst( Ret(Class::*fn)(Args...) ) -> decltype(fn)
	{
		return fn;
	}
};

int main(int argc, char* argv[])
{
	std::cout 
		<< def(meth_cast<int>::cast_const(&test_class::test))
		<< def(meth_cast<int>::cast_nonconst(&test_class::test));

	return 0;
}

Sowohl VC2013 als auch GCC auf Ideone.com geben aus:

nonconst
const

Irgendwas verpeile ich doch hier extrem maximal?

Viele Grüße & einen schönen Tag noch!

Hab' ich mal gemeldet - aber ich sollte mich wohl sowieso nicht so sehr auf IntelliSense verlassen...

Ja, es ist allgemein bekannt dass IntelliSense viele false positives liefert. Daher: Gerade bei C++11 & co. einfach ignorieren.