In this post I’d like to share my experiences of linking an external library and code files to an X-Code and Qt project. This task, more than anything, requires a good deal of “glue” information, that is, knowing how and when to do this or that little task to get to the next stage. It’s not too hard, but can be quite time consuming as you scour the net for hints. Hopefully this single write-up will help others.
Archive for the ‘C++’ Category
Qt – 4 Methods Of Adding & Integrating Designer Forms
Aug 23rd, 10
/ 0 Comments
The Qt Designer tool allows us to create forms for our application in a visual manner, freeing us from the tedium of hand-coding. While this saves time, it’s important to understand the various ways Qt creates these forms and by extension, the methods at our disposal to integrate these forms into a larger application.
In this post we’ll look at the 3 main technical options Qt Designer employs to serve this function:
- Aggregation as a pointer member
- Aggregation
- Multiple Inheritance
We’ll also see examples of each method in practice. By the end of this post we should have a good grasp on the various ways we can use Qt Designer to create and integrate designer forms into a larger application.
Threading In Qt 4
Jul 31st, 10
/ 0 Comments
In this quick post we’ll take a look at Qt’s elegant and simple QFuture, QtConcurrentRun, and QFutureWatcher interfaces. Using these classes allows us to consume a QThreadPool thread for a specific function.
This is handy for many operations, and while simplistic in that we’re not synchronizing data, still has many uses, from processing large blocks of images to streaming chunks of data.
In this post we’ll check out some sample code for implementing QFuture.
C++ Performance – Counting Clocks
Jul 18th, 10
/ 0 Comments
Performance computing can be an interesting task to undertake, as it lets us get under the hood of a complex abstraction (C++) and talk to the machine directly.
In the next two posts we’ll take a look at the Fibonacci algorithm used in a few other posts and see just how fast we can make it by looking at loop implementation, data type usage, and assembly code optimizations. In this first post we’ll take a look at some basic timing code, what gcc will do for us using the -O2 flag, then in the second post, see what we can do (if anything) to improve upon the generated code.
C++ 64-bit Inline Assembly Primer – Part 2
Jul 1st, 10
/ 0 Comments
In this series we examine the relationship and implementations of C++ and raw assembly code. In this post we create our own add function in gcc extended assembly.
In the previous post we wrote a short C++ program that loaded two numbers. Despite its simplicity in C++, we saw how the assembly version was comprised of several dozen individual instructions in a rather cryptic format. Much of this complexity stems from the fact that in our sample program we called a function to perform our addition. Calling functions means dealing with a stack, base pointers, and the setup and maintenance of that stack. It means dealing with memory offsets, relative positions, and several other factors. The good news is that at this point we can safely ignore these details. In fact, we will do well to ignore them and focus on just the core competencies of function implementation code. In other words, we’ll let gcc create the function shells, calls, and stack management, we’ll focus on the core logic.
C++ 64-bit Inline Assembly Primer – Part 1
Jun 29th, 10
/ 0 Comments
We can talk directly to our machines in C++ by inserting assembly code via the asm() or extended assembly __asm__ commands.
Doing so allows us to exploit potential performance gains, learn more about our machines, and is in all cases, a fascinating exercise in the lowest level of computer programming.
In this post I want to share a few tips and tricks I’ve learned when using AT&T style syntax on Linux/gcc, and also explain how basic assembly coding works. We’ll start by creating a simple function and checking out the gcc created assembly code. We’ll then take this apart and step through the code to understand how it works.
Porting to the Qt C++ Framework :: Part 4
Jun 2nd, 10
/ 0 Comments
Having created a shell of our app in step 2, porting the image cleaner code in step 3, we’re now at the stage where we can to port our command line XML cleaner code to Qt. At the end of this post we’ll have a fully functioning C++ Qt app.
Porting to the Qt C++ Framework :: Part 3
May 28th, 10
/ 0 Comments
In this part of our series we’ll dive in and start implementing our logic from the command line application to the GUI version.
The goal during this step is to make exclusive use of the Qt frameworks built-in functions and methods for handling these tasks, as the end result must be a cross-platform compatible app.
We’re already getting a valid directory entry from part 2, so the first step in this part is to figure out how we iterate and query files from our base folder.
Porting to the Qt C++ Framework :: Part 2
May 28th, 10
/ 0 Comments
In this post I want to introduce the Qt code I’ve written so far. One of the strengths of the Qt framework is its well supported in NetBeans, but more importantly, by Nokia via the Qt Creator IDE. In fact, Nokia supplies a host of tools, from the IDE and language tools, an Interface Designer, and loads of examples.
At the end of this post we’ll have a shell ready for the actual porting process to being. In other words, a GUI that loads, reacts to button presses, and updates status text.
Porting to the Qt C++ Framework :: Part 1
May 26th, 10
/ 0 Comments
In this post we’ll start the process of porting a simple command line C++ application to the Nokia Qt framework. Well take a quick look at the code in question, then talk about how we’ll port it.
The application in question is a simple tool for cleaning up the export of a Print Publishing CMS system for eventual use in a Web-based CMS. By simple I mean we open a folder and loop through it, diving into sub-folders as needed to:
- Remove all images tagged with a _bw_
- Open XML ’story’ files and remove extra line breaks from headline elements, and clean up content HTML.
The application started as an Apple Xcode project, and has now moved into NetBeans 6.8 on Linux. In the end I hope to learn a good deal about the Qt framework, as well as proper C++ application development.