c ++类访问关键字“信号”是什么意思？

Question

I came across a declaration similar to this (names changed per NDA ):

class Foo
{
    int  bar;

 public:
    explicit Foo (Fu *parent = NULL);

 private:
    void somefunc (String);

 signals:        // ??? what does this do ???
    void windowClosed();
};

This is compiled successfully by g++ 4.4.7 (from about 2012). Additionally, vim recognizes it as a keyword similar to public and private by highlighting them in brown. (Dis)similiarly, vim uses green to highlight the keywords namespace , class , void , int , double , float , char , unsigned , etc.

The Stackoverflow code formatter does not highlight signals above like it does public and private !

It has proved quite difficult to Google for this (lots of noise), but I haven't found anything mentioning it, not even on SO. I also looked in the enhancements section of the g++ documentation.

This codebase is large (23+ million lines), oldish (~1998), and has a distinct accent. For example, the same class definition has the class access private slots: before two member functions. So it is possible there is some #define obfuscation or trickery going on, but I can't find it using grep . It is possible g++ has been altered, but its --version output does not indicate modification.

Answer 1

It isn't a keyword, if you're using a framework such as Qt it adds up 'keywords' to the language to provide additional functionality that isn't part of the standard.

In Qt for example this code gets preproccessed by the MOC(Meta-Object Compiler), signals is defined in qobjectdefs.h as #define signals public , the moc checks for this macro to add meta-code and provide the actual signal-slot functionality, the generated code is put into a file with a name such as 'moc_myClass.cpp'.

Answer 2

These are not c++ keywords! c++ will not compile them, unless you include a header from the Qt library which will remove them with the preprocessor using:

//from qobjectdefs.h
#     define slots
#     define signals public

These are "tags" used by the Qt Library Preprocessor (moc, Meta Object Compiler) for processing them.

They mark methods which are used in a signal-slot communication mechanism between objects. moc will process them only if the class is marked with the Q_OBJECT macro, and these classes must inherit from QObject.

From these, moc create a companion class in moc_xxxxx.h and moc_xxxxx.cpp source files, with the necessary code for handling the signal/slot mechanism.

Even if you have Qt headers and libraries, you will generally not be able to link the code without the qmake generated sources.

Answer 3

signals is a macro defined by the Qt framework that is translated to public during compilation while serving as a beacon to Qt's moc preprocessor for implementing observer-like class relations with "signals" and "slots". Other similar Qt macros include slots and Q_SLOTS .