C++ IDE for Linux? [closed]

Question

Initially: confusion

When originally writing this answer, I had recently made the switch from Visual Studio (with years of experience) to Linux and the first thing I did was try to find a reasonable IDE. At the time this was impossible: no good IDE existed.

Epiphany: UNIX is an IDE. All of it.¹

And then I realised that the IDE in Linux is the command line with its tools:

• First you set up your shell
  • Bash, in my case, but many people prefer
  • fish or
  • (Oh My) Zsh;
• and your editor; pick your poison — both are state of the art:
  • Neovim² or
  • Emacs.

Depending on your needs, you will then have to install and configure several plugins to make the editor work nicely (that’s the one annoying part). For example, most programmers on Vim will benefit from the YouCompleteMe plugin for smart autocompletion.

Once that’s done, the shell is your command interface to interact with the various tools — Debuggers (gdb), Profilers (gprof, valgrind), etc. You set up your project/build environment using Make, CMake, SnakeMake or any of the various alternatives. And you manage your code with a version control system (most people use Git). You also use tmux (previously also screen) to multiplex (= think multiple windows/tabs/panels) and persist your terminal session.

The point is that, thanks to the shell and a few tool writing conventions, these all integrate with each other. And that way the Linux shell is a truly integrated development environment, completely on par with other modern IDEs. (This doesn’t mean that individual IDEs don’t have features that the command line may be lacking, but the inverse is also true.)

To each their own

I cannot overstate how well the above workflow functions once you’ve gotten into the habit. But some people simply prefer graphical editors, and in the years since this answer was originally written, Linux has gained a suite of excellent graphical IDEs for several different programming languages (but not, as far as I’m aware, for C++). Do give them a try even if — like me — you end up not using them. Here’s just a small and biased selection:

• For Python development, there’s PyCharm
• For R, there’s RStudio
• For JavaScript and TypeScript, there’s Visual Studio Code (which is also a good all-round editor)
• And finally, many people love the Sublime Text editor for general code editing.

Keep in mind that this list is far from complete.

---

¹ I stole that title from dsm’s comment.

² I used to refer to Vim here. And while plain Vim is still more than capable, Neovim is a promising restart, and it’s modernised a few old warts.

My personal favorite is the CodeLite 2.x IDE.

see: http://www.codelite.org

The decision to use CodeLite was based on a research regarding the following C++ IDE for Linux:

• Eclipse Galileo with CDT Plugin
• NetBeans 6.7 (which is also the base for the SunStudio IDE)
• KDevelop4
• CodeBlocks 8.02
• CodeLite 2.x

After all I have decided to use CodeLite 2.x.

Below I have listed some Pros and Cons regarding the mentioned C++ IDEs. Please note, that this reflects my personal opinion only!

EDIT: what a pity that SOF doesn't support tables, so I have to write in paragraphs ...

Eclipse Galileo with CDT Plugin

Pros:

• reasonable fast
• also supports Java, Perl(with E.P.I.C plugin)
• commonly used and well maintained
• also available for other OS flavours (Windows, MacOS, Solaris, AIX(?))

Cons:

• GUI is very confusing and somewhat inconsistent - not very intuitive at all
• heavy weight
• Only supports CVS (AFAIK)

NetBeans 6.7 (note this is also the base for the SunStudio IDE)

Pros:

• one of the most intuitive GUI I have ever seen
• also supports Java, Python, Ruby
• integrates CVS, SVN, Mercurial
• commonly used and well maintained
• also available for other OS flavours (Windows, MacOS, Solaris)

Cons:

• extremly slow
• heavy weight
• uses Spaces for indentation, which is not the policy at my work. I'm sure this is configurable, but I couldn't find out how to to that

KDevelop4 (note: I did not much testing on it)

Pros:

• commonly used on Linux
• integrates CVS, SVN, Mercurial

Cons:

• the GUI looks somewhat old fashioned
• heavy weight
• very specific to the KDE environment

CodeBlocks 8.02 (note: I did not much testing on it)

Pros:

• reasonable fast

Cons:

• the GUI looks somewhat old fashioned (although it has a nice startup screen)
• the fonts in the editor are very small
• some icons (e.g. the debugger related icons starting/stepping) are very small
• no source control integration

CodeLite 2.x (note: this is my personal favorite)

Pros:

• the best, modern looking and intuitive GUI I have seen on Linux
• lightweight
• reasonable fast
• integrates SVN
• also available on other OS flavours(Windows, MacOS, Solaris(?))

Cons:

• no CVS integration (that's important for me because I have to use it at work)
• no support for Java, Perl, Python (would be nice to have)

1. Code::Blocks
2. Eclipse CDT

Soon you'll find that IDEs are not enough, and you'll have to learn the GCC toolchain anyway (which isn't hard, at least learning the basic functionality). But no harm in reducing the transitional pain with the IDEs, IMO.

A quick answer, just to add a little more knowledge to this topic:
You must definitely check out NetBeans. Netbeans 6.7 has the following features:

• C/C++ Projects and Templates: Supports syntax highlighting, automatic code completion, automatic indentation.
• It has a C/C++ Debugger
• Supports Compiler Configurations, Configuration Manager and Makefile Support (with a Wizard).
• It has a Classes Window, a Usages Window and a File Navigation Window (or panel).
• A Macro expansion view, and also tooltips.
• Support for QT development.

I think it's a perfect (and far better) Visual Studio substitution, and a very good tool to learn C/C++.

Good Luck!

At least for Qt specific projects, the Qt Creator (from Nokia/Trolltech/Digia) shows great promise.

could you clarify a little bit more how it was for you, what you had to change. Maybe you could point me in the right direction by providing some links to the information you used.

My first source were actually the tools' man pages. Just type

$ man toolname

on the command line ($ here is part of the prompt, not the input).

Depending on the platform, they're quite well-written and can also be found on the internet. In the case of make, I actually read the complete documentation which took a few hours. Actually, I don't think this is necessary or helpful in most cases but I had a few special requirements in my first assignments under Linux that required a sophisticated makefile. After writing the makefile I gave it to an experienced colleague who did some minor tweaks and corrections. After that, I pretty much knew make.

I used GVIM because I had some (but not much) prior experience there, I can't say anything at all about Emacs or alternatives. I find it really helps to read other peoples' .gvimrc config file. Many people put it on the web. Here's mine.

Don't try to master all binutils at once, there are too many functions. But get a general overview so you'll know where to search when needing something in the future. You should, however, know all the important parameters for g++ and ld (the GCC linker tool that's invoked automatically except when explicitly prevented).

Also I'm curious, do you have code completion and syntax highlighting when you code?

Syntax highlighting: yes, and a much better one than Visual Studio. Code completion: yes-ish. First, I have to admit that I didn't use C++ code completion even in Visual Studio because (compared to VB and C#) it wasn't good enough. I don't use it often now but nevertheless, GVIM has native code completion support for C++. Combined with the ctags library and a plug-in like taglist this is almost an IDE.

Actually, what got me started was an article by Armin Ronacher. Before reading the text, look at the screenshots at the end of it!

do you have to compile first before getting (syntax) errors?

Yes. But this is the same for Visual Studio, isn't it (I've never used Whole Tomato)? Of course, the syntax highlighting will show you non-matching brackets but that's about all.

and how do you debug (again think breakpoints etc)?

I use gdb which is a command-line tool. There's also a graphical frontend called DDD. gdb is a modern debugging tool and can do everything you can do in an IDE. The only thing that really annoys me is reading a stack trace because lines aren't indented or formatted so it's really hard to scan the information when you're using a lot of templates (which I do). But those also clutter the stack trace in IDEs.

Like I said, I had the 'pleasure' to set my first steps in the Java programming language using windows notepad and the command line java compiler in high school, and it was, .. wel a nightmare! certainly when I could compare it with other programming courses I had back then where we had decent IDE's

You shouldn't even try to compare a modern, full-feature editor like Emacs or GVIM to Notepad. Notepad is an embellished TextBox control, and this really makes all the difference. Additionally, working on the command line is a very different experience in Linux and Windows. The Windows cmd.exe is severely crippled. PowerShell is much better.

/EDIT: I should mention explicitly that GVIM has tabbed editing (as in tabbed browsing, not tabs-vs-spaces)! It took me ages to find them although they're not hidden at all. Just type :tabe instead of plain :e when opening a file or creating a new one, and GVIM will create a new tab. Switching between tabs can be done using the cursor or several different shortcuts (depending on the platform). The key gt (type g, then t in command mode) should work everywhere, and jumps to the next tab, or tab no. n if a number was given. Type :help gt to get more help.

Not to repeat an answer, but I think I can add a bit more.

Slickedit is an excellent IDE.

It supports large code-bases well without slowing down or spending all its time indexing. (This is a problem I had with eclipse's cdt). Slickedit's speed is probably the nicest thing about it, actually.
The code completion works well and there are a large amount of options for things like automatic formatting, beautification and refactoring.
It does have integrated debugging.
It has plug-in support and fairly active community creating them.
In theory, you should be able to integrate well with people doing the traditional makefile stuff, as it allows you to create a project directly from one, but that didn't work as smoothly as I would have liked when I tried it.
In addition to Linux, there are Mac and Windows versions of it, should you need them.