A thread for discussing the best way to do stuff in C++, i.e. best-practices and features that might be unfamiliar to beginners. I made this thread because most of my experience was using C++03 in an environment where STL could not be used, due to a combination of an outdated version of xlC on IBM z/OS (for z/series mainframes), and also due the fact that my previous employer wrote most of its base libraries before the C++98 standard. The point here is that modern C++ (>= 11) is full of useful functionality like constexpr, static_assert, smart pointers, move semantics, and of course the STL containers that can be used to quickly produce useful code that's also type-safe. Better yet, Boost has libraries for graph search algorithms and good ongoing proposals, like a decimal floating point library. To give an example of why I need this thread and why I think other people might be in the same boat, on my github I wrote an example matrix library to support complex numbers, and in it I needlessly reinvented std::complex. No question is stupid, no proposal is ridiculous, and any answers or examples are worth their weight in gold- but good ones are worth their weight in FL-grade diamond. EDIT: Here are some thoughts and observations that I think are especially relevant to C programmers who think C++ is just C with classes, as someone who used to think C++ is just C with classes... The C learning curve has just 1 plateau between being a beginner and fully mastering the core language (minus OS-specific libraries such as POSIX): learning how to pass functions around as data via function pointers and building big projects around this concept. On the other hand, the C++ learning curve has 5-10 plateaus between a beginner and Bjarne Stroustrup. Here are just the 5 I've observed and some hallmarks of someone who has reached each plateau: 1. Dunning-Kruger (unknowingly incompetent) C++ programmers: C-style programming, but with std::string, classes, and occasionally virtual functions (dynamic polymorphism). 2. Basically competent C++ programmers: Using the STL, using RAII idioms where possible, using smart pointers instead of raw pointers, allocating on the heap only when data is too big for the stack (i.e. no unnecessary uses of "new"), and passing non-primitive data by reference. 3. People who should be allowed to work on low-latency systems in C++: Using functors and lambdas instead of function pointers, creating template classes to avoid dynamic polymorphism, implementing custom iterators and streams. 4. People who should be allowed to write books on how to use C++: Using move semantics to pass around data without copying instead of pointers, understanding the general concept of rvalues vs lvalues, implementing custom "new" operators, and occasionally specializing template classes to optimize code. 5. People who should be allowed to architect low-latency systems in C++: Using full-blown template metaprogramming and constexpr instead of C macros to safely inline code. After 5 years of full-time work almost entirely in C++, I'm only somewhere between (3) and (4). To be uncomfortably blunt I don't think anyone with an account on this forum is above 3. If you take the time to learn the "C++ way of writing C++", you can do things in 1 week that take 6 weeks in C. Speaking from experience, you can even write a simple plaintext HTTP client in a day by the time you reach (3), a task which takes 2 weeks in C. Here are some telltale signs you're not fully utilizing C++: 1. Your own code contains void pointer function args and member variables, and you use C-style casts on them instead of static_cast or reinterpret_cast where appropriate. NOTE: usually reinterpret_cast is baaaaaad. 2. You're using raw pointers. 3. You're using smart pointers to data that cannot be null, rather than using references. 4. You're using C stdlib and posix/Win32 API calls that have a higher-level abstraction in the C++ STL. 5. You're allocating small, non-persistent data on the heap, i.e. using "new" to allocate temporary variables. 6. You're aliasing with "typedef" instead of "using". 7. You're using C macros to write inlined code instead of constexpr functions.