Qt C++ application framework evangelism

I am normally not much of an evangelist, but after working with Qt C++ on a few different apps, (my first experience was back when it was still trolltech and I was running KDE on Mandrake Linux, ahh the good ol days.) and all I can say is: This is C++?

Qt is the C++ framework of the future, and those who haven’t adopted it should, now, as soon as possible.

A little case study will suffice. I have been working on a project for a few months now and a few days ago it came up that there needed to be plugin architecture integrated into the software so that third party vendors could easily add functionality to the program. Sounds fun huh?

The answer was simple, Qt already has a signals and slots mechanism, asking third party vendors to use Qt isn’t unreasonable, its a dead easy framework to use, and no, it’s not that bloated.

Here were the steps:

  1. Create a standard message definition that can be used to communicate steps and program state
  2. Create a general purpose relay QObject (I called it Telegraph) with a send and receive. It sends, whatever it receives.
  3. Pass the relay object to the library allowing them to connect to the send/receive methods on the object

The entire plugin architecture was up and running in less than an hour, and tested, it hasn’t had an issue yet, though I am sure something might need some finaigling before it ships.

The great thing about it is, plugins can be made in pure Qt with only one header file, the message definitions! Since the hooking up of signals and slots is an abstract process, 3rd party devs just extern a register function that receives a QObject or void * object and the casts it to QObject* and connects the signals and slots. If we decide to change or add in some functionality to the telegrapher, it won’t affect old plugins, and new plugins can subscribe to new features without having to include any code.

Plugins can also connect to the Telegraphs receive slot, which relays whatever it receives to send signal, so any application objects that want to be exposed to plugins can define their own receive slot and connect it to the telegraphs send signal. Any interested party will be notified of an “event” and can choose what to do based on the message and the void * passed with it.

This has already been tested with two way communication, communicating from a Dialog box to the main window etc.

Working with Qt is sometimes like working in Flex/AS3, the signals and slots idea is exactly like event listeners, well more or less. The difference is, you get this functionality for free in a C++ app, and that in and of itself is tremendously useful.

People say that developing C/C++ apps takes along time and that’s why things like RIAs and web based apps will overtake them, that’s partially true, but when you get right down to it, C++ has never been this easy to use, and making an extremely cool app in C++ can take days in Qt whereas without it, it might take months, or even never happen.

So yeah, I feel pretty comfortable making with a little Qt evangelism right now, as it’s really made my life a whole lot easier.

/j

About Jason

I am a 31 year old programmer living in the south of France. I currently work actively in the fields of Ruby/PHP/Javascript and server/website administration.
This entry was posted in c/C++, Qt, Topics, Tutorials and tagged , , . Bookmark the permalink.