Поиск объекта памяти.

[apofioz]

Здравствуйте! И опять вопрос:

Создайте класс, содержащий переменные и виртуальные функции. Напи*шите функцию, которая ищет в памяти объект вашего класса и выводит его различные фрагменты. Для этого вам придется поэкспериментировать и опре*делить, где в объекте хранятся указатели VPTR.

class A
{
public:
A() :ch('F'), iv(1), lv(12L), fv(2.71f), dv(3.141592) { }
virtual void f1() { printf("%s %f \n", "This double : ", dv); }
virtual void f2() { printf("%s %c \n", "This character: ", ch); }
//private:
char ch;
int iv;
long lv;
float fv;
double dv;
};

Функция, которую я написал. В main() я через new создаю объект класс и передаю его в функцию. Но как получить доступ к _vftable/vptr ума не приложу, хотя бы как вообще определить, что это _vftable, а не объект поля класса или виртуальная функция? Как вывести содержимое участка памяти, которое, как я предполагаю, отведено под мой класс.
Исхожу из того, что указатель указывает на начало класса, соответственно, если к началу прибавить размер класса, то я попадаю в конец отведённой под мой класс памяти.
Почему размер класса равен 32? ведь 1 + 4 + 4 + 4 + 8 + 4 = 25, а не 32, не ясно.

void func(A* f)
{
printf("%s %i \n", "sizeof(A) = ", sizeof(*f));
printf("%p \n", &*f);
cout << ((&*f) + 0) << endl;
cout << ((&*f) + 4) << endl;
cout << ((&*f) + 5) << endl;
cout << ((&*f) + sizeof(*f)) << endl;
}

int main()
{
A* aa = new A;
func(aa);

_getch();
return 0;
}

Разве может С++ работать с памятью напрямую, кроме new, delete мне ничего неизвестно!

[Алексей1153]

apofioz, 32 - это из-за выравнивания. Чтобы не было выравнивания (хотя, зачем это тут) можно выставить выравнивание

#pragma pack(push,1)
... тут описать класс, выравнивание будет == 1
#pragma pack(pop)

место размещения указателя на виртуальную таблицу вроде бы не задаётся стандартом (могу ошибаться), но обычно этот указатель в начале экземпляра класса. "Визуализировать" можно так:

#include <iostream>
#include <iomanip>
using std::cin;
using std::cout;

class A
{
    virtual void f1() {}
    virtual void f2() {}
};

//без выравнивания
class B:public A
{
    public:
    
    uint8_t  v1{0x11};
    uint32_t v3{0x33333333};
    uint16_t v2{0x2222};

    void f1()override {}
    void f2()override {}
};

//с выравниванием
#pragma pack(push,1)
class C:public A
{
    public:
    
    uint8_t  v1{0x11};
    uint32_t v3{0x33333333};
    uint16_t v2{0x2222};

    void f1()override {}
    void f2()override {}
};
#pragma pack(pop)

int main()
{
    A a;
    B b;
    C c;
    
    auto print_hex=[](const char* name,const auto& x)
    {
        cout<<'\n';
        cout<<name<<":"<<'\n';
        auto beg=(const uint8_t*) &x;
        auto end=(const uint8_t*)(&x+1);
        cout<<std::hex<<std::setfill('0');
        for(auto* p=beg; p!=end; p++)
        {
            cout<<std::setw(2)<<(uint16_t)*p<<' ';
        }
    };

    print_hex("a",a);
    print_hex("b",b);
    print_hex("c",c);

    return 0;
}

a:                                                                                                                                        
30 10 40 00 00 00 00 00                                                                                                                   
b:                                                                                                                                        
10 10 40 00 00 00 00 00 11 09 40 00 33 33 33 33 22 22 13 12 fd 7f 00 00                                                                   
c:                                                                                                                                        
f0 0f 40 00 00 00 00 00 11 33 33 33 33 22 22

в автоматически выровненном экземпляре промежутки между полями заполнены мусором. Указатель оказался 64-битным (компилятор 64 бита)

можно "спровоцировать" более компактное размещение переупорядочиванием полей и без прагмы. Например, если самое длинное поле у нас 32 бита, то можно его разместить первым, а 16 и 8 - после него. Тогда паддинг будет всего 1 байт

[apofioz]

Сообщение от Алексей1153

Чтобы не было выравнивания (хотя, зачем это тут)

Это я спросил ради любопытства, когда получил результат размера класса, через sizeof(), то сомнения одолели, что там добавляет ещё компилятор, откуда такой размер...

#pragma pack(push,1)

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

Сообщение от Алексей1153

auto print_hex=[](const char* name,const auto& x)

Это что за конструкция, функтор? Альтернативный стиль это написание функции для каждого типа?
(&x + 1) почему '+1' и точно попадаете на конец структуры?

Почему бы тогда не написать что то такое:

void print_hex1(const char* name, const B& var)
{
	cout << "\n" << name << ':' << "\n";
	unsigned int sz = sizeof(var);
	const unsigned char* b = (const unsigned char*)&var;
	cout << std::hex << std::setfill('0');
	for (; sz-- > 0;) //прогуляемся по памяти, от начала выделенной области (var) до её (sizeof(var)) конца, с шагом 1. 
	{
		cout << std::setw(2) << (unsigned short int)*b++ << ' ';
	}
}

Не так изящно, но всё же.

Всё равно, спасибо, я бы сам до этого не дошёл. Значит напрямую с памятью работать нельзя, по крайней мере в С++, а если ассемблер подключить?

[Алексей1153]

Сообщение от apofioz

Это что за конструкция

лямбда-выражение

можно заменить на аналогичную шаблонную функцию, но в данном случае мне лямбда показалась удобнее

Сообщение от apofioz

Почему бы тогда не написать что то такое:

тут нельзя будет подставить любой тип. Да и цикл какой-то нечитабельный. А каст адреса константной переменной к неконстантному (unsigned char*) - это совсем плохо

Сообщение от apofioz

Значит напрямую с памятью работать нельзя,

этот код и так "работает напрямую с памятью" (внутри лямбды print_hex)

или что ты имеешь в виду под работой с памятью?

[Алексей1153]

Сообщение от apofioz

(&x + 1) почему '+1'

потому что адресная арифметика

[apofioz]

Сообщение от Алексей1153

этот код и так "работает напрямую с памятью" (внутри лямбды print_hex)

Это память не совсем память это искусственно созданная память для данного эксперимента. Мы же не можем найти по определённому адресу таблицу виртуальных функций...

Сообщение от Алексей1153

или что ты имеешь в виду под работой с памятью?

Имею ввиду работу с памятью на нижнем уровне, насколько возможно, конечно, где можно получить доступ к реальным объектам в реальной памяти, по реальным адресам. Как-то так.

Сообщение от Алексей1153

потому что адресная арифметика

В курсе, что арифметика. Почему тогда + 1 указывает на конец данной области.

addr + sizeof(type) * n;

разве не так.

Сообщение от Алексей1153

тут нельзя будет подставить любой тип. Да и цикл какой-то нечитабельный. А каст адреса константной переменной к неконстантному (unsigned char*) - это совсем плохо

Теперь лучше.