c++11

https://www.youtube.com/watch?v=4WJIEHFvSQU High performance C++

https://www.youtube.com/watch?v=Rub-JsjMhWY All C++

https://www.youtube.com/watch?v=wG49AGqQ5Aw C++ algo

https://www.geeksforgeeks.org/commonly-asked-c-interview-questions-set-1/

https://github.com/rigtorp/awesome-modern-cpp

http://www.sanfoundry.com/1000-cpp-algorithms-problems-programming-examples/

https://www.codeproject.com/Articles/854127/Top-Beautiful-Cplusplus-std-Algorithms-Examples

https://www.codeproject.com/Articles/1035313/Cplusplus-is-fun-tips-and-tricks

https://www.codeproject.com/Articles/344282/Cplusplus-Come-Closer

Explicit override,final,delete and default

These modifiers allow you to be explicit in member functions:

- override tells the compiler that a function must override a parent class function
- final tells the compiler that a function must not be overriden by a descentant class functio
- default tells the compiler to explicitly generate the default constructor
- delete tells the compiler that a member of a class must not be called.

override is useful if you want to override a parent function, but accidentally change the function signature, so a second function is generated instead:

class a { public: virtual void foo(int) {...} }; class b : public a { public: virtual void foo() override; // Compiler error. void foo() has not replaced void foo(int) }

Here the programmer indents to override a::foo() with b::foo(), but without the override indication a new virtual function is created instead, because the programmer forgot that the original foo() takes an int as a parameter.

final is useful if you want to ensure that a function will never be overriden:

class a { public: virtual void foo(int) final {...} }; class b : public a { public: virtual void foo(int) {}; // Compiler error. void foo(int) is final. }

default allows the programmer to tell the compiler that a default constructor should be generated automatically, although there might be other constructors:

class a { public: a() = default; a(int) { ... } };

delete allows the programmer to explicity restrict calling to a member, such as a function that would be called due to unwanted casting or a copy constructor:

class a { public: a(const a&) = delete; void x(int) = delete; void x(float); };

Here, the class copy constructor can't be called, and a call to a::x() must explicitly pass a floating point number (e.g. you can't call x(0)).

My evaluation: Useful. It helps to avoid uneccessary errors.

Visual C++ 11: Not available.

extern template

The keyword extern in a template tells the compiler not to instantiate the template:

template <typename X> class a { public: void test(X); }; template class a<int>; // C++ 03 instantiationextern template class a<int> // C++ 11 won't instantiate.

C++ 11 won't instantiate the "a", but a will be visible to the current compilation unit.

My evaluation: Useful. It helps to avoid uneccessary instantiations in multiple cpp files.

Visual C++ 11: Not available.

Hash tables

C++ 11 has unordered associative containers, called hash tables. These containers use hashing functions to store elements.

void test_hash() { unordered_map<string,int> days(7); const char* str[] = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"}; for(int i = 0 ; i < 7 ; i++) days[str[i]] = i; auto j = days["Wed"]; // j = 3; }

http://www.bfilipek.com/2017/06/cpp17-details-clarifications.html

https://www.youtube.com/watch?v=LuaNbkRPGRo&t=368s Михаил Матросов, Повседневный С++

https://habrahabr.ru/company/aligntechnology/blog/283352/ C++ without new and delete

https://www.youtube.com/watch?v=k_FWj2l1KiM

https://www.slideshare.net/sermp/c-without-new-and-delete-russian-c-user-group

https://www.youtube.com/watch?v=SIZmLPtcZiE

http://2015.secr.ru/lang/ru/program/submitted-presentations/daily-cpp

https://www.youtube.com/watch?v=LuaNbkRPGRo&index=9&list=PLZN9ZGiWZoZojYik8EdApUgPwa0YM3Yuz

https://www.youtube.com/watch?v=rJWSSWYL83U&index=14&list=PLZN9ZGiWZoZojYik8EdApUgPwa0YM3Yuz

https://apolukhin.github.io/

https://www.youtube.com/playlist?list=PLZN9ZGiWZoZojYik8EdApUgPwa0YM3Yuz Russian

http://www.fluentcpp.com/

https://leanpub.com/cpplibrary

http://www.acodersjourney.com/2017/01/c11-multithreading-tutorial-via-faq-thread-management-basics/

https://github.com/tvaneerd/cpp17_in_TTs/blob/master/ALL_IN_ONE.md

http://shop.oreilly.com/product/0636920033707.do

https://github.com/nothings/single_file_libs

http://www.icce.rug.nl/documents/cplusplus/

https://www.embeddedrelated.com/showarticle/639.php Immutability

http://www.shoutarticle.com/2016/12/modern-c-14-vs-old-version-of-c-part.html

http://www.levelofindirection.com/journal/2016/12/28/c17-why-its-better-than-you-might-think.html

https://kfrlib.com/blog/how-c14-and-c17-help-to-write-faster-and-better-code-real-world-examples/

https://github.com/AnthonyCalandra/modern-cpp-features

https://habrahabr.ru/company/pvs-studio/blog/310064/

http://itscompiling.eu/2016/03/10/why-learn-cpp-2016/

http://open.compscicenter.ru/archive/modern-cpp-1/

http://open.compscicenter.ru/archive/modern-cpp-2/

https://programming.dirty.ru/

https://news.ycombinator.com/item?id=11483857

http://www.loic-yvonnet.com/articles/dynamic-structures-in-cpp/

http://genbattle.bitbucket.org/blog/2016/02/06/Modern-C-Memory-Management-With-unique-ptr/

http://arne-mertz.de/2016/02/modern-c-features-in-place-construction/

http://eli.thegreenplace.net/2016/the-promises-and-challenges-of-stdasync-task-based-parallelism-in-c11/

http://www.stroustrup.com/resource-model.pdf Stroustroup

http://eli.thegreenplace.net/2016/c11-threads-affinity-and-hyperthreading/

http://www.loic-yvonnet.com/articles/multithreading-in-cpp14-part-8/

https://vimeo.com/131640207 functional C++

http://vitiy.info/

https://medium.com/@jamesperry/starting-a-tech-startup-with-c-6b5d5856e6de#.fuw38gi68

http://arne-mertz.de/

https://github.com/Dobiasd/FunctionalPlus

https://www.youtube.com/watch?v=iWvcoIKSaoc&feature=youtu.be

https://github.com/sean-parent/sean-parent.github.io/wiki/Papers-and-Presentations

http://blog.aaronballman.com/

https://github.com/Microsoft/cpprestsdk C++ rest sdk Casablanka from Microsoft

https://github.com/scylladb/seastar async programming based on futures

https://github.com/scylladb/scylla Cassandra compatible db in C++

http://habrahabr.ru/post/267413/ C++ GUIDLINES FROM STRAUSTRUP

https://github.com/isocpp/CppCoreGuidelines/blob/master/talks/Sutter%20-%20CppCon%202015%20day%202%20plenary%20.pdf

https://kerpanic.wordpress.com/2015/11/16/5-useful-things-in-c11/

http://codeyarns.com/2015/04/24/asynchronous-threads-in-c/

http://codeyarns.com/2015/09/14/how-to-lock-using-mutex-in-c/

concurrent queue

https://github.com/cameron314/concurrentqueue

http://www.cppsamples.com/

https://plus.google.com/collection/gbWeX

http://seanmiddleditch.com/

folly http://www.codergears.com/Blog/?p=431

http://www.reddit.com/r/cpp/comments/317ng0/what_are_the_best_resource_to_learn_the_new/

https://svn.boost.org/trac/boost/wiki/BestPracticeHandbook

Serialization

http://vitiy.info/immutable-data-and-serialisation-in-cpp11/

https://habrahabr.ru/post/303368/

https://github.com/simongog/sdsl-lite

https://kacperkolodziej.com/articles/programming/272-fighting-off-memory-leaks-and-errors-cpp11.html

https://www.youtube.com/watch?v=SHiXwBbMT2s

http://yapb-soc.blogspot.com/2015/02/common-algorithm-patterns.html

http://siliconframework.org/blog/a_simple_silicon_blog_api.html

http://habrahabr.ru/post/248901/

http://vitiy.info/ten-ways-to-not-shoot-yourself-in-the-foot-using-cpp11/

Code examples

https://github.com/leapmotion/autowiring

https://github.com/mnmlstc/core

http://vitiy.info/functional-pipeline-in-c11/

http://jscheiny.github.io/Streams/

https://news.ycombinator.com/item?id=9329802

http://habrahabr.ru/post/229327/

http://actor-framework.org/

http://seshbot.com/blog/2014/08/16/modern-c-plus-plus-idioms-i-use-every-day/

https://news.ycombinator.com/item?id=8193754

http://clean-cpp.org/interfaces-done-right/

https://github.com/boostcon/cppnow_presentations_2014

http://www.reddit.com/r/cpp/comments/24iqyx/what_is_a_good_small_sized_project_to_see_c1114/

http://www.infoq.com/news/2014/07/cpp14-streams-lazy-functional

http://channel9.msdn.com/Events/GoingNative/2013/An-Effective-Cpp11-14-Sampler

http://channel9.msdn.com/Events/Build/2014/2-661

http://channel9.msdn.com/Events/GoingNative/GoingNative-2012/STL11-Magic-Secrets

http://channel9.msdn.com/shows/Going+Deep/C9-Lectures-Introduction-to-STL-with-Stephan-T-Lavavej/

http://channel9.msdn.com/Series/C9-Lectures-Stephan-T-Lavavej-Advanced-STL

http://channel9.msdn.com/Series/C9-Lectures-Stephan-T-Lavavej-Core-C-

http://channel9.msdn.com/Events/GoingNative/GoingNative-2012/Keynote-Bjarne-Stroustrup-Cpp11-Style/player

http://blog.smartbear.com/c-plus-plus/the-biggest-changes-in-c11-and-why-you-should-care/

http://blog.smartbear.com/category/c-plus-plus/

http://clean-cpp.org/

http://herbsutter.com/elements-of-modern-c-style/

https://github.com/sean-parent/sean-parent.github.com/wiki/Papers-and-Presentations

http://isocpp.org/

https://en.wikipedia.org/wiki/C%2B%2B11

http://www.codeproject.com/Articles/570638/Ten-Cplusplus11-Features-Every-Cplusplus-Developer

http://learnandexperiment.blogspot.com/2013/06/c-11-some-important-features.html

http://cpprocks.com/c-concurrency-cheatsheet/

http://exceptionsafecode.com/

http://www.thesaguaros.com/openmp-style-constructs-in-c11.html

https://github.com/Amanieu/asyncplusplus

http://www.infoq.com/presentations/gof-patterns-c-plus-plus-boost

https://github.com/ipkn/crow Flask-inspired microframework in C++

https://news.ycombinator.com/item?id=8002604

for any container c:

for ( auto x : c ) { do something with x }

http://files.meetup.com/1455470/Why%20C%2B%2B%20Sails%20When%20the%20Vasa%20Sank.pdf

http://habrahabr.ru/post/238237/

cpprocks.com

http://isocpp.org/wiki/faq/ FAQ

http://chriskohlhepp.wordpress.com/convergance-of-modern-cplusplus-and-lisp/

LINQ for CPP

http://cpplinq.codeplex.com/

http://www.gamefromscratch.com/post/2014/04/04/LINQ-for-CPP-with-cpplinq.aspx

http://www.reddit.com/r/cpp/comments/21pxx2/what_is_your_favorite_little_c_snippet_of_code/

http://habrahabr.ru/post/207842/ RAII smart pointer

http://www.codeproject.com/Tips/537403/Cplusplus11-Prefer-bind-to-bind1st-and-bind2nd

http://katyscode.wordpress.com/2012/10/04/c11-using-stdunique_ptr-as-a-class-member-initialization-move-semantics-and-custom-deleters/

auto and decltype Explained

http://thbecker.net/articles/auto_and_decltype/section_01.html

https://www.ibm.com/developerworks/community/blogs/5894415f-be62-4bc0-81c5-3956e82276f3/entry/c_11_the_decltype_specifier_part_ii?lang=en

rvalue and move()

http://habrahabr.ru/post/226229/

http://arne-mertz.de/2015/09/new-c-features-move-constructor-and-move-assignment/

http://thbecker.net/articles/rvalue_references/section_01.html

http://cpp-next.com/archive/2009/08/want-speed-pass-by-value/

http://katyscode.wordpress.com/2013/02/27/c-explained-object-initialization-and-assignment-lvalues-and-rvalues-copy-and-move-semantics-and-the-copy-and-swap-idiom/

http://clean-cpp.org/std_move-it/

http://www.codesynthesis.com/~boris/blog/2012/06/19/efficient-argument-passing-cxx11-part1/

http://akrzemi1.wordpress.com/2011/08/11/move-constructor/

http://kholdstare.github.io/technical/2013/11/23/moves-demystified.html

Singleton

template <typename Target> class shared_singleton { public: static std::shared_ptr<Target> instance() { auto ptr = s_instance.lock(); if (!ptr) { ptr = std::make_shared<Target>(); s_instance = ptr; } return ptr; } private: static std::weak_ptr<Target> s_instance; }; template <typename Target> std::weak_ptr<Target> shared_singleton<Target>::s_instance;

http://habrahabr.ru/post/182610/ mulithreading

http://habrahabr.ru/post/188234/

http://www.cpprocks.com/c11-a-visual-summary-of-changes/

http://isocpp.org/blog/2012/11/introduction-to-modern-c-techniques

http://yapb-soc.blogspot.com/2012/11/the-importance-of-function-objects.html

http://lemire.me/blog/archives/2012/11/26/why-i-like-the-new-c/

http://en.wikipedia.org/wiki/C%2B%2B0x

http://www.baptiste-wicht.com/2012/07/c11-concurrency-tutorial-part-4-atomic-type/

https://blogs.oracle.com/pcarlini/

http://wiki.apache.org/stdcxx/C++0xCompilerSupport

http://www2.research.att.com/~bs/C++0xFAQ.html

https://github.com/larroy/Dive-into-C--11

http://habrahabr.ru/blogs/cpp/139064/#habracut

http://altdevblogaday.com/2011/10/08/caring-by-sharing-header-hero/

http://solarianprogrammer.com/2011/11/01/cpp-11-lambda-tutorial/

http://solarianprogrammer.com/2011/12/16/cpp-11-thread-tutorial/

http://solarianprogrammer.com/2012/02/27/cpp-11-thread-tutorial-part-2/

http://www.reddit.com/r/cpp/comments/3azi39/the_real_price_of_shared_pointers_in_c_nico/

unordered_map is the proposed C++ TR1 name for a hash table, accessible as std::tr1::unordered_map.

unordered_map works very similarly to the existing map class in the C++ STL. It will replace the various incompatible implementations of the hash table (called hash_map by GCC and MSVC).

Until TR1 is officially accepted into the upcoming C++0x standard, unordered_map is available from the <tr1/unordered_map> header file, and from <unordered_map> in MSVC[1].