I am a fairly competent Java programmer wanting to transition into C++. I find myself back at the beginner stage wondering "Where do I go from here?" My question is: What is the best path I can take to becoming a competent C++ programmer?

Coming from Java?

The most important advice: DO NOT USE "new" -- it doesn't do what you think it does!

On its own (i.e., raw / not in conjunction with unique_ptr or shared_ptr) it opts into using manual memory management, which is not as often necessary as it may seem at first.

Don't:

std::string * horrible = new std::string; // NEVER DO THIS

Do:

std::string good;

That is, prefer automatic memory management (using automatic variables, allocated on the stack) by default.

Only in certain circumstances, when you're *absolutely* sure you _have_ to allocate on the heap (also called "free store" in C++), consider the alternatives (but remember that the cases where you actually _need_ to do so are far rarer than in Java).

The #0 alternative being:

Derived allocatedEarlierDerived; // yes, still on the stack

// ...

Base & refBase = allocatedEarlierDerived; // yes, you can absolutely use references for dynamic polymorphism (so this, on its own, is NOT a reason to use pointers)

// need to store in a container? consider std::reference_wrapper: http://en.cppreference.com/w/cpp/utility/functional/reference_wrapper

The #1 alternative being:

std::unique_ptr<Base> ptrBase(new Derived);

// In C++14 this will become: std::unique_ptr<Base> ptrBase = std::make_unique<Derived>();

The #2 almost last resort (only use after you have carefully considered the preferable alternatives -- assuming that you need to share from the start is often a sign of a sloppy design) alternative being:

std::shared_ptr<Base> ptrBase = std::make_shared<Derived>();

// NEVER: std::shared_ptr<Base> ptrBase(new Derived);

The absolute last resort:

-no, still don't use raw "new", at least not before you thoroughly familiarize yourself with the following:

http://www.informit.com/articles/article.aspx?p=1944072

http://en.cppreference.com/w/cpp/memory/unique_ptr

http://en.cppreference.com/w/cpp/memory/shared_ptr

Not to copy paste, see also, perhaps you'll find some of the links helpful:

http://www.gamedev.net/topic/643070-having-a-hard-time-learning-c/#entry5061820

HTH! :-)

The interesting thing is that the transition from Java to C++ is smooth. There is still some funkiness that makes C++ stands out but the basic concepts early on in the beginning are identical if not similar. Since you are competent in Java, then the object oriented concepts in C++ should be easier to understand. It might sounds scary when you learn the object oriented concepts in C++ but it is the nature of C++. Stick with it and you will enjoy what it has to offer.

#include in C++ is the equivalent of importing statements in Java

cout << in C++ performs the equivalent of System.out.println in Java

cin >> in C++ performs the equivalent of the Scanner object in Java

fstream in C++ performs the similar function of FileInputStream object in Java

the object oriented stuff in C++ is definitely similar in Java along with some new features that is not included in Java.

C++ also introduced a feature called "friends" which you should also take a look at.

There is also using namespace std, something C++ and C# and I think other languages also might have.

For the most part, whenever you transition to a new language there is still plenty of new stuff to learn even by leveraging the concepts from the previous language you have learned. I will let you find the other mysteries during your journey.

Start by doing what you have been doing to be competent in Java: read some and code a lot. That is when the understanding really comes. Start with the basics of C++. It is still necessary but the early concepts are easy to grasp since you have experience with Java. Then start working on the object-oriented material like what other members pointed out.

Good luck!

Any books I should get? Or should I just read online tutorials?

Also, any project suggestions?

Any books I should get? Or should I just read online tutorials?

Also, any project suggestions?

http://www.gamedev.net/topic/643070-having-a-hard-time-learning-c/#entry5061820

One thing I think really helps is zero tolerance for quality problems from the start. It seems like you spend more time up front, but it comes back many-fold because you avoid massive and demoralizing debug sessions later when you have written 3000 new lines of code and have no idea where the bugs are. Even if you wouldn't save any time, it'd still be worth it because you end up understanding more. You'll have some degree of trust in your code and feel good about that instead of feeling like you are walking on quicksand. You'll learn faster to not write those bugs in the first place.

Turn all warnings on in the compiler, and tell it to treat warnings as errors, so your code won't compile as long as there's any warning or error. Of course, when you do get a warning, don't just try to mindlessly suppress it, but figure out what it is and why you are seeing it. If it turns out to be a real problem that could lead into trouble, you fix it. If not, only then you suppress it.

Also, often run the program under a memory checker like Valgrind with all memory leak checks etc. turned on. Again, if anything comes up, immediately stop adding new code and new features. Even if it seems to work, treat the program as "no good" until you have completely fixed the problem and get a clean bill from the checker.

I've been involved in teaching C and C++. We require the above (zero compiler warnings, zero detected memory issues) for any returned assignment work, starting from the very first assignment. Compiler warning = fail, memory issues = massive point deduction.