Как получить доступ к private-полям класса извне?

Question

Есть учебное задание, в котором необходимо получить доступ к private-полям класса извне. struct Cls дана изначально. Я нагуглил что нужно создать копию структуры, но с public методами, а потом через нее стучаться в изначальную. Вопрос в том как это реализовать? Как можно вернуть ссылку на private поля?

struct Cls {
  Cls(char c, double d, int i);
  private:
      char c;
      double d;
      int i;
  };



 struct B {
  B(char c, double d, int i);
  public:
      char c1;
      double d1;
      int i1;
 };

// Эта функция должна предоставить доступ к полю c объекта cls.
// Обратите внимание, что возвращается ссылка на char, т. е.
// доступ предоставляется на чтение и запись.
char &get_c(Cls &cls) {

    return ((B*)(&cls))->c1 = 'p';

}

// Эта функция должна предоставить доступ к полю d объекта cls.
// Обратите внимание, что возвращается ссылка на double, т. е.
// доступ предоставляется на чтение и запись.
double &get_d(Cls &cls) {
    /* ... */
}

// Эта функция должна предоставить доступ к полю i объекта cls.
// Обратите внимание, что возвращается ссылка на int, т. е.
// доступ предоставляется на чтение и запись.
int &get_i(Cls &cls) {
    /* ... */
}

int main() {
    Cls cls('h', 2.0, 3);
    char ch = get_c(&cls);
    cout << ch << endl;
}

Answer 1

Вы не можете честным и надёжным путём получить доступ к приватным данным. Существуют грубые хаки, наподобие «угадать бинарный лэйаут данных и скастить указатель», которые прямо запрещены стандартом, и дают право компилятору наказать вас в любой момент.

Правильный ответ на вопрос, как получить доступ к приватным данным — никак. Ваш преподаватель либо задаёт вопрос с подвохом, либо плохо знает язык, который преподаёт.

Конкретно в вашем случае, код

(B*)(&cls)->c1

нарушает strict aliasing rule (правило 3.10/10 стандарта).

Дополнительное чтение по теме:

• What is the strict aliasing rule?
• GotW #76: Uses and Abuses of Access Rights.

---

Окей, исходя из развернувшейся дискуссии в ответе @Vlad from Moscow, вопрос о доступе через указатель на «чужой» тип не так уж очевиден даже из стандарта. Как видите, мы покамест не пришли к общему мнению о том, правомерен ли такой доступ по стандарту. В любом случае, доступ к приватным полям — очень плохой стиль программирования, и даже если так возможно сделать, делать этого не нужно.

---

Обновление: Другие ответы: ([1], [2] и [3]) убедили меня в том, что к приватным полям таки можно получить доступ «законным» — то есть, совместимым со стандартом путём. (Впрочем, с трактовкой стандарта в последнем из них я не вполне согласен, но это лишь показывает, что сам по себе стандарт — достаточно большой и не очень ясно написанный текст.)

Тем не менее, любой из приведённых подходов кажется мне грубым хаком, и я бы крайне не рекомендовал пользоваться ими в production-коде. Думаю, будет поучительно, если вы отправите ссылку на это обсуждение вашему преподавателю.

Answer 2

Формально можно обмануть компилятор следующим образом

#include <iostream>

struct Cls {
  Cls(char c, double d, int i) : c( c ), d( d ), i( i ) {}
  private:
      char c;
      double d;
      int i;
  };



 struct B {
  B(char c, double d, int i) : c1( c ), d1( d ), i1( i ) {}
  public:
      char c1;
      double d1;
      int i1;
 };

char &get_c( Cls &cls ) 
{
    void *p = &cls;

    B *pb = static_cast<B *>( p );

    return pb->c1 = 'A';;
}


int main()
{
    Cls cls('h', 2.0, 3);
    char ch = get_c( cls) ;
    std::cout << ch << std::endl;

}    

Вывод программы на консоль:

A

Это совершенно корректный код, так как обе структуры являются layout-compatible и согласно стандарту C++ (3.9.2 Compound types)

3. ...Pointers to cv-qualified and cv-unqualified versions (3.9.3) of layout-compatible types shall have the same value representation and alignment requirements (3.11).

Более подробно: 9.2 Class members:

16 Two standard-layout struct (Clause 9) types are layout-compatible if they have the same number of non-static data members and corresponding non-static data members (in declaration order) have layout-compatible types (3.9).

и 9 Classes:

7 A standard-layout class is a class that:

— has no non-static data members of type non-standard-layout class (or array of such types) or reference,

— has no virtual functions (10.3) and no virtual base classes (10.1),

— has the same access control (Clause 11) for all non-static data members,

— has no non-standard-layout base classes,

— either has no non-static data members in the most derived class and at most one base class with non-static data members, or has no base classes with non-static data members, and — has no base classes of the same type as the first non-static data member.

8 A standard-layout struct is a standard-layout class defined with the class-key struct or the class-key class. A standard-layout union is a standard-layout class defined with the class-key union

Вы также в main могли бы объявить ссылку на объект типа char. Вот более наглядная программа благодаря добавлению дружественного оператора вывода

#include <iostream>

struct Cls {
  Cls(char c, double d, int i) : c( c ), d( d ), i( i ) {}
  private:
      char c;
      double d;
      int i;
    friend std::ostream & operator << ( std::ostream &os, const Cls &cls )
    {
        return os << "c = " << cls.c << ", d = " << cls.d << ", i = " << cls.i;
    }        
  };



 struct B {
  B(char c, double d, int i) : c1( c ), d1( d ), i1( i ) {}
  public:
      char c1;
      double d1;
      int i1;
 };

char &get_c( Cls &cls ) 
{
    void *p = &cls;

    B *pb = static_cast<B *>( p );

    return pb->c1 = 'A';;
}


int main()
{
    Cls cls('h', 2.0, 3);
    char &ch = get_c( cls) ;
    std::cout << ch << std::endl;
    ch = 'B';

    std::cout << cls << std::endl;
Ъ

Ее вывод на консоль:

A
c = B, d = 2, i = 3

Answer 3

Легальный способ - это явная инстанциация шаблона.
Согласно [temp.spec] p6:

Правила доступа не применяются к именам использованным при явных инстанциациях. [ Примечание: в частности, шаблонные аргументы и имена использованные при декларации функции (...) могут быть приватными типами или членами, которые обычно не были бы доступны, и шаблон может быть шаблоном функции-члена класса, которая обычно не была бы доступна. — конец примечания ]

(В оригинале: The usual access checking rules do not apply to names in a declaration of an explicit instantiation or explicit specialization (...))

Это можно использовать следующим способом:
Допустим у нас есть класс

#include <iostream>
class Foo {
    int field;
    void print() { std::cout << field << '\n'; }
};

Мы хотим положить указатели на члены класса field и print в следующие глобальные переменные.

inline int Foo::* Foo_field_ptr;
inline void (Foo::* Foo_print_ptr)();

Напишем шаблонный класс, который принимает указатель на глобальную переменную, и какое-то значение.
В инициализаторе поля _ мы будем присваивать значение переменной.

template<auto* Ptr, auto Val>
class SetVar {
    static const bool _;
};
template<auto* Ptr, auto Val>
inline const bool SetVar<Ptr, Val>::_ = (*Ptr = Val, false);
//                              оператор "запятая" ^

Теперь мы можем инстанциировать SetVar указателем на переменную Foo_field_ptr и указателем на член класса&Foo::field, сработает инициализатор SetVar::_, и значение запишется в переменную.

template class SetVar<&Foo_field_ptr, &Foo::field>;
template class SetVar<&Foo_print_ptr, &Foo::print>;
int main() {
    Foo x;
    x.Foo_field_ptr = 42;
    (x.Foo_print_ptr)();
}

---

Альтернативная версия с использованием функции-друга

// Привязывает член класса к некоторому типу-тегу,
// и определяет функцию, которая возвращает указатель на член класса.
template<typename Tag, auto MemPtr>
class PrivateMemberAccess {
    friend constexpr auto GetPrivateMemPtr(Tag) {
        return MemPtr;
    }
};
// Всмомогательный тип чтобы писать <T> вместо (T{})
template<typename Tag>
static constexpr auto PrivateMemberPtr = GetPrivateMemPtr(Tag{});

Класс-жертва

#include <iostream>
class Foo {
    int field;
    void print() { std::cout << field << '\n'; }
};

Бойлерплейт для доступа к приватным членам класса

struct Foo_field_tag {};
struct Foo_print_tag {};
template class PrivateMemberAccess<Foo_field_tag, &Foo::field>;
template class PrivateMemberAccess<Foo_print_tag, &Foo::print>;
// Если не объявить функцию, то мы не сможем её вызвать.
constexpr auto GetPrivateMemPtr(Foo_field_tag);
constexpr auto GetPrivateMemPtr(Foo_print_tag);

Использование

int main() {
    Foo x;
    x.*PrivateMemberPtr<Foo_field_tag> = 42;
    (x.*PrivateMemberPtr<Foo_print_tag>)();
}

Answer 4

http://ideone.com/gTyt2Q

#include <stdio.h>
#include <stddef.h>

struct cls
{
  public:
    cls(char c, double d, int i) : c(c), d(d), i(i) {}
  private:
    char c;
    double d;
    int i;
};

struct copy
{
  public:
    copy(char c, double d, int i);
  public:
    char c;
    double d;
    int i;
};

int main(void)
{
  cls x('1', 2.5, 3);

  printf
  (
    "%c %f %d\n", 
    *(char*)((void*)&x + offsetof(copy, c)),
    *(double*)((void*)&x + offsetof(copy, d)),
    *(int*)((void*)&x + offsetof(copy, i))
  );

  return 0;
}

Вроде бы в комментариях пришли к выводу, что этот код не содержит UB, поскольку:

• Структуры с одинаковым набором и последовательностью полей имеют одинаковое внутреннее представление.
• Приведение указателя к другому типу не является UB до тех пор, пока не делается его разыменование. Кроме того, в данном коде приведение делается только к void*.
• Добавление смещения к адресу структуры даёт указатель на её поле.
• Указатель на поле приводится к корректному типу, поэтому его разыменование не приводит к UB.

Answer 5

Уже, наверное, неактуально, но всё же оставлю здесь свой вариант)

#include <iostream>
using namespace std;
class lol
{
    int x;
public:
    lol()
    {
        x = 5;
    }
    void pr()
    {
        cout << x << endl;
    }
};
int main()
{
    lol big;
    big.pr();
    int* x = reinterpret_cast<int>(&big);
    cout << x << endl;
    return 0;
}

пробежался по ответам, reinterpret_cast нигде не увидел

Answer 6

А можно и без функций для доступа (и для разнообразия, а то что-то все про union забыли).

int main (int ac, char *av[]) {
  union u {
    struct Cls hidden;
    struct B   B;
  } *up;


  Cls cls('h', 2.0, 3);
  B b('A', 3.14, 10);
  up = (union u *)&cls;

  cout << up->B.c1 << ' ' << up->B.d1 << ' ' << up->B.i1 << '\n';
  up->B = b;
  cout << up->B.c1 << ' ' << up->B.d1 << ' ' << up->B.i1 << '\n';

}

Результат

avp@avp-ubu1:hashcode$ g++ c.cpp -std=c++11
avp@avp-ubu1:hashcode$ ./a.out 
h 2 3
A 3.14 10
avp@avp-ubu1:hashcode$ 

Если же использовать -std=gnu++11, то union можно сделать безымянным, а приведение типа up = (typeof(up))&cls; вот так.

Answer 7

Вам нужно применить паттерн "Паблик Морозов"

#define private public
#define protected public
#include "your class header.h"
#undef private
#undef protected

После такого подключения все закрытые поля класса, объявленного в Yourclass header.h станут пабликами.

Answer 8

class A
{
#ifdef BOOST_TEST_MODULE
public:
#endif