Vielleicht erinnert ihr euch noch an diesen Thread, ich konnte jetzt den Umstand ausnutzen, dass VC++ beim letzten Argument doch den nullptr als default akzeptiert. Zusammen mit decltype sieht das jetzt mMn sehr schön aus, mal davon ab, dass Intellisense darauf abraucht:

#include <iostream>

template< typename ValueType, typename ClassType, ValueType(ClassType::*Getter)() const = nullptr >
struct getter {
	static ValueType get(const ClassType* this_)
	{
		return (this_->*Getter)();
	}

	static bool is_null() {
		return Getter == nullptr;
	}
};

template< typename ValueType, typename ClassType, void(ClassType::*Setter)(ValueType) = nullptr >
struct setter {
	template< typename ValInType >
	static void set(ClassType* this_, ValInType&& val)
	{
		(this_->*Setter)(std::forward<ValInType>(val));
	}

	static bool is_null() {
		return Setter == nullptr;
	}
};

template< typename ValueType, typename ClassType, bool(ClassType::*Validator)(ValueType) const = nullptr >
struct validator {
	static bool validate(const ClassType* this_, const ValueType& val) {
		if (!is_null()) {
			return (this_->*Validator)(val);
		}
		else {
			return true;
		}
	}

	static bool is_null() {
		return Validator == nullptr;
	}
};

template< typename ValueType, typename ClassType, void(ClassType::*Options)() = nullptr >
struct options {
	static void option()
	{}
};

template < typename ValueType, typename ClassType,
	typename Getter,
	typename Setter = setter<ValueType,ClassType>,
	typename Validator = validator<ValueType,ClassType>,
	typename Options = options<ValueType,ClassType>
>
struct StaticProperty
{

	ValueType get(const ClassType* this_) {
		return Getter::get(this_);
	}

	template < typename ValTypeIn >
	void set(ClassType* this_, ValTypeIn&& val)
	{
		Setter::set(this_, std::forward<ValTypeIn>(val));
	}

	template < typename ValTypeIn >
	void validate(ClassType* this_, ValTypeIn&& val)
	{
		Validator::validate(this_, std::forward<ValTypeIn>(val));
	}
private:

};

template< typename... Types >
struct type_list
{};

template< typename Ret, typename Class, typename... Args >
struct method_types {
	using ret_type = Ret;
	using class_type = Class;
	using arg_types = type_list<Args...>;
};

template< typename ClassType, typename Ret, typename... Args >
method_types<Ret, ClassType, Args...> deduce(Ret(ClassType::*arg)(Args...) const);

#define StaticPropertyR(Getter) \
	StaticProperty< typename decltype(deduce(Getter))::ret_type, typename decltype(deduce(Getter))::class_type, \
		getter< typename decltype(deduce(Getter))::ret_type, typename decltype(deduce(Getter))::class_type, Getter > \
	>

#define StaticPropertyRS(Getter,Setter) \
	StaticProperty< typename decltype(deduce(Getter))::ret_type, typename decltype(deduce(Getter))::class_type, \
		getter< typename decltype(deduce(Getter))::ret_type, typename decltype(deduce(Getter))::class_type, Getter >, \
		setter< typename decltype(deduce(Getter))::ret_type, typename decltype(deduce(Getter))::class_type, Setter > \
	>

#define StaticPropertyRSV(Getter,Setter,Validator) \
	StaticProperty< typename decltype(deduce(Getter))::ret_type, typename decltype(deduce(Getter))::class_type, \
		getter< typename decltype(deduce(Getter))::ret_type, typename decltype(deduce(Getter))::class_type, Getter >, \
		setter< typename decltype(deduce(Getter))::ret_type, typename decltype(deduce(Getter))::class_type, Setter >, \
		validator< typename decltype(deduce(Getter))::ret_type, typename decltype(deduce(Getter))::class_type, Validator > \
	>

struct test_class {
	test_class() {
	}

	int get_property() const {
		return value_;
	}

	void set_property(int value) {
		value_ = value;
	}

	bool validate(int value) const {
		return true;
	}

private:
	int value_;
};

StaticPropertyR(&test_class::get_property) my_prop;
StaticPropertyRS(&test_class::get_property, &test_class::set_property) my_prop2;
StaticPropertyRSV(&test_class::get_property, &test_class::set_property, &test_class::validate) my_prop3;

int main()
{
	test_class test;

	my_prop3.set(&test, 4);
	std::cout << my_prop3.get(&test);

	return 0;
}