Russian Qt Forum

C++ (Qt)
#include <QObject>
#include <iostream>
 
class BaseQtShape : public QObject
{
    Q_OBJECT
 
public:
    void animate()
    {
        emit visibleChanged(true);
        emit enabledChanged(false);
        emit positionChanged(5, 7);
        emit sizeChanged(10, 15);
    }
 
signals:
    void visibleChanged(bool visible);
    void enabledChanged(bool enable);
    void positionChanged(int x, int y);
    void sizeChanged(int height, int width);
};
 
class ChildQtShape : public BaseQtShape
{
    Q_OBJECT
 
public:
    void animate()
    {
        BaseQtShape::animate();
        emit scaleChanged(3, 8);
    }
 
signals:
    void scaleChanged(int x, int y);
};
 
class BaseQtLogger : public QObject
{
    Q_OBJECT
 
public slots:
    void onVisibleChanged(bool visible)
    { std::cout << "visibleChanged: " << visible << std::endl; }
    void onEnabledChanged(bool enable)
    { std::cout << "enabledChanged: " << enable << std::endl; }
    void onPositionChanged(int x, int y)
    { std::cout << "positionChanged: " << x << ", " << y << std::endl; }
    void onSizeChanged(int height, int width)
    { std::cout << "sizeChanged: " << height << ", " << width << std::endl; }
};
 
class ChildQtLogger : public BaseQtLogger
{
    Q_OBJECT
 
public slots:
    void onScaleChanged(int x, int y)
    { std::cout << "scaleChanged: " << x << ", " << y << std::endl; }
};
 
int main(int /* argc */, char ** /* argv[] */)
{
    ChildQtShape shape;
    ChildQtLogger logger;
 
    QObject::connect(&shape, &BaseQtShape::visibleChanged, &logger, &BaseQtLogger::onVisibleChanged);
    QObject::connect(&shape, &BaseQtShape::enabledChanged, &logger, &BaseQtLogger::onEnabledChanged);
    QObject::connect(&shape, &BaseQtShape::positionChanged, &logger, &BaseQtLogger::onPositionChanged);
    QObject::connect(&shape, &BaseQtShape::sizeChanged, &logger, &BaseQtLogger::onSizeChanged);
    QObject::connect(&shape, &ChildQtShape::scaleChanged, &logger, &ChildQtLogger::onScaleChanged);
 
    shape.animate();
 
    // Invalid usage. emit must be protected.
    shape.emit visibleChanged(true);
 
    return 0;
}
 
#include "main.moc"
 

C++ (Qt)
#include <iostream>
#include <boost/signals2.hpp>
 
using namespace std;
 
void func( int val1, int val2 )
{
	cout << "Call func: " << val1 << " " << val2 << endl;
}
 
#define	DEF_SIGNAL(name, type)						\
public:												\
	template<typename Slot>							\
	void		connect_##name( Slot slot )			\
	{												\
		m_##name.connect( slot );					\
	}												\
													\
	template<typename Slot>							\
	void		disconnect_##name( Slot slot )		\
	{												\
		m_##name.disconnect( slot );				\
	}												\
private:											\
	boost::signals2::signal<type> m_##name;			\
 
class Demo
{
public:
	explicit Demo() {}
 
	void		emit( int val )
	{
		cout << "Emit signal" << endl;
		m_signal( val, val );
	}
 
	DEF_SIGNAL(signal, void( int, int ) )
};
 
int main()
{
	cout << "Start..." << endl;
 
	Demo demo;
	demo.connect_signal( &func );
	demo.emit( 10 );
 
	return 0;
}
 

C++ (Qt)
template <class, class>
class signal;
 
template <class Friend, class R, class... Args>
class signal<Friend, R(Args...)> 
{
public:
    template <class Slot>
    void connect(Slot slot) { m_sig.connect(slot); }
 
   template <class Slot>
    void disconnect(Slot slot) { m_sig.disconnect(slot); }
 
protected:
    friend Friend;
    boost::signal2::signal<R(Args...)> m_sig;
 
    void emit(Args... args) { m_sig.emit(args...); }
};
 
 
class Demo 
{
public:
    signal<Demo, void( int )> my_signal; 
 
    void emit(int val) { my_signal.emit(val); }
};
 
 
void func( int val )
{
	cout << "Call func: " << val <<  endl;
}
 
int main()
{
    Demo demo;
    demo.my_signal.connect(&func);
    demo.emit(10); // ok
    demo.my_signal.emit(10) // Wrong! my_signal.emit is protected!
 
 
    return 0;
}
 

C++ (Qt)
DEF_SIGNAL( update, void() )
 

C++ (Qt)
template <class Friend, class R, class... Args>
class signal<Friend, R(Args...)> 
{
public:
    template <class Slot>
    void connect(Slot slot) { m_sig.connect(slot); }
 
   template <class Slot>
    void disconnect(Slot slot) { m_sig.disconnect(slot); }
 
protected:
    friend Friend;
    boost::signal2::signal<R(Args...)> m_sig;
 
    void emit(Args... args) { m_sig.emit(args...); }
};
 
class Demo 
{
public:
    signal<Demo, void( int )> my_signal; 
 
    void emit(int val) { my_signal.emit(val); }
};
 

C++ (Qt)
shape.visibleChanged(true);

C++ (Qt)
public:
    void move(int x, int y);
signals:
    void moved(int x, int y);
 

C++ (Qt)
class BaseQtShape : public QObject
{
...
private:
    Q_INVOKABLE void test(bool value)
    { std::cout << "Test: " << value << std::endl; }
};
 
int main()
{
    QMetaObject::invokeMethod(&shape, "test", Q_ARG(bool, true));
}
 

Only the class that defines a signal and its subclasses can emit the signal.

C++ (Qt)
class Demo
{
public:
    enum { visibleChanged,
           enabledChanged,
           positionChanged,
           sizeChanged
       };
 
    template <size_t SignalID, class Slot>
    void connect(Slot slot)
    {
        std::get<SignalID>(signal_map).connect(slot);
    }
 
    template <size_t SignalID, class Slot>
    void disconnect(Slot slot)
    {
        std::get<SignalID>(signal_map).disconnect(slot);
    }
 
    template <size_t SignalID, class ...Args>
    void emit(Args ...args)
    {
        std::get<SignalID>(signal_map)(args...);
    }
 
protected:
    typedef std::tuple< signal<void(bool)>,
                        signal<void(bool)>,
                        signal<void(int, int)>,
                        signal<void(int, int)>> signal_map_t;
 
    signal_map_t signal_map;
};
 
void func(bool)
{
    std::cout << "ok" << std::endl;
}
 
int main()
{
    Demo demo;
    demo.connect<Demo::visibleChanged>(&func);
    demo.emit<Demo::visibleChanged>(true);
    retrun 0;
}
 

C++ (Qt)
class Demo
{
public:
#define SIGNALS \
    X(signal<void(bool)>,       visibleChanged), \
    X(signal<void(bool)>,       enabledChanged), \
    X(signal<void(int, int)>,    positionChanged), \
    X(signal<void(int, int)>,    sizeChanged)
 
#define X(a,b) b
    enum { SIGNALS };
#undef X
 
    template <size_t SignalID, class Slot>
    void connect(Slot slot)
    {
        std::get<SignalID>(signal_map).connect(slot);
    }
 
    template <size_t SignalID, class Slot>
    void disconnect(Slot slot)
    {
        std::get<SignalID>(signal_map).disconnect(slot);
    }
 
    template <size_t SignalID, class ...Args>
    void emit(Args ...args)
    {
        std::get<SignalID>(signal_map)(args...);
    }
 
protected:
#define X(a,b) a
    typedef std::tuple<SIGNALS> signal_map_t;
#undef X
 
    signal_map_t signal_map;
};
 

C++ (Qt)
class Demo
{
public:
    enum { visibleChanged,
           enabledChanged,
           positionChanged,
           sizeChanged
       };
 
    void test()
    {
        emit<visibleChanged>(true);
    }
 
protected:
    template <size_t SignalID, class ...Args>
    void emit(Args ...args)
    {
        std::get<SignalID>(signal_map)(args...);
    }
 
    typedef std::tuple< signals2::signal<void(bool)>,
                        signals2::signal<void(bool)>,
                        signals2::signal<void(int, int)>,
                        signals2::signal<void(int, int)> > signal_map_t;
 
    signal_map_t signal_map;
};
 
template < class Sender >
struct Connector : public Sender
{
    template <size_t SignalID, class Slot>
    void connect(Slot slot)
    {
        std::get<SignalID>(this->signal_map).connect(slot);
        std::cout << "signal " << SignalID << " connected" << std::endl;
    }
};
 
template < class Sender >
struct Disconnector : public Sender
{
    template <size_t SignalID, class Slot>
    void disconnect(Slot slot)
    {
        std::get<SignalID>(this->signal_map).disconnect(slot);
        std::cout << "signal " << SignalID << " disconnected" << std::endl;
    }
};
 
template < size_t SignalID, class Sender, class Slot >
void connect(Sender &sender, Slot slot)
{
   typedef Connector<Sender> Connector;
   Connector &connector = static_cast<Connector &>(sender);
   connector.connect<SignalID>(slot);
}
 
template < size_t SignalID, class Sender, class Slot >
void disconnect(Sender &sender, Slot slot)
{
   typedef Disconnector<Sender> Disconnector;
   Disconnector &disconnector = static_cast<Disconnector &>(sender);
   disconnector.disconnect<SignalID>(slot);
}
 
void func(bool value)
{
    std::cout << "func " << value << std::endl;
}
 
int main()
{
    Demo demo;
 
    connect<Demo::visibleChanged>(demo, &func);
    demo.test();
    disconnect<Demo::visibleChanged>(demo, &func);
    demo.test();
 
    return 0;
}
 

C++ (Qt)
struct Derived : public Demo
{};
 
int main()
{
    Derived derived;
    derived.connect<Demo::visibleChanged>(&func); // or derived.connect<Derived::visibleChanged>(&func); 
    derived.emit<Derived::visibleChanged>(true);
 
}