Блог

В моих приложениях Qt я использую макрос препроцессора для автоматического объявления и регистрации мета-типа:

 #define Q_DECLARE_AND_REGISTER_METATYPE(TYPE) 
    Q_DECLARE_METATYPE(TYPE) 
    static struct TYPE ## _metatype_registrar { 
        TYPE ## _metatype_registrar() { 
            qRegisterMetaType<TYPE>(); 
        } 
    } _ ## TYPE ## _metatype_registrar;
 

Обычно я использую его в заголовочном файле после определения типа, который я хочу использовать в системе метатипов Qt, например:

 struct MyDataType {
    int foo;
    double bar;
};

Q_DECLARE_AND_REGISTER_METATYPE(MyDataType)
 

Это работает, потому что статический экземпляр struct, который он определяет, всегда будет иметь свой конструктор, вызываемый при запуске программы. Я предпочитаю этот подход, потому что теперь мне не нужно отдельно регистрировать каждый тип, о котором я забочусь, где-то в моем коде в начале программы. (Раньше я использовал этот подход, и я часто забывал добавлять туда новые типы, потому что я забывчивый, что приводит к досадным ошибкам во время выполнения.)

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

Технически Qt позволяет вызывать qRegisterMetaType несколько раз для одного и того же типа и игнорирует последующие вызовы. Так что это не приводит к каким-либо ошибкам. Но это по-прежнему кажется мне неэффективным и нечистым. Каждый исходный файл, который содержит заголовок — прямо или косвенно — который использует Q_DECLARE_AND_REGISTER_METATYPE , расширит его до кода, определяющего отдельную статическую структуру, конструктор которой будет выполняться при запуске, засоряя скомпилированный код множеством избыточных структур и функций, все из которых будут выполняться.

Я хотел бы посмотреть, смогу ли я улучшить его, чтобы каждое использование Q_DECLARE_AND_REGISTER_METATYPE для определенного типа приводило к тому, что он выполнял только код, который он расширяет до одного раза для каждого типа во всей программе, и (как что-то вроде цели «растяжения») не создавал избыточных структур, предполагая, что это возможно.

Более конкретно, если файл заголовка foo.h содержит строку Q_DECLARE_AND_REGISTER_METATYPE(Foo) , и файлы a.cpp , b.cpp , и c.cpp все включают foo.h , я хочу, чтобы скомпилированная программа вызывалась только qRegisterMetaType<Foo>(); один раз. И, если возможно, я хочу, чтобы он не создавал несколько избыточных экземпляров _Foo_metatype_registrar .

Если бы не соображения эффективности и чистоты, я бы хотел это сделать, возможно, я смогу изучить некоторые интересные приемы предварительной компиляции C !

Есть ли какой-либо способ сделать это?

Это та проблема, которая может быть решена с помощью одноэлементного шаблона. В двух словах, шаблон singleton гарантирует, что когда-либо будет создан только один экземпляр типа.

Одним из подходов может быть создание внутреннего одноэлементного класса, который реализует ваше регистрационное действие в конструкторе. Затем ваш внешний класс получит экземпляр singleton в своем конструкторе. Независимо от того, сколько static внешних классов создано, внутренний класс является одноэлементным, поэтому его конструктор будет вызван только один раз. Собрав все это вместе, ваш макрос может быть переписан следующим образом:

 #define Q_DECLARE_AND_REGISTER_METATYPE(TYPE) 
    Q_DECLARE_METATYPE(TYPE) 
    static struct TYPE ## _metatype_registrar { 
        class inner { 
            inner() { qRegisterMetaType<TYPE>(); } 
            inner(const inner amp;) = delete; 
            void operator=(const inner amp;) = delete; 
        public: 
            static inner amp; once () { 
                static inner instance; 
                return instance; 
            } 
        }; 
        TYPE ## _metatype_registrar() { 
            inner::once(); 
        } 
    } _ ## TYPE ## _metatype_registrar;
 

Я провел расследование std::call_once , и оно работает.

 #define Q_DECLARE_AND_REGISTER_METATYPE(TYPE) 
    Q_DECLARE_METATYPE(TYPE) 
    static struct TYPE ## _metatype_registrar { 
        TYPE ## _metatype_registrar() { 
            static std::once_flag f; 
            std::call_once(f, qRegisterMetaType<TYPE>); 
        } 
    } _ ## TYPE ## _metatype_registrar;
 

Однако для этого требуется, чтобы вы #include <mutex> и связались с вашей библиотекой потоков, что может показаться странным, если ваша программа не является многопоточной.

Обратите внимание, это предотвратит возникновение нескольких регистраций. Однако ваш метод решения требует, чтобы статические экземпляры были определены в единицах перевода заголовочными файлами, потому что в противном случае вы нарушили бы правило единого определения. Таким образом, приведенные выше решения не решают проблему того, что ваш код завален этими избыточными статическими объектами.

Однако есть способ обойти это, если вы используете шаблоны. C имеет особый случай для шаблонных классов, где с его помощью избыточные определения статических элементов автоматически объединяются в одно определение. Это связано с тем, что шаблоны полностью реализованы в заголовочных файлах, где также обычно определяются его статические члены. Итак, вы могли бы создать общий шаблонный класс для вашего регистратора.

 template <typename T>
class MetatypeRegistrar {
    MetatypeRegistrar () { qRegisterMetatype<T>(); }
public:
    static MetatypeRegistrar _registrar;
};

template <typename T>
MetatypeRegistrar<T> MetatypeRegistrar<T>::_registrar;
 

Обратите внимание, что последние две строки предоставляют определение шаблона для объявления статического члена _registrar .

И теперь вы можете выполнить автоматическую регистрацию в вашем заголовочном файле для вашего типа с помощью этого макроса:

 #define Q_DECLARE_AND_REGISTER_METATYPE(TYPE) 
Q_DECLARE_METATYPE(TYPE) 
template class MetatypeRegistrar<TYPE>;
 

По сути, это явное создание экземпляра шаблона с указанным типом.

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