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
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.
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.
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://www.youtube.com/playlist?list=PLZN9ZGiWZoZojYik8EdApUgPwa0YM3Yuz Russian
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://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://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++
https://medium.com/@jamesperry/starting-a-tech-startup-with-c-6b5d5856e6de#.fuw38gi68
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
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://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
https://plus.google.com/collection/gbWeX
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://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://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://herbsutter.com/elements-of-modern-c-style/
https://github.com/sean-parent/sean-parent.github.com/wiki/Papers-and-Presentations
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://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/
http://isocpp.org/wiki/faq/ FAQ
http://chriskohlhepp.wordpress.com/convergance-of-modern-cplusplus-and-lisp/
LINQ for CPP
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
auto and decltype Explained
http://thbecker.net/articles/auto_and_decltype/section_01.html
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://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].
See more here: http://www.aristeia.com/C++0x/C++0xFeatureAvailability.htm
Hide Copy Code
Hide Copy Code
Hide Copy Code
Hide Copy Code
Hide Copy Code
Hide Copy Code