Всегда ли вызов чистых виртуальных функций косвенно из конструктора неопределенным поведением?

Да, это не определено. Стандарт специально говорит об этом в 10.4 / 6.

Функции-члены могут быть вызваны из конструктора (или деструктора) абстрактного класса; эффект выполнения виртуального вызова (10.3) чистой виртуальной функции прямо или косвенно для объекта, создаваемого (или уничтожаемого) из такого конструктора (или деструктора), не определен.

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

Нельзя предполагать, что виртуальный указатель установлен, пока конструктор не запустится полностью (закрытие "}"), и, следовательно, любой вызов виртуальной функции (или чистой виртуальной функции) должен быть настроен во время самой компиляции (статически привязан вызов).

Теперь, если виртуальная функция является чистой виртуальной функцией, компилятор обычно вставляет свою собственную реализацию для такой чистой виртуальной функции, поведение которой по умолчанию заключается в создании ошибки сегментации. Стандарт не диктует, какой должна быть реализация чистой виртуальной функции, но большинство компиляторов C ++ используют вышеупомянутый стиль.

Если ваш код не вызывает никакого вреда во время выполнения, то он не вызывается в указанной последовательности вызовов. Если бы вы могли опубликовать код реализации для ниже 2 функций

instances().push_back(this);
instances().sort();

тогда, возможно, это поможет увидеть, что происходит.

Пока построение объекта не завершено, чистая виртуальная функция не может быть вызвана. Однако, если он объявлен чистым виртуальным в базовом классе A, а затем определен в B (производном от A), конструктор C (производный от B) может вызвать его, поскольку построение B завершено.

В вашем случае используйте вместо этого статический конструктор:

class check {
private Check () { ... }
public:
    static Check* createInstance() {
        Check* check = new Check();
        instances().push_back(check);
        instances().sort();
    }
...
}

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

Среди прочего, это не особенно надежно: я могу использовать ваши классы Checker, но я могу зарегистрировать их по-другому.

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

Производные классы также имеют защищенные ctors и общедоступный статический метод («именованный шаблон конструктора») для создания экземпляров. Этот метод создания обновляет подкласс Checker, и они передают его (полностью созданный на данный момент) классу CheckerRegister (который также является абстрактным, поэтому пользователи могут реализовать свои собственные, если это необходимо).

Для создания экземпляра Checkerregister и предоставления его подклассам Checker вы используете любой одноточечный шаблон или механизм внедрения зависимостей.

Один из простых способов сделать это - использовать статический метод getCheckerRegister в Checker.

Итак, подкласс Checker может выглядеть так:

class CheckBufferOverrun: public Check {protected: CheckBufferOverrun: Check ("Проверка границ") {// поскольку у каждого производного есть имя, почему бы просто не передать его как аргумент? } public: CheckBufferOverrun makeCheckBufferOverrun () {CheckBufferOverrun, который = новый CheckBufferOverrun ();

   // get the singleton, pass it something fully constructed
   Checker.getCheckerRegister.register(that) ;
   return that;
}

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