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

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

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

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

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

int a;

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

vpointer *p;
int a;

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

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

Не делайте так больше никогда. Компилятор не знает ничего о том, что находится по указателю 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

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

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

Согласен, сложного ничего.
В моем случае в дереве хранятся объекты разных типов: пользователи содержат папки, которые содержат сообщения
Пользователи при этом используют сигналы/слоты.
В функциях 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

никогда не слышал про такоеЗа статью спасибо.