Java has been my choice programming language for many, many years now, and I want to start doing C++. I've written in C++ before, but that was a while back. I'm treating myself as a beginner at the moment.

I use Eclipse to write Java, and I recently updated my Eclipse to write C++. Eclipse lists out Standard Make C++ project and Managed Make C++ project. What's the difference?

Also, when writting in java, especially in eclipse, you have a project folder, a source folder, a package and then the class files. Is there a similar setup I can follow with C++?


Edited by glenak: n/a

7 Years
Discussion Span
Last Post by glenak

In very basic terms, a managed make project frees you from having to work directly with the makefiles needed to build your project. Conversely, a standard make project requires that you build, and maintain, the makefile for your project.

Using Google will surely give you better details and specifics about each. For example, on the SaltyCrane Blog:

Standard Make

* Re-uses existing makefiles
* Simple integration with arbitrary build systems
* Parsing of toolchain output to generate error markers

Managed Make

* Manages compiles and toolchain directly
* No makefile editing
* Fine control over compile, link settings

If you visit the blog yourself, you will find a couple of links that will help you better understand the CDT IDE. I know that I have bookmarked that link for later reading. :)


>>Also, when writing in java, especially in eclipse, you have a project folder, a source folder, a package and then the class files. Is there a similar setup I can follow with C++?

When you get into C++, you enter the land of the Free. One beautiful thing with C++ is that there are essentially no structural rules (only syntactic rules for the code) (note: this is something that really bugged me in the bits of Java I have done, to be shackled in a fixed, forced code structure).

This does not mean there are no _conventions_ used by most programmers. Below is the structure that I usually take and most code I have seen are organized similarly. This is for a program you are developing (so installs are local for testing), to release it you would just compile the src directory into a package or installer.

/trunk/: the very top level folder
/trunk/src/: the top level folder for all the source code (headers and cpp are mixed), this is the only "needed" folder
/trunk/lib/: where you dump the intermediate outputs (static and shared libaries)
/trunk/bin/: where you dump the final outputs (applications)
/trunk/include/: if a library: where you put the headers (copied from "src", i.e. "frozen" with the library releases)
/trunk/src/build/: run the "make" in another directory (out-of-source build) just to keep the src directory clean (especially important for Xplatform programming)
/trunk/src/lib1/ /trunk/src/lib2/ ..: its a good idea to organize the source files with respect to the libraries or binaries they compile to.

As for the standard make vs. managed make. As a beginner, don't wander off in the realm of makefile editing... it's a nightmare (especially if the project grows in any significant way). I strongly recommend "cmake", but I'm not sure how well it interfaces with Eclipse. But surely their built-in tool "managed make" will serve all the purpose you will need it for (at least for a good while).

Votes + Comments
Very informative and on topic.

Thanks, you guys. Can't wait to start writing codes in c++!

This question has already been answered. Start a new discussion instead.
Have something to contribute to this discussion? Please be thoughtful, detailed and courteous, and be sure to adhere to our posting rules.