Размер объекта - наследника QObject Опции Подписка на тему Сообщить другу Версия для печати Скачать тему Подписка на этот форум Режимы отображения Переключить на: Древовидный Переключить на: Стандартный Линейный

[daorus]

Захотелось мне любопытному узнать, сколько байтов добавляет к классу операция наследования от QObject, но может я что-то не так делаю? Подскажите в чем ошибка-то?

// параметры моей тачки
qDebug() << sizeof(int); // == 4
//
//
class e { public: e(){} };
e ept;
qDebug() << sizeof(ept); // == 1
//
//
class ine { public: ine(){ int a = 5; } };
ine inept;
qDebug() << sizeof(inept); // == 1
//
// #1. что происходит с int a в inept, когда я создаю два экземпляра ine?
//     почему функции не учитываются в sizeof?
//     они что - подобно *.dll'кам, т.е. носят share-характер вне зависимости от кол-ва экземпляров?
//     или просто конструкторы не могут быть inline'овыми?
//
// #2. существует ли какой-то дешевый способ подсчитать
//     стековую стоимость объекта вместе с его функциями   
//     или из-за возможности рекурсивных вызовов
//     получается калейдоскоп, не поддающийся подсчёту?
//     может тогда как-то можно подсчитать стоимость одной функции?
//
//
class eg { public: eg(){ a = 5; }; int a; };
eg egpt;
qDebug() << sizeof(egpt); // == 4
//
// #3. почему egpt == 4, а не egpt == 5, если ept == 1
//
//
class eo : public QObject
{
    Q_OBJECT
public:
    eo() { }
};
eo eopt;
qDebug() << sizeof(eopt); // == 8
//
// #4. неужели сделать потомком QObject'a какой-то класс стоит всего 8 байт?
//     при его навороченной-то функциональности, когда он даже имена типов хранит?
//     чё-то не верится...
//     а как тогда измерить реальную цену наследования от QObject'a?
//
//

[Алексей1153]

daorus, пустой класс имеет размер 1 байт. Это какие-то заморочки, необходимые компилятору (детали не знаю)

class A
{
};

//sizeof(A)==1;

когда класс не пустой (к примеру, произведён от QObject) , то его (класса) размер становится равен размеру QObject (а единичка "пустоты" уже не учитывается)

class A:QObject
{
};

//sizeof(A)==sizeof(QObject);

Если класс сам что-то ещё содержит, то это также учтётся в размере

class A:QObject
{
   char c;
};

//sizeof(A) должен быть ==sizeof(QObject)+sizeof(c);

должен быть - но не обязательно равен, так как происходит ещё выравнивание (на 4 байта, если явно не задано другое)
размер также будет одинаков для таких вариантов:

class B
{
   QObject  o;
   char c;
};

class A:QObject
{
   char c;
};

//sizeof(A)==sizeof(B);

// #4. неужели сделать потомком QObject'a какой-то класс стоит всего 8 байт?
// при его навороченной-то функциональности, когда он даже имена типов хранит?

указатель, например, всего 4 байта занимает

в исходниках нашёл нестатический мембер QObject такой

QScopedPointer<QObjectData> d_ptr;


Сообщение отредактировал Алексей1153 - 4.11.2010, 14:47

[BRE]

указатель, например, всего 4 байта занимает

Ну это не всегда.

[Алексей1153]

BRE, ну так то да. Я для 32-битной системы сказал по привычке

в 64-битной - 8 байтов

[daorus]

указатель, например, всего 4 байта занимает

Т.е. вы намекаете, что QObject внутри себя содержит указатель и поэтому sizeof(наследникQObject) == 8, и стало быть узнать сколько реально весит наследование от QObject понять нельзя, потому что придется под капотом искать QObjectData, а потом замерять sizeof(*d_ptr) и а что содержится в QObjectData хрен знает, там могут быть ещё указатели, а значит ещё объёмы и поэтому установить цену наследования от QObject практически нереально. Ход мыслей верный?

кстати, что показал тест

qDebug() << sizeof(QObjectData); // == 28

уже как говорится вперед

[Алексей1153]

daorus, дык, я ж размер не замерял - я пример привёл, что размер объекта реально может и всего 4 байта составлять.

Насчёт посчитать реальный объём - через ОС API это наверняка возможно (сам не делал, не подскажу). Только нужно задаться вопросом - зачем

Если возник вопрос о том, что затратно наследоваться от QObject, то, может, этого делать просто не нужно ?

Сообщение отредактировал Алексей1153 - 4.11.2010, 16:23

[daorus]

Только нужно задаться вопросом - зачем

хочется знать стоимость привычки. Речь идет о QT-разработке. Хочу узнать, если я на автомате буду объекты наследовать от QObject, чтобы вместо обычного указателя юзать QPointer<>, то сколько мне будет стоить такая привычка. Если она будет стоить, 28 байт на объект, ещё жить можно, а если пол-кило на объект, тогда лучше такую привычку не заводить. Вот собственно и хотел узнать как измерить или может сразу кто цифру назовет, какой размер оверхеда при наследовании от QObject.

[Алексей1153]

daorus, ну не знаю, мне ещё ни разу не пришлось наследоваться от QObject . От его детей - приходилось, но там объектов немного, так что 28 байтов на рожу - это совершенно ни на что не влияет.

Сообщение отредактировал Алексей1153 - 4.11.2010, 16:35

[daorus]

28 байтов на рожу

Согласен. Особенно если функции, которые я включаю в свой объект в счёт не включаются, тогда вообще халява.

[Алексей1153]

daorus, функции располагаются в сегменте кода - и в единственном экземпляре для класса. Конечно же они не добавляют размер кэкземпляру класса.
Исключение - если есть виртуальные функции, то каждая такая функция увеличивает размер экземпляра класса на величину sizeof(void*) (размер указателя)

[daorus]

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

Ну, Лёха, даже не знаю как вас благодарить. Просто счастье, что именно вы смогли найти возможность ответить на мои вопросы. Огромное вам спасибо!

[Litkevich Yuriy]

Ну, Лёха, даже не знаю как вас благодарить

странная комбинация в обращении

[Алексей1153]

сам в шоке до сих пор

[Влад]

daorus, пустой класс имеет размер 1 байт. Это какие-то заморочки, необходимые компилятору (детали не знаю)

Это вытекает из простого требования: каждый объект в памяти должен иметь уникальный адрес. Рассмотри, например, такую конструкцию:

class A {};

A my_array[100];

Если бы sizeof(A) был бы строго равен нулю, каковы были бы &my_array[0], &my_array[1] и так далее до &my_array[99]? Стандарт языка ведь требует, чтобы элементы массива были упакованы плотно, без пустот между ними - на этом строится адресная арифметика. А общий размер массива (sizeof(my_array))? А каковы были бы адреса переменных, объявленных "до" и "после" массива?

Поэтому размер любого объекта (даже "пустого" класса) - не менее 1 байта (а более - делать можно, но весьма бессмысленно, ибо пустой расход памяти). Как только же класс A наследуется от QObject, или же наоборот - от него наследуется какой-то класс (пусть A1, и например, непустой), - конечный класс становится заведомо "непустым", и лишние байты компилятору уже не нужны. Это называется "оптимизацией пустой базы" или "оптимизацией пустого базового класса" - empty base optimization.

[Алексей1153]

Влад, понятно

[kwisp]

#1. что происходит с int a в inept, когда я создаю два экземпляра ine?

тут вопрос неосвещенным остался.
по идее int a рождается в стеке и героически умирает тут же, и нет никакой разницы сколько обЪектов ine создается.
Хотя умный компилятор может и рождать ничего не будет, - оптимизирует вызов к примеру и не будет создавать лишнюю неиспользуемую переменную. Хотя там предупреждение должно быть что она неиспользуемая.