Странное поведение при множественном наследовании QObject Опции

[aljeshishe]

BRE, ничего не изменилось

Хм, сделал наследование каком к верху, т.е. "А" первый, тогда получаю единичку.

Тут имеет значение порядок наследования.
В первом случае в памяти имеем (объект класса B ):
int a;
<данные QObject>
int b;

Во втором случае:
<данные QObject>
int a;
int b;

Т.е. смещение переменной a будет разным и компилятор не может правильно рассчитать смещение при обычном привидении типа (void* -> A*).
А вот если указатель сначала привести к B*, а потом к A*, то все будет нормально.

Провел несколько экспериментов с порядком наследования, скажите правильно я понял, что:
1. Сначала в памяти идут виртуальные базовые классы в порядке наследования
2. затем невиртуальные классы в порядке наследования
3. в конце идет дочерний класс

И еще вопросик, как располагается в памяти виртуальное наследование ?

[ViGOur]

Не совсем так, получается примерно так, когда ты создаешь объект класса B создаются аргументы данного класса в такой последовательности:

vpointer *p; // создается неявно компилятором
int a;
int b;

после чего, когда ты приводишь объект класса B к классу A, то аргументу класса A a присваивается значение p (что тот, что другой 4 байта), так как если создать объект класса А, то создается только:

int a;

Если же в классе А добавить ключевое слова virtual деструктору, то создается таблица виртуальных методов и указатель на нее, то есть получается следующая картина:

vpointer *p;
int a;

и все приводится без проблем.

[BRE]

Ой, не являюсь знатоком стандарта, поэтому точно сказать не могу. Может это прописано в стандарте, а может это остается на совести конкретного компилятора.
Попробуй найти эту информацию в книгах/интернете.
Если после своего исследования отпишишся здесь, думаю не только я скажу спасибо.

[frg10]

void* p = new B;
A* a = (A*)p;

Не делайте так больше никогда. Компилятор не знает ничего о том, что находится по указателю p, поэтому не может корректно привести типы.
Вот так правильно:

    B* p = new B;
    A* a = (A*)p;

[Litkevich Yuriy]

Если же в классе А добавить ключевое слова virtual деструктору

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

[ViGOur]

Достаточно одного виртуального метода, не обязательно деструктора, даже если этот метод в родительском классе, в производном от него классе, так же создается данная таблица.

[aljeshishe]

void* p = new B;
A* a = (A*)p;

Не делайте так больше никогда. Компилятор не знает ничего о том, что находится по указателю p, поэтому не может корректно привести типы.
Вот так правильно:

    B* p = new B;
    A* a = (A*)p;

Это была выдержка из того что используется в реальном проекте. В различных сторонних библиотеках некоторые методы могут принимать произвольные данные (void*) и эти же данные возвращать. Поскольку менять библиотеку нехорошо приходится приводить свои типы к void*
P.S. Пример был создан в результате безуспешных попыток передать функции QModelIndex QAbstractItemModel::createIndex ( int row, int column, void * ptr = 0 ) свой объект и забрать его обратно через void * QModelIndex::internalPointer () const

[Litkevich Yuriy]

Пример был создан в результате безуспешных попыток передать функции QModelIndex QAbstractItemModel::createIndex ( int row, int column, void * ptr = 0 ) свой объект и забрать его обратно через void * QModelIndex::internalPointer () const

Хм, вроде тут всё относительно просто:

B *p1, *p2;
p1 = new B;
QAbstractItemModel *model = new QAbstractItemModel(....);
model->createIndex(myRow, myColumn, p1);
...
p2 = model->internalPointer();

[aljeshishe]

Хм, вроде тут всё относительно просто:

Согласен, сложного ничего.
В моем случае в дереве хранятся объекты разных типов: пользователи содержат папки, которые содержат сообщения
Пользователи при этом используют сигналы/слоты.
В функциях index, data, parent модели приходится определять какой тип текущего узла. Для этого есть тип Node:

#include <QObject>
class Node
{
public:
    enum NType
    {
        N_USER,
        N_FOLDER,
        N_MSG
    };
    Node(NType tp_): tp(tp_){};
    NType getType() const{return tp;}
    void setType(NType tp_){tp = tp_;}
private:
    NType tp;

};

class Folder : public Node
{
public:
    Folder() : Node(Node::N_FOLDER), b(2){};
    int b;
};
class User : virtual public QObject,  public Node
{
public:
    User():Node(Node::N_USER), b(2){};
    int b;
};
class Msg : public Node
{
public:
    Msg():Node(Node::N_MSG), b(2){};
    int b;
};
int main(int argc, char* argv[])
{
    void* p = new Folder;
    Node* node = (Node*)p;
    return 0;
}

Решил использовать виртуальное наследование вместо полиморфности Node(все равботает). Правильно ли это?


Хорошая статься в тему
http://www.devdoc.ru/index.php/content/view/virtual_base.htm

[Litkevich Yuriy]

виртуальное наследование

никогда не слышал про такое

lass User : virtual public QObject, public Node

За статью спасибо.