Ich habe mir überlegt eine private Funktion zu schreiben und sie in beiden nur noch aufzurufen. Eine andere Idee ist die get() const; in get(); aufzurufen, aber hier weiß ich nicht wie ich dem Compiler sagen kann dass es sich hier nicht um seine eigene Funktion handelt, damit würde das Programm in einer Endlosschleife landen. Oder habt ihr noch eine bessere Möglichkeit ?

struct X
{
    T const& x() const { return x_; }
    T&       x()       { return const_cast<T&>(static_cast<X const*>(this)->x()); }

private:
    T x_;
};

struct X
{
    T const& x() const { return const_cast<X*>(this)->x(); }
    T&       x()       { return x_; }

private:
    T x_;
};

#include <type_traits>

template <typename T>
struct add_inner_const
{
    using type = typename std::remove_pointer<T>::type const*;
};

template <typename T>
using add_inner_const_t = typename add_inner_const<T>::type;

#define CALL_CONST(...) const_cast<decltype((this->__VA_ARGS__))> \
    (const_cast<add_inner_const_t<decltype(this)>>(this)-> __VA_ARGS__)

struct X
{
    struct T {};

    X() {}

private:
    T x_;

public:

    T const& x() const {return x_;}
    T& x() {return CALL_CONST(x());}
};

int main()
{
    X o;
    X const oc;
    o.x();
    oc.x();
}

P.S.:

auto x() const -> decltype((x_)) {return x_;}
	auto x()       -> decltype((x_)) {return x_;}

Edit:

Oder wie folgt mit nur einem Cast:

Nein, das ist falsch (und wird ggf. zu undefiniertem Verhalten führen).

Oder wie folgt mit nur einem Cast:

Nein, das ist falsch (und wird ggf. zu undefiniertem Verhalten führen).

Mann muss natürlich annehmen, dass im non-const x() das Objekt nicht verändert wird. Wenn diese Annahme stimmt sollte es kein UB geben oder liege ich da falsch?

Wenn diese Annahme stimmt sollte es kein UB geben oder liege ich da falsch?

Richtig.

Bekomme ich aber einen Compiler-Fehler wenn ich aus Versehen im non-const x() ein Objekt verändere, oder eine non-const Memberfunktion aufrufe die ersteres tut?

Oder derartiges nachträglich ergänze, möglicherweise sogar nicht als Erstprogrammierer der es vergessen hat, sondern als Zweitprogrammierer der von der const -Memberfunktion gar nichts weiß?

Natürlich nicht. Daher ist dein Ansatz ziemlich frickelig. Bedenke folgendes: Es geht hier wahrscheinlich nicht um getter wie x , sondern komplexere Funktionen. Sonst könnte man doch das return -Statement kopieren.

Das Makro geht doch sicher einfacher, ohne <type_traits> -Header?

Dass Getter-Funktionen das Objekt direkt beim Aufruf ändern, ist doch relativ unüblich.

Warum auf Getter beschränken?

Nachfrager schrieb:

Das Makro geht doch sicher einfacher, ohne <type_traits> -Header?

Klar - du kannst (und solltest vielleicht) add_inner_const so umschreiben:

template <typename T> struct add_inner_const;
template <typename U> struct add_inner_const<U*>
{ using type = U const*; };

#define DEFINE_PAIR( rtype, trailing, decl, ... )   \
	rtype trailing decl {__VA_ARGS__}             \
	rtype const trailing decl const {__VA_ARGS__}

struct X
{
	struct T {};

	X() {}

private:
	T x_;

public:

	DEFINE_PAIR( T, &, x(), return x_; )
};

#include <type_traits> // Lediglich zu Testzwecken

int main()
{
	X o;
	X const oc;
	o.x();
	oc.x();
	static_assert( std::is_same<decltype((o .x())), X::T      &>::value, "" );
	static_assert( std::is_same<decltype((oc.x())), X::T const&>::value, "" );
}

Damit werden zwei Memberfunktionen definiert die sich lediglich im Rückgabetyp und im const -qualifier unterscheiden.
Lässt sich dann zu

#define DEFINE_GETTER_PAIR( rtype, trailing, decl, ... )      \
	rtype trailing decl {return (__VA_ARGS__);}                       \
	rtype const trailing decl const {return (__VA_ARGS__);}

erweitern.