
Ask HN: Best way to learn modern C++? - jxub
Do you have some good advice or know any useful resources to learn in a proper way how to code in C++? For the context, I know some C, but C++ seems a different kind of beast, and it&#x27;s easy to get lost in the huge variety of features and libraries it offers.
======
pjmlp
\- Tour of C++
([http://www.stroustrup.com/Tour.html](http://www.stroustrup.com/Tour.html))

\- Principles and Practice Using C++
([http://www.stroustrup.com/programming.html](http://www.stroustrup.com/programming.html))

\- From Mathematics to Generic Programming
([http://www.fm2gp.com/](http://www.fm2gp.com/))

\- The Scott Meyers books

Some of the Bjarne Stroustrup videos,

"Learning and Teaching Modern C++" \-
[https://www.youtube.com/watch?v=fX2W3nNjJIo](https://www.youtube.com/watch?v=fX2W3nNjJIo)

Some of the Herb Sutter videos,

"Writing Good C++14... By Default" \-
[https://www.youtube.com/watch?v=hEx5DNLWGgA](https://www.youtube.com/watch?v=hEx5DNLWGgA)

"Back to the Basics! Essentials of Modern C++ Style" \-
[https://www.youtube.com/watch?v=xnqTKD8uD64](https://www.youtube.com/watch?v=xnqTKD8uD64)

Some of the Kate Gregory videos,

"Stop Teaching C" \-
[https://www.youtube.com/watch?v=YnWhqhNdYyk](https://www.youtube.com/watch?v=YnWhqhNdYyk)

"10 Core Guidelines You Need to Start Using Now" \-
[https://www.youtube.com/watch?v=XkDEzfpdcSg](https://www.youtube.com/watch?v=XkDEzfpdcSg)

"It's Complicated" \-
[https://www.youtube.com/watch?v=tTexD26jIN4](https://www.youtube.com/watch?v=tTexD26jIN4)

~~~
bloodorange
I agree with this completely :)

I would also like to add that it helps to read "The Design and Evolution of
C++".

I found that I plateaued early in my C++ journey. However, I was always
reading from the experts and it really helped to read material from Dr.
Stroustrup. Once I began to see the common thread behind what he was saying
and understood why some things were the way they were, it helped understand
when it's a good time to use/not-use certain things. This helped break past
that barrier and to improve my skill further.

Also, it helped to write a _lot_ of c++ code and think about how that could be
better.

I'm afraid I didn't read a tonne of good C++ code in that period but somehow,
I managed to keep growing and at some point, it became my "go to" language and
I really started to like it.

Long story, short: Read books from the experts, esp. Dr. Stroustrup.

~~~
krylon
> I would also like to add that it helps to read "The Design and Evolution of
> C++".

I think that book is worth reading even to people who have no intention of
going anywhere near C++, as long as they are interested in programming
language design and evolution. I wish there were more books like this one to
explain the kind of thinking that went into the design of a language and to
tell its history.

~~~
vram22
Agreed.

I had commented on the book on HN about a month ago:

[https://news.ycombinator.com/item?id=16275341](https://news.ycombinator.com/item?id=16275341)

Excerpt from it:

"I found that book very interesting in many regards. I had bought and read it
several years ago (out of interest, though I have not worked on C++
professionally).

Stroustrup goes into a lot of details about the reasons for many design
decisions in the language."

That's one of the reasons that make the book interesting. He even goes into
human and cultural aspects of programming.

~~~
scott_s
Agreed on D&E, but I think it really does need an update now.

~~~
cbHXBY1D
I would love a book similar to _C# In Depth_ but for C++. The book takes you
on an evolutionary tour of C#s features, version-by-version. One of my
favorite programming books of all time and a good read even for someone who
doesn't program in C#.

~~~
krylon
I have been using C# at work for a little while now, and I am starting to like
it. Thanks for the suggestion!

------
msaltz
One of the trickier things about C++ for me (in terms of “getting lost”) when
I first started was that there’s no standard C++ project structure. It varies
based on the build system you use, whether what you’re building is just an API
or something else, and personal preference. I recommend looking at some open
source C++ projects like Tensorflow (Google), LevelDB (also Google), folly
(Facebook), MongoDB, and Thrill (a Spark clone in C++,
[https://github.com/thrill/thrill](https://github.com/thrill/thrill)). Also
pick your own projects you’re interested in. Take a look at basic tutorials
for build systems like make, CMake, and Bazel. Hopefully that’ll give you an
idea of what a modern C++ project actually looks like, and will help you start
your own.

For books I’d like to add to the current top comment (may go away) API Design
for C++. It’s a great reference on exactly what it sounds like.

~~~
aloukissas
100% agree - the code quality in some of these projects (e.g. folly) is
outstanding.

------
fsloth
If you want fun miniproject may I suggest Peter Shirley's excellent mini-
raytracing bookseries: Ray Tracing In One Weekend, Ray tracing the next week,
and Ray Tracing, the Rest of Your Life: [https://www.amazon.com/Ray-Tracing-
Weekend-Minibooks-Book-eb...](https://www.amazon.com/Ray-Tracing-Weekend-
Minibooks-Book-ebook/dp/B01B5AODD8)

If you get interested on rendering Matt Pharr & Co's Oscar winning "Physically
based rendering" is a didactic masterpiece.
[https://www.amazon.com/Physically-Based-Rendering-Third-
Impl...](https://www.amazon.com/Physically-Based-Rendering-Third-
Implementation/dp/0128006455)

The book is one of the best examples of how to combine high quality code and
academic exposition together.

~~~
tonetheman
Indeed this is a good project. And a great set of books. I second this!!!!

------
landtuna
Once you've got the basics down from a tutorial (old C++ or modern C++), move
on to internalizing all the lessons here:

[https://isocpp.org/faq](https://isocpp.org/faq) (what Marshall Cline's
excellent C++ FAQ has become)

and here:

[https://herbsutter.com/gotw/](https://herbsutter.com/gotw/) (Not as
organized, but Herb Sutter wrestles with the essential questions of how to
deal with the tricky bits of C++)

If you've got the cash, read Effective Modern C++ by Scott Meyers.

Finally, if you're ready to snark at all you've learned, read the C++ FQA:

[http://yosefk.com/c++fqa/](http://yosefk.com/c++fqa/)

~~~
Suro
I would like to point out that yosefk fqa is a bit old now, and while some
problems mentioned are still relevant, tools and conformity across up to date
compilers are magnitudes better now.

------
vehemos
Also in case anyone is going to suggest something project-like please
something in the direction of HFT/OS/Systems related as opposed to game
programming? There are loads of stuff out there for C++ related to game
programming.

For OP: [https://stackoverflow.com/questions/388242/the-
definitive-c-...](https://stackoverflow.com/questions/388242/the-definitive-c-
book-guide-and-list/388282#388282)

Also some C++ related YT channels such as TheChernoProject, CppCon etc

Following the respective reddit and slack communities is also extremely
helpful.

Also get your hands dirty with this: [https://github.com/vitalets/github-
trending-repos](https://github.com/vitalets/github-trending-repos)

or [https://github.com/fffaraz/awesome-
cpp](https://github.com/fffaraz/awesome-cpp) There is more but this should do.

Oh I almost forgot: [https://ishansharma.github.io/twitter-
mentors/](https://ishansharma.github.io/twitter-mentors/)
[http://stephaniehurlburt.com/blog/2016/11/14/list-of-
enginee...](http://stephaniehurlburt.com/blog/2016/11/14/list-of-engineers-
willing-to-mentor-you)
[https://twitter.com/sehurlburt/status/889004724669661184](https://twitter.com/sehurlburt/status/889004724669661184)

Good Luck! :-)

------
cpfohl
Use it.

Not being a smart@$$ here. Any language you want to learn will only become
natural when you've used it for a significant project or set of exercises.
Either clone or port something non trivial, or use it for your latest pet
project, or get permission to use it at work.

~~~
kdelok
I'd still argue that there's a lot of value in some form of teaching (via book
or video or whatever). If left to their own devices, novices will often come
up with messy, non-idiomatic ways to do things.

~~~
OskarS
I find using both in combination is usually the best way to go. If you're just
reading a book and doing exercises in it, you wont learn as well. Making
something you want to make and using books as reference while developing makes
you learn a lot quicker.

Also, the answer to this question depends a lot on your previous experience
with other languages. If you're well-versed in another C-like language,
jumping right in and starting to make something will probably teach you a lot,
really quickly. If you're more of a beginner in programming generally, you
need a book or a teacher.

------
isaachier
IMO, the classic C++ book/author is still the best: Effective C++. Don't
forget about the sequels, including the mostly overlooked Effective STL (which
I happen to like better than the first two books). And to address the modern
part of this question, I'll add that Scott Meyers has written Effective Modern
C++ as well, but I'd read that last after getting the hang of C++03. No matter
what people say, I tend to believe C++11 and on is not really a different
language as much as it is syntactic sugar to cover up the ugliest parts of
C++.

~~~
dfan
As someone who programmed in "classic C++" for decades, I feel like modern C++
is pretty different, and that it's not just syntactic sugar to make some ugly
things easier. The biggest example is that my natural inclination to use raw
pointers everywhere and manage all memory myself, while idiomatic modern C++
is full of unique_ptrs and shared_ptrs everywhere, and raw pointers seem to be
regarded as a code smell. Converting to this style is not an automatic
process.

For people who are coming from a classic C++ background, I find Bancila's
Modern C++ Programming Cookbook to be a good first stop for discovering modern
C++ idioms.

~~~
isaachier
OK from that perspective I can relate. Even before using C++11 I was using a
lot of the new STL through Boost. If you use Boost, the only fundamental
differences are syntax like auto, variadic macros, constexpr, noexcept, and
lambdas all of which are familiar enough to get by. The only practical
differences that have no equivalent in C++03 is move operations and maybe the
threading/chrono stuff. Effective Modern C++ covers that so that's all I
needed to "upgrade."

------
rambl30n
If you know C, C++ Common Knowledge ([https://www.amazon.com/Common-Knowledge-
Essential-Intermedia...](https://www.amazon.com/Common-Knowledge-Essential-
Intermediate-Programming/dp/0321321928)) will give you a quick run of the
gotchas you're to avoid. From there, move to Scott Meyer's books, which will
give you some good foundational knowledge on how features of the language work
together. In particular I like that each concept is presented in a bite-sized
chapter that you can read in a couple of hours and think about for the rest of
the day. Even though the first two are about "classic C++" I wouldn't skip
them. For a glimpse of the true power of modern C++, check the Boost Hana
library docs, hopefully this will serve you as motivation to keep on going.
Above all, don't do this alone. The compiler errors that you get once you
start applying modern (template) techniques can be a bit of a rabbit hole and
takes a bit to get an eye for deciphering them. Lean on coworkers, local user
groups and/or the C++ slack group which is pretty supportive. Best of luck.

------
steveklabnik
I’m on my phone so I don’t have links, but the last few CPPCons have had talks
by very prominent C++ luminaries talking about how to properly teach C++. They
may be of interest.

The biggest message seems to be “don’t treat C++ as C with extra stuff, it’s
its own language.”

------
mrlyc
Google's C++ course at
[https://developers.google.com/edu/c++/](https://developers.google.com/edu/c++/)
looks useful to start with.

~~~
johndubchak
Don’t forget SFINAE. It’s what most of the modern type traits rely on and
something you’d have to understand, at least conceptually, to fully understand
how to effectively use things like std::enable_if.

~~~
hermitdev
For those unfamiliar with C++, SFINAE is "Substitution Failure Is Not An
Error". The short of it is how the language deals with overload selection with
templates. If you want a more detailed explanation and example, see [1].

[1]
[https://en.wikipedia.org/wiki/Substitution_failure_is_not_an...](https://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error)

------
manca
As others mentioned, Effective Modern C++ by Scott Meyers is a solid modern
C++ book with nice tips and tricks. Other than that, check out the official
C++ Guidelines by Bjarne and co.
[http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines)

Good luck!

------
elteto
Others have talked about how to learn the language but many people often find
that hardest thing to do is to even compile their first C++ file. This is the
"build system escalation policy" that I personally use, depending on what I
need:

1: Experimental, throw-away code: online IDEs or Godbolt if I care about
compiler output. You would be surprised how much mileage you can get out of a
simple online IDE when you are just learning or exploring a new thing and
don't care about preserving your work.

2: Single-file code or small multi-file projects with no dependencies (like
exercises or code samples from a book): direct calls to clang++/g++ in the
command prompt or a simple build.sh shell script when I have to build multiple
files. Make is a fantastic tool for this so you can learn and use that
instead. I would actually encourage beginners to play directly with the
compiler and learn the basic flags though, but this is personal preference.

3a: Personal projects that pull in other dependencies (either system wide or
libraries from github or other sources): Make or cmake would probably work
here equally well. I actually prefer cmake for its find_package and external
project functionality. Notice the jump in complexity from 2 to 3, this is
something you have to deal with and eventually you will have to pick a build
tool and learn it.

3b: After learning to use Bazel I have mostly migrated to it for all my
personal projects, but there was an initial learning curve for sure (not worse
than cmake though).

4: At work: Whatever your company/team/group uses, you will most likely have
little input on this if the codebase is old and established.

If you are in Windows you can use vanilla Visual Studio C++ (Community edition
is free and has all the bells and whistles) for 1-3, or use Visual Studio +
cmake (you can generate VS solution files from cmake).

------
tolger
I found "C++ Primer" by Lippman et al very well written and comprehensive. It
includes C++11 features and every chapter has exercises to make sure you
understand the content.

[https://www.amazon.com/Primer-5th-Stanley-B-
Lippman/dp/03217...](https://www.amazon.com/Primer-5th-Stanley-B-
Lippman/dp/0321714113)

~~~
AstralStorm
Already outdated by 6+ years though.

~~~
tolger
What would you say are important features missing in C++11 that are in the
current standard? I ask because I'm trying to get back into C++ development
after many years and even C++11 seems like a new language to me.

------
bogomipz
I have a question on this topic which is - is it possible or practical to only
learn "modern" C++?

Isn't it necessary to be able to understand pre-modern C++ in legacy code
bases or to work alongside a co-worker who might code using an older style? Or
even to be able to understand documentation and texts about C++ from an
earlier era?

~~~
DoofusOfDeath
I share your concern. Even if one isn't (knowingly) dealing with older C++
code, _all_ of the language rules apply to every line of C++ being compiled.

Just one typo, or misguided use of syntax, and a person might be using some
"older" revision of the language without knowing it. And I'm not aware of any
tool that will warn the programmer that he/she has done that.

So I'm concerned that programmers schooled only in "modern" C++ will fail to
understand that this has occurred, and will either (a) get error messages that
don't understand, or (b) get program behavior that they don't anticipate.

I'm curious if people have found this to be a problem in practice.

~~~
bogomipz
>"I'm curious if people have found this to be a problem in practice."

Same. And I think you articulated the specific concerns I have about just
learning the "modern" version.

It would certainly lower the barrier to entry in learning C++ if this was an
unfounded concern.

C++ has some 35 year of history and changes at this point. This point alone
adds(for me anyway) to the perceived cognitive load of learning it. C also has
a similar length of history but it is a much smaller language.

~~~
oblio
> It would certainly lower the barrier to entry in learning C++ if this was an
> unfounded concern.

If the Javascript community, which is as fragmented as C++, if not more, could
introduce "strict" mode and enforce it basically everywhere, then maybe C++
could do the same thing.

Have C++20 recommend a certain subset of C++, have C++24 warn as deprecated
features not in this subset, have C++30 error out on everything outside this
subset, unless the compiler is set to compatibility mode and finally have
C++40 refuse to compile the old code.

~~~
DoofusOfDeath
I'll take your word for it regarding JS, but I was thinking along the same
lines w.r.t. C++ deprecation.

Alternatively, one could take a page from CMake's playbook with "policies"
[0].

[0] [https://cmake.org/cmake/help/v3.7/manual/cmake-
policies.7.ht...](https://cmake.org/cmake/help/v3.7/manual/cmake-
policies.7.html#cmake-policies-7)

~~~
oblio
ECMAScript 6 modules are in strict mode only:
[https://stackoverflow.com/a/31685340/1320143](https://stackoverflow.com/a/31685340/1320143)

I think C++ is getting modules, maybe they could do the same thing?

------
GreyZephyr
Piggybacking of this post, if anyone has any similar resources for best
practices in modern C I'd be interested. There don't seem to be any moocs that
go beyond introductory material and K&R obviously doesn't cover modern tools
and methods.

~~~
modernclearning
“C Interfaces and Implementations” by David R. Hanson is what I used when I
had a similar concern a few years ago. It’s from 1997, so no, it doesn’t cover
the newest C standards, which I understand is your main concern. Though C11
didn’t add too much semantically, for what it’s worth. That said, the book
provides great design patterns for writing C in an object-oriented sort of
manner, more idiomatic to OOP.

Peter Hintjens was writing “Scalable C” a couple years ago, but recently died,
and never got very far unfortunately.

------
pvg
It's a bit of an evergreen question.

[https://hn.algolia.com/?query=learn%20c%2B%2B&sort=byPopular...](https://hn.algolia.com/?query=learn%20c%2B%2B&sort=byPopularity&prefix&page=0&dateRange=all&type=story)

For even more stuff - if you do the same search for C, especially 'modern C',
you'll find those threads often also contain a parallel set of recommendation
for C++ resources.

------
dmlorenzetti
Coincidentally, Pearson just announced a 40% off sale for all their C/C++
books (in honor of Stroustrup receiving the Draper Prize).

[http://www.informit.com/promotions/programming-with-c-
and-c-...](http://www.informit.com/promotions/programming-with-c-and-c-plus-
plus-tutorials-and-references-138989)

------
justicezyx
Writing a piece of software in C++.

Sizing the softare to fit your schedule: i.e., if you want to be at the level
of BJS, write a C++ compiler; if you want to be as good as Google employee,
uses the common Google c++ libraries Protobuf ABSL etc. to write a simple
webserver with a few APIs. The list goes on and on.

------
snarfy
I look for projects on github with good quality source code and start hacking
on them.

here is a vulkan renderer
[https://github.com/pumexx/pumex](https://github.com/pumexx/pumex)

You'll pick up the good habits working with good code.

------
kuwze
I would recommend the following websites for practice:

[http://exercism.io/](http://exercism.io/)

[http://rosalind.info/problems/locations/](http://rosalind.info/problems/locations/)

[https://projecteuler.net/](https://projecteuler.net/)

[https://www.hackerrank.com/](https://www.hackerrank.com/)

------
JepZ
Do you mind asking 'Why C++'?

I know that doesn't answer your question and to be honest, I am curious about
the resources which come up here too, but C++ can be so painful to learn that
I wanted to know what drives you into that direction. I mean, there are
alternatives like Rust. Do you have a specific project in mind, need it to
fulfill some résumé requirements or something completely different?

~~~
carlmr
Not OP, but good question.

I find Rust is a much better language, but there are very few mature libraries
right now if you do something outside the scope of what Mozilla is doing. Also
very few companies that are working in Rust (AFAIK, if you know some let me
know) looking for devs.

If you want to work in a company that is doing any kind of low level code you
will either need C or C++ as a foundation. At least to understand existing
code. Most companies won't just rewrite everything in Rust, no matter how good
the language is.

I really hope Rust replaces C++ for new projects, but it's just too new to
tell whether that will happen. I find there's a bit more momentum (and good
ideas) than in D, but nobody can predict the future from 2-3 years of language
history.

~~~
steveklabnik
> if you know some let me know

“This Week in Rust” lists explicit job postings. One of the latest companies
looking for Rust programmers is a little company you may have heard of:
Facebook.

That said, many places are hiring _good programmers_ and putting them on Rust
projects, rather than hiring Rust programmers explicitly. There aren’t many
pure Rust shops yet, so they need a broader skill set.

~~~
carlmr
I'm pretty good in C as well (less C++). I just would like to know beforehand
if I could grow into a Rust role there.

~~~
steveklabnik
Yeah, that's the issue with these kinds of roles. You'd have to ask each
company, of course.

------
colin_mccabe
The question assumes that there is a single "proper" way to code in C++ that
everyone agrees on. But that's just not the case. For example, Google bans
exceptions, operator overloading, and most uses of Boost in their C++ code.
Facebook embraces all those things. QT re-invents most of the standard
library.

A lot of the C++ language is sort of experimental. Sometimes features get
thrown in and then deprecated and/or taken out, like the "export" keyword for
templates, or throw specifications. Most programmers have strong opinions
about which C++ features are bad. But that's all they are-- opinions. The C++
standard supports pretty much any way of doing things you could imagine--
async, sync, multiple inheritance, functional, you name it.

If you're a novice, my advice is to learn C really well. Then choose a C++
style guide and follow its recommendations closely.

------
rb808
If you haven't already I'd suggest learning a functional language first, then
coming back to modern C++, because much of the new features are borrowed from
other languages.

Personally I started doing this then never went back. Seems most of the jobs
out there for C++ really aren't that interesting.

~~~
modernclearning
Absolutely unnecessary. Modern C++ borrowed some paradigms of functional
programming, but learning a functional language isn’t remotely close to being
a prerequisite to learning those features.

In terms of jobs, C++ is used heavily, if not the majority of the time in: AAA
game development, high performance computing, high frequency trading and
quantitative finance, embedded software, image processing and computer
vision... honestly, I focused on C++ out of school years ago BECAUSE of how
interesting many of the jobs are. They’re also generally more stable and thus
competitive over time compared to e.g. web dev, enterprise software, and so
on, because the domain knowledge required means you’re a lot more valuable
than knowing X and Y design pattern or framework Z.

------
SXX
As others noted best way to learn is to use it. Pick any open source you like,
compile and test it, learn it's code, try to fix some bugs or implement
features, ask questions from other developers, get feedback on your code. That
way you'll learn all caveats of practical C++ development and tools.

Additionally while traditional and more detailed books already posted here
I'll just add one I personally liked: Discovering Modern C++ by Peter
Gottschling. It's had exactly information I would expect be needed for person
who already have reasonable experience in programming, but want short
introduction into C++.

Disclaimer: I'm certainly not someone you can call experienced C++ programmer
since I just developing and manage open source project for 3+ years. So take
my opinion with a grain of salt.

------
overcast
Best way to learn anything new, is just pick a pet project you've been
thinking about, and implement it in that language/database/system/whatever.
That's how I've always done it over the years. You end up constantly building
upon the last projects knowledge.

------
RandomCSGeek
I would recommend the book C++ Primer, by Stanley Lippman. Also
[http://www.learncpp.com/](http://www.learncpp.com/). Both are great resources
IMHO. You might have to skim over certain topics as you already know C.

------
clarkrinker
Read the Core Guidelines.
[https://github.com/isocpp/CppCoreGuidelines/blob/master/CppC...](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md)

------
72deluxe
Read Stroustrup's blue book (The C++ Programming Language 4th edition);
chapter 1 will teach you a LOT.

Then read Meyer's Effective modern C++.

And then have a local copy of cppreference.com (they provide a zip you can
download) and set yourself some projects.

------
therealmarv
Build simple command line programs with it and use first a simple editor like
Code::Blocks. Best thing to stop you learning C++ is using one of this beasts
like VisualStudio and start with Windows programming ;)

------
mannykannot
Take a look at how the standard library does things, and particularly anything
for which it is not clear to you how one might implement it, or the use of
anything whose purpose you don't really understand.

~~~
Const-me
Large parts of the standard library are designed badly. E.g. io streams are
horrible, allocators are questionable.

~~~
DoofusOfDeath
> Large parts of the standard library are designed badly.

That's true, but IMO it's useful to study the standard library to understand
_what it offers_ , as opposed to examples of well-designed C++ code.

~~~
Const-me
People who spent many years developing C++ already understand what the
standard library offers, regardless on whether they studied that deliberately.

People coming to the language lack the expertise to tell well-designed code
from bad-designed. It’s tempting to treat the whole standard library as an
example of the former.

Maybe that’s a personal thing but I remember doing that when I just started my
career back in 2000. STL wasn’t quite there but MFC was already in wide use.
Because I lacked the experience I considered whatever’s there is good, and
ended up using not so good parts such as C++ exceptions and macro-driven
dynamic serialization.

~~~
DoofusOfDeath
> People who spent many years developing C++ already understand what the
> standard library offers

That statement isn't true for (at least) me. The main reason is that I'm
usually working on code that must be compile-able as C++11, and/or may require
an old-ish version of gcc's standard C++ library.

So in my daily work I usually have little/no reason to interact with the newer
parts of the standard library.

------
logandk
Before diving into smart pointers, move semantics and other (mostly) recent
additions, I would recommend getting well acquainted with the basics: RAII and
common patterns such as passing by constant reference. Effective C++ by Scott
Meyers, as others have noted, is an excellent entry point.

------
mlboss
I would recommend to start with C++ integration with Jupyter notebook
[https://blog.jupyter.org/interactive-workflows-for-c-with-
ju...](https://blog.jupyter.org/interactive-workflows-for-c-with-jupyter-
fe9b54227d92).

------
rashikas215
Check this out. [https://unacademy.com/course/c-programming-
essentials-994/BM...](https://unacademy.com/course/c-programming-
essentials-994/BMFTV2O4)

Definitely a good kick start.

------
MadcapJake
Anyone aware of good, thorough, (online) material to learn C++ template
programming?

~~~
isaachier
For this, I can't point to any one source, but I highly suggest looking at the
implementations of the C++11 type_traits header. Building off of that would be
a great second step.

------
prando
I usually get bogged down by the syntax of very many complex things that gets
me lose the focus on the motive of the code. I wish we had an efficient way to
learn what a declaration means. (On the lines of cdecl)

------
ndj7
What's the best way to teach modern C++ as a first programming language?

I'm at CU Boulder and their curriculum is outdated (90s) and backwards. What
resources could I point the professors towards?

------
TheArcane
Related: Any good websites to practice C++ with challenges? I've heard some
things about CodeWars, but are there any other?

~~~
jxub
I think you can use C++ in code challenges in all major coding riddles
practice sites eg. Hackerrank, Leetcode and TopCoder.

------
ebspelman
I don't see openFrameworks mentioned here:
[http://openframeworks.cc/](http://openframeworks.cc/)

Probably the most comprehensive open-source creative coding framework. Maybe
most helpful for familiarity with graphics programming / OpenGL, but it really
extends to all types of possible interactions. Maintained by an awesome group
of people.

~~~
tzahola
OpenFrameworks has nothing to do with _modern_ C++. It’s a framework for
laymen artists that happens to be written in C++. It won’t teach you about
move semantics, lambdas, unique_ptr, for-in loops, etc.

------
bbimbop
This is great information, thanks.

------
gurpreetshanky
I would say watch C++ primer

------
dman
I wonder if at some point it will be possible to discuss C++ on HN without the
majority of the conversation becoming side tracked into discussing Rust.

------
ronreiter
May I ask why do you want to learn modern C++?

You should check out Rust, it aims to replace C++ and do a better job in
memory management, and developer experience in general (cross-platform
compatibility, package management, etc)

~~~
pjmlp
Rust still needs to catch up with C++ in a few domains.

SIMD, GPGPU, GUI, embedded platforms, iOS, Android, UWP, COM, certified
compilers, ...

~~~
steveklabnik
Incidentally, SIMD is just waiting on stabilization now; it’s RFC was accepted
and the implementation landed. Soon!

~~~
AnimalMuppet
Will Rust have idioms for really doing SIMD _in Rust_? If I understand
correctly, C++ has to drop into assembly to do SIMD (at least so far).

~~~
pjmlp
C++ doesn't need Assembly for SIMD.

Most compilers do a reasonable job with auto-vectorization, and if more is
needed, there are instrisics.

No need to write straight Assembly.

~~~
AnimalMuppet
OK. (The one time I encountered SIMD in C++ was a decade ago; we had to use
assembly then. And even then, we weren't playing with an up-to-the-minute
compiler. (In my experience, your comments elsewhere on this article about
embedded toolchains were accurate.)

Are the intrinsics standard? If so, what version of the standard were they in?
How good is compiler support for them?

~~~
AstralStorm
Not standard, unless you count "supported with the same semantics in multiple
compilers" as good enough.

They are not portable between CPU architectures either way

For reference, C got real alignment support in C11 and C++ in C++17. Without
this, even starting on SIMD is risky.

That said, you can go really far with a good C++ math library like Eigen which
has singe vectorization in the operations themselves.

------
moocowtruck
This is undoubtedly the best c++ resource available
[http://shop.oreilly.com/product/0636920040385.do](http://shop.oreilly.com/product/0636920040385.do)

------
qdoop
C++ is just C with extra notation for easy modeling of Classes and Objects.
While C still remains valuable, C++ is in my opinion questionable and there
are many excellent alternatives like Java or C# for doing similar things and
much more. I have programmed in C++ for many years and honestly would not
suggest it to any one but anyway here are some excellent resources.

ftp://bitsavers.informatik.uni-
stuttgart.de/pdf/borland/borland_C++/Borland_C++_Version_2.0_Getting_Started_1991.pdf
(Read chapter 4 C++Primer. The hole folder is a rare jewel)

[https://docs.microsoft.com/en-us/cpp/cpp/cpp-language-
refere...](https://docs.microsoft.com/en-us/cpp/cpp/cpp-language-reference)
Probably the best documentation of C++ by far.

P.S. If you are desperate on learning C++ I could give short course saving you
time and money.

~~~
chi3
> C++ is just C with extra notation for easy modeling of Classes and Objects.

That's far from true today, and I'd even argue it hasn't been true since very
early on. Simple example to prove my point: RAII.

~~~
qdoop
So you know
[https://en.wikipedia.org/wiki/Resource_acquisition_is_initia...](https://en.wikipedia.org/wiki/Resource_acquisition_is_initialization)
Good for you.

"Object Oriented Programming puts the Nouns first and foremost. Why would you
go to such lengths to put one part of speech on a pedestal? Why should one
kind of concept take precedence over another? It's not as if OOP has suddenly
made verbs less important in the way we actually think. It's a strangely
skewed perspective." from [https://en.wikipedia.org/wiki/Object-
oriented_programming](https://en.wikipedia.org/wiki/Object-
oriented_programming) criticisms says a lot.

~~~
chi3
That's quite irrelevant to the conversation though, we weren't talking about
whether OOP is good or not. C++ is very far from "C with classes" today.

~~~
qdoop
Ok but still OOP is the central idea and also there is this trend the most
annoying one to always try modeling everything as classes and objects.

~~~
leetcrew
plenty of c++ is just functions wrapped in namespaces. namespaces alone are a
significant advantage over c.

