Каков порядок инициализации членов класса?

Инициализация C++ происходит в следующем порядке:

1. Базовые классы, слева направо
2. Переменные-члены в том порядке, в котором они объявлены

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

Поэтому, когда компилятор встречает:

Two two;

Сначала Two::Two начинает выполнение, начиная со списка инициализаторов. Все базы инициализируются через список инициализации, даже если вы не записали его или пропустили инициализацию базового класса. Итак, код, который на самом деле работает, выглядит примерно так:

Two::Two
:
  One(),
  test()
{
  test = "text";
}

Список инициализаторов выполняется перед телом конструктора. Таким образом, One полностью создается до того, как тело Two::Two начнет выполняться.

В свою очередь, One выглядит так:

One::One()
: 
  Base()
{
  string test = "test";
}

А Base пусто:

Base::Base()
{
}

Итак, что происходит, когда выполняется Two two;:

1. Base построен.
2. One построен
3. Автоматическая переменная test создается, инициализируется и уничтожается в контексте One::One.
4. Two::test инициализируется по умолчанию
5. Two::test присваивается значение "текст"

Обратите внимание, что некоторые из них, особенно шаги 4 и 5, могут быть оптимизированы компилятором, если он сочтет это безопасным.

Для класса One инициализация One.test будет инициализирована до вызова Base::Base. Но Two.test будет инициализирован после вызова Base::Base.

Нет. Базы инициализируются перед любым элементом.

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

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

В случае с Two есть одна деталь, которая, вероятно, имеет значение, и я не уверен, что вы знаете, элемент test инициализируется в списке инициализаторов Two, до входа в тело конструктора, а затем присваивается.

Другие ответили на вопрос.
Но следующая демонстрация может быть полезной.

#include <iostream>
class String
{
    public:
        String(char const* d)               {std::cout << "String Constructor: " << d << "\n";}
        String()                            {std::cout << "String Constructor: Default\n";}
        String(String const& rhs)           {std::cout << "String Constructor: Copy\n";}
        String& operator=(String const& rhs){std::cout << "String Assignment\n";}
        ~String()                           {std::cout << "String Destructor\n";}
};

class Base
{
    public: Base()
    {
        std::cout << "Base::Base()\n";
    }
};

class One : Base
{
    String test = "text";
};

class Two : Base
{
    String test;
    public: Two()
    {
        std::cout << "Two::Two\n";
        test = "text";
    }
};

int main()
{
    std::cout << "Trying One\n";
    One     one;

    std::cout << "==========\n\n\n";
    std::cout << "Trying Two\n";
    Two     two;

    std::cout << "==========\n\n\n";
    std::cout << "Trying Base\n";
    Base    b;
}

Результат этого:

> ./a.out
Trying One                    // Outside the class about to start
Base::Base()                  // One: Calls the base constructor first Base
String Constructor: text      // One: Constructs its members.
==========


Trying Two                    // Outside the class about to start
Base::Base()                  // Two: Calls the base construtor first
String Constructor: Default   // Two: Constructs its members next
Two::Two                      // Two: Now entering the body of the constructor
String Constructor: text      //      Builds a string
String Assignment             //      Calls the assignment constructor.
String Destructor             //      Temporary destroyed.
==========                    //


Trying Base
Base::Base()
String Destructor             // Destroys the string in Two
String Destructor             // Destroys the string in One