Skip to content

Windows C++ IDEs – Part Two

June 23, 2011

In this second part of my quick tour of available C++ IDEs for Windows, I will consider the two main Open Source contenders. Before doing so, I should issue a statement of interest – I have been a mostly happy Code::Blocks user for the past few years.


Code::Blocks is a cross-platform IDE (it is available for Windows and most Linux distros) based on the wxWidgets toolkit. The size of the download will vary depending on whether you want to install the GCC compiler at the same time. Downloads are available from and I recommend you use the larger of the two Windows downloads, as it is the quickest way to get started. However, in this post I am actually discussing a later version, SVN 7040, which is what the Code::Blocks community calls a “nightly build”. Code::Blocks is being actively developed, and the best way to get new goodies as they are added. To learn how to use these builds, and to track changes, go to the Code::Blocks User Forums, and take a look at the Nightly Builds group.

On starting Code::Blocks (which I will refer to henceforth as CB) your first impression may not be to great, particularly when you compare it with Visual C++. I think “utilitarian” would be the mot juste. Still it is not actually repulsive, and selecting “Create New Project” goes through the expected series of Wizard dialogs. The resultant console project consisted of a single CB configuration file and a “hello world” main.cpp source file, which I immediately removed from the project. Adding my own files to the project was easy, and both recursive (add all files in a tree) and non-recursive options are provided.

When I tried to build the nclip project, I had the same (expected) problems with include paths as I had with VC++. Adding the path took more clicks than should really be necessary, but CB has a neat feature that VC++ seems to lack – it will optionally turn the path into a relative one, which is handy if your project will ever be moved, which it probably will be. Compiling was no problem, and I was not required to turn off Unicode. I also had no problems running the executable from the IDE – there is a big green “Run” button on the CB toolbar.

So far so good. Project setup was a little easier than that for VC++, and getting it to run was much less hassle. Let us now turn our attention to the editor and other IDE features.

In general, the CB IDE is less configurable than VC++, and the configuration dialogs and features have rough edges. One that particularly annoys me is the fact that the colour of the cursor is set in a one-off manner, but it is possible to have both dark and light backgrounds for different file types. This makes the cursor invisible in either the dark or light background, thus negating the utility of the feature. There are also some inexplicable omissions – for example, why isn’t the list of abbreviations available in the editor sorted in alphabetical order? CB is based on a plugin architecture and the plugins that come with it are of variable quality. Those that provide basic support for the IDE do their job well and mostly silently, whereas those that try to provide some sort of GUI are often clunky or even flatly impossible to discern the use of, and I tend to disable these.

The editor itself is workmanlike enough, and in my opinion the code completion feature is better thought out than that in VC++. The CB developers have put a lot of effort into code completion over the past year or so, and this has definitely paid off – what used to be slow and a bit flakey now seems fast and pretty solid.

We now turn to the debugger. CB uses the GCC compiler collection and its gdb debugger by default, and provides integration of gdb within the IDE. It has to be said that this integration is nowhere near as good as that provided by VC++. Particularly, display of C++ Standard Library collection classes is not as good as it is in VC++. For me, this is not really an issue as I rarely use a debugger, but if you spend a lot of time stepping through code, the CB/gdb combination may get old pretty quickly. However, the CB team are currently working hard on the debugging side of things, so debug features may improve significantly quite soon.

To sum up for Code::Blocks, the positives:

  • Open Source
  • Reasonable download size
  • Projects are easy to create and manipulate
  • Good code completion

and the negatives:

  • Could not be called “pretty”
  • Some plugins are clunky
  • gdb debugger


CodeLite is another Open Source, cross-platform IDE based on the wxWidgets toolkit. It is a younger project than Code::Blocks, and it seems does not have so many users or developers. Like CB, it has a plugin architecture.

Starting up, impressions are generally positive – it’s perhaps slightly prettier than CB, but not as good-looking as VC++. One minus point is that it integrates a file system explorer into the IDE, something I never really like.

Creating a new project was a bit involved. First, I had to create a “workspace”. Why did I have to do that? I don’t want or need one. Then I created a console project, which resulted in a total of five files and a subdirectory. The project manager also displays a mysterious thing called “src” which has no reflection in the file structure. This I do not like. Adding the files for my project was made difficult by the complete lack of a “Project” menu – there is only one for that unwanted “workspace”. However, I eventually managed it, by rather a nice little dialog which unfortunately does not offer all the options the Ad and Add Recursive options to in CB.

So now I build the project. The expected errors about missing header appear, but there is something strange about the output. Eventually, I realise what it is – the build system is by default set up to parellelise builds, presumably because I’m using a dual-core machine. This is a very, very bad idea (parallel builds are really for experts), and is I fear symptomatic of the whole CodeLite ethos which seems to be one of doing things it thinks best and hiding them from the programmer. I turn off the parallel build (which was I admit easy to do) and add the necessary include path, which didn’t provide a navigation dialog – I had to type in the path. Once done, the code built and linked with no further problems – once again no need to worry about Unicode. Running the executable was easy – there is a Run option in the Build menu. Now let’s look at the other parts of the IDE.

CodeLite seems to be less configurable than either CB or VC++. In particular, I could find no way of changing the font size in the compiler output/error message panes, which is set to a (for me) uncomfortably small point size. Code completion is good in that it is quick and seems quite accurate, but seems to have a fatal flaw – the completion tooltip window does not go away once you ave finished entering the function call! This may be a bug in the version ( but if so it is a pretty big one.

Turning to the debugger, I had to run it several times before a breakpoint I had set in the IDE was hit. Once it did work, it had approximately the same functionality as CB, but once again we are in gdb land, and the debugging experience cannot match that you get with VC++.

My final impression of CodeLite is of an over-eager puppy. It wants to be liked, and tries to do good things, but ends up falling over its own good intentions. To summarise, the good:

  • Open Source
  • Looks quite nice
  • Reasonable sized download

and the bad:

  • Strange workspace/project structure
  • Inappropriate default values
  • Code completion problems
  • Uses gdb debugger (and debugging seemed a bit flaky)

In the next instalment – Qt Creator, TheIDE and DevC++.

Leave a Comment

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: