class A {
public:

  int& P() { return p; }

private:
  int p;
};

void F(const A& a) {

  // some code ...

  int z=a.P();

  // some code ...

}

class A {
public:

  int& P() { return p; }
  const int& P() const { return p; }

private:
  int p;
};

class A {
public:

  int& P() const { return p; }

private:
  mutable int p;
};

class Foo
{
    int x_;
    int y_;
    int z_;
    .....
public:
    int& x() { return x_; }
    int const& x() const { return x_; }
    .....
    
    void doit(); // что-то полезное
    .....
};

// заменить на:
class FooNaked
{
public:
    // раз уж всё равно к ним есть прямой доступ
    int x_;
    int y_;
    int z_;
    .....
    void doit();
};
// или на
class FooPacked
{
public:
    // предоставить доступ ко всем таким полям одним махом
    struct Settings
    {
        int x, y, z;
    };
private:
    Settings s_;
public:
    Settings& settings() { return s_; }
    Settings const& settings() const { return s_; }
    .....
    void doit();
};

К>class Foo
К>{
К>    int x_;
К>    int y_;
К>    int z_;
К>    .....
К>public:
К>    int& x() { return x_; }
К>    int const& x() const { return x_; }
К>    .....
    
К>    void doit(); // что-то полезное
К>    .....
К>};

К>// заменить на:
К>class FooNaked
К>{
К>public:
К>    // раз уж всё равно к ним есть прямой доступ
К>    int x_;
К>    int y_;
К>    int z_;
К>    .....
К>    void doit();
К>};
К>// или на
К>class FooPacked
К>{
К>public:
К>    // предоставить доступ ко всем таким полям одним махом
К>    struct Settings
К>    {
К>        int x, y, z;
К>    };
К>private:
К>    Settings s_;
К>public:
К>    Settings& settings() { return s_; }
К>    Settings const& settings() const { return s_; }
К>    .....
К>    void doit();
К>};
К>

template< class T >
class InternalParameters {
public:

  T* Ptr() { return m_parameters; }
  T& P(int nIndex) {
    assert(nIndex>=0&&nIndex<4,"Incorrect index");
    return m_parameters[nIndex];
  }
  const T& P(int nIndex) const {
    assert(nIndex>=0&&nIndex<4,"Incorrect index");
    return m_parameters[nIndex];
  }

  T& AU() { return P(I_AU); }
  T& AV() { return P(I_AV); }
  T& U0() { return P(I_U0); }
  T& V0() { return P(I_V0); }
  T& K1() { return P(I_K1); }
  T& K2() { return P(I_K2); }
  T& P1() { return P(I_P1); }
  T& P2() { return P(I_P2); }

  const T& AU() const { return P(I_AU); }
  const T& AV() const { return P(I_AV); }
  const T& U0() const { return P(I_U0); }
  const T& V0() const { return P(I_V0); }
  const T& K1() const { return P(I_K1); }
  const T& K2() const { return P(I_K2); }
  const T& P1() const { return P(I_P1); }
  const T& P2() const { return P(I_P2); }

private:
  enum Indexes { I_AU,I_AV,I_U0,I_V0,I_K1,I_K2,I_P1,I_P2 };
  T m_parameters[4];
};

template<class T>
class InternalParams
{
private:
    enum Index { I_AU, I_AV, ...., I__Count };
    void check(Index i) const { assert(i>=0 && i<I__Count); }
    
    T m_params[I__Count];
    
public: // или всё-таки private?
    T& at(Index i) { check(i); return m_params[i]; }
    T const& at(Index i) const { check(i); return m_params[i]; }

#define DEFPARAM(Id) \
    T& Id() { return at(I_##Id); } \
    T const& Id() const { return at(I_##Id); } \
    //endmacro
    
    DEFPARAM(AU)
    DEFPARAM(AV)
    .....
#undef DEFPARAM
};

_>class A {
_>}
_>

// Намутить еще всякий ук-лей на функции геттеры сеттеры класса-держателя свойства, если логика не тривиальна...
template <class T> 
struct property
{
    property(T t = T()): _t(t)
    {
    }

    // Оператор позволяет взять значение. Для ленивых оформлен как преобразование, но я не сторонник этого.
    operator T() const
    {
        return _t;
    }

    property& operator= (const property& p) // сеттер
    {
        _t = p._t;
        return *this;
    }

private:
    T _t;
};

// Тетовый классец
struct A
{
    property<int> ip;
};

void f1(const A& a)
{
    int y = a.ip;
    // За что боролись: когда объект A - const проперти не может быть ничего присвоено. Только чтение.
    //a.ip = 10; //This is not allowed by compiler!
    printf("%i\n", y);
}

void f2(A& a)
{
    // А здесь все методы доступны
    int y = a.ip; //This allows!
    a.ip = 9;
}

void main()
{
    A a;
    f2(a);
    f1(a);
}

...

// Тетовый классец
struct A
{
      // Нет занудных пар с перегрузкой!
    property<int> ip;
};

...

template <class T>
T const& constify(T const& x)
{
    return x;
}

template <class T>
T volatile const& constify(T volatile const& x)
{
    return x;
}

template <class T>
T& deconstify(T const& x)
{
    return const_cast<T &>(x);
}

template <class T>
T volatile& deconstify(T volatile const& x)
{
    return const_cast<T volatile &>(x);
}

// ---

class SomeClass
{
    X const& getX(. . .) const
    {
        assert(. . .);
        assert(. . .);

        if(. . .)
        {
            throw . . .;
        }

        // и т. д., и т. п.
        
        return someX;
    }

    X& getX(. . .)
    {
        return deconstify(constify(*this).getX(. . .));
    }
};