/* Why you should avoid the SL C++ course. Disclaimer I am not a C++ expert, and I don't think that I have more than a month of experience in C++. However, I have enough knowledge to bring strong arguments why this course should definitively be avoided. I may have done mistakes while writing this, so I apologize. Moreover, since I'm not that much experienced, and despite the fact that I did a lot of researches, I may have written wrong things. The reasons it is a bad course As you may know if you are interested in C++, it exists a clear distinction between old C++ (before 2011) and modern C++ (introduced in 2011 with the C++11 standard). We could even say that there are two different languages. Currently, in 2020, most, if not all C++ developers are using modern C++ : old C++ is dead. Unfortunately, the SL course is covering the old C++, and thus teaching a lot of bad practices to beginners. I) the unified initialisation syntax Curly braces are now used to initialize data types (at least for int, double, string, arrays, ...), which mean we do not use the '=' operator anymore. It is called list initialization. wrong : int x = 10; good : int x { 10 }; You may wonder what is the difference between the two. One reason is that the new initialisation syntax doesn't allow implicit conversions, which means that the following code will not compile, for instance : int x { 10.0 }; It also prevent from possible overflow, so the following code will not compile : unsigned int x { -2}; // does not compile ... whereas the old C++ version one will : unsigned int x = -2; // compiles Some great links on the subject: - https://stackoverflow.com/questions/18222926/why-is-list-initialization-using-curly-braces-better-than-the-alternatives II) Arrays We do not longer use C-like arrays at all, but a more convenient data type : std::array. wrong : int x[] = {1, 2, 3}; good : std::array x{1, 2, 3}; The advantages are that : - it is as fast as a C-style array - std::array is not a pointer but an objet - you always know the size of the array thanks to the '.size()' method - it is more readable It is however not safer and can lead to the same issues as a C-style array. However, std::array does provide a '.at(index)' method which throws an exception if you try to get an element at an invalid index. https://stackoverflow.com/questions/30263303/stdarray-vs-array-performance https://www.quora.com/Why-is-there-std-array-in-C-11-What-are-the-benefits-of-it?share=1 III) Pointers and memory management One of the biggest change brought by C++11 is the way memory is managed in C++. Short long story : you do not allocate memory by yourself anymore and you work with smart pointers. Smart pointers are way safer than raw pointers since it manages memory for you and brings some guarantees (memory is always free). I don't understand how SL could not present them. There are basically three types of smart pointers : - std::unique_ptr : this pointer is used for owned data - std::shared_ptr : this pointer is used for shared data - std::weak_ptr : this pointer is used to avoid memory leaks in come conditions. It is often used with std::shared_ptr The std::shared_ptr is a reference counting pointer, which means that when the reference counter to the data falls to zero, memory is automatically freed ! Here are some exemples (needs to include the header) OWNED DATA wrong : { int *x = new int(5); ... delete x; } good : { auto x = std::make_unique(5); ... } // automatic memory management SHARED DATA wrong : { int *x = new int(5); int *y = x; ... y = nullptr; delete x; } good : { auto x = std::make_shared(5); auto y = x; ... } As you can see, memory is managed for you, so it reduces the amount of mistakes you easily make with raw pointers. Another thing about pointers : if you need, for some obscure reason, to have a null raw pointer, you must use the 'nullptr' keyword instead of 'NULL'. A last thing about smart pointers : they are used to represent the ownership of value. The concept of ownership is a very important concept in modern C++. Great links : all good C++ tutorials :) https://docs.microsoft.com/en-us/cpp/cpp/smart-pointers-modern-cpp?view=msvc-160 https://docs.microsoft.com/en-us/cpp/cpp/how-to-create-and-use-shared-ptr-instances?view=msvc-160 https://www.reddit.com/r/cpp_questions/comments/8d5ory/when_to_use_a_smart_pointer_a_raw_pointer_or_a/ IV) Random numbers We do not use 'rand' and 'srand' functions. Instead, we use random generators. Event if it is more complicated to use, it is the right way to do. See header, std::random_device and std::uniform_int_distribution. https://www.fluentcpp.com/2019/05/24/how-to-fill-a-cpp-collection-with-random-values/ V) Passing by reference In the SL course, it is shown how to pass values by pointer, and not by reference. This is a big difference ! A reference is an alias for a variable, whereas a pointer... is a pointer ! wrong : void add_two(int *x) { if(x != nullptr) { *x += 2; } } int y { 5 }; add_two(&y); good : void add_two(int &x) { x += 2; } int y { 5 }; add_two(y); Generally speaking, you always transfer data by reference, and never by pointer. Moreover, you usually transfer data by constant reference when you don't have to modify the data. You may wonder what are the advantages of references over pointers, and here are some strong reasons : - a pointer can hold a null value, whereas a reference cannot! So the billion dollars mistake can be avoided! - working with references is way more natural than working with pointers https://stackoverflow.com/questions/7058339/when-to-use-references-vs-pointers VI) Basic STL containers This course does not show the most basic and useful STL collections, namely : - std::vector - std::array - std::map This three basic collections should definitively be teached in a C++ tutorial, instead of focusing on C-style arrays, which are considered as bad programming practices in C++. Other things... Some other things are missing in this tutorial : - the move semantic - the standard template library (stl) and all the usefull collections - anonymous functions - iterators and the for-each loop over containers - auto keyword and type inference - casts with 'static_cast' SOURCES : Links https://stackoverflow.com/questions/4986673/c11-rvalues-and-move-semantics-confusion-return-statement https://docs.microsoft.com/en-us/cpp/cpp/welcome-back-to-cpp-modern-cpp?view=msvc-160 https://www.modernescpp.com/index.php/move-semantic-tow-nice-properties https://stackoverflow.com/questions/7576953/c-auto-keyword-why-is-it-magic https://stackoverflow.com/questions/1609163/what-is-the-difference-between-static-cast-and-c-style-casting https://docs.microsoft.com/en-us/cpp/cpp/type-conversions-and-type-safety-modern-cpp?view=msvc-160 CppCoreGuidelines https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines and namely : - for std::array and std::vector VS C-style arrays : https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#slcon1-prefer-using-stl-array-or-vector-instead-of-a-c-array - for new and delete part : https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r11-avoid-calling-new-and-delete-explicitly - for smart pointers (and why it is better than new and delete) : https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r20-use-unique_ptr-or-shared_ptr-to-represent-ownership Bjarne Stroustrup about C++11 - https://www.stroustrup.com/C++11FAQ.html YouTube videos - "Stop teaching C" : https://www.youtube.com/watch?v=YnWhqhNdYyk this video is relevant since it is a C++ teacher with a lot of experience with teaching C++ to beginners Courses - Zeste de Savoirs, "La programmation en C++ moderne" : https://zestedesavoir.com/tutoriels/822/la-programmation-en-c-moderne/ */ #include #include #include #include int main() { /* ============================== */ std::cout << "I) INITIALIZATION\n"; int an_integer { 5 }; // unsigned int u_integer { -2 }; // does not compile (underflow) std::string str{"hello"}; std::cout << "int an_integer { 5 }; " << an_integer << std::endl; /* ============================== */ std::cout << "\nII) ARRAYS\n"; std::array arr{1, 2, 3}; std::cout << "array length : " << arr.size() << std::endl; std::cout << "array[0] = " << arr[0] << std::endl; /* ============================== */ std::cout << "\nIII) MEMORY MANAGEMENT\n"; auto owned_data = std::make_unique(10); std::cout << "owned_data : " << *owned_data << std::endl; auto shared_ptr1 = std::make_shared(20); std::cout << "reference count : " << shared_ptr1.use_count() << std::endl; auto shared_ptr2 = shared_ptr1; std::cout << "reference count : " << shared_ptr1.use_count() << std::endl; std::weak_ptr weak{ shared_ptr1 }; std::cout << "reference count : " << shared_ptr1.use_count() << std::endl; /* ============================== */ std::cout << "\nOTHER THINGS\n"; float floating { 32.5 }; unsigned int data { static_cast(floating) }; std::cout << "static cast : " << data << std::endl; std::cout << "for-each loop : "; for (const auto item : arr) { std::cout << item << " "; } std::cout << std::endl; }

Avoid SL C++ course