[2018] Get familiar with C++

[XJTUmg]

Content of Issue:

• [x] https://www.youtube.com/watch?v=eidEEmGLQcU

• [x] https://www.youtube.com/watch?v=u5senBJUkPc

• [x] https://www.youtube.com/watch?v=YnWhqhNdYyk

• [x] https://www.youtube.com/watch?v=1OEu9C51K2A

• [x] https://www.youtube.com/watch?v=xnqTKD8uD64

• [x] https://www.youtube.com/watch?v=86xWVb4XIyE

• [x] Make Report

View the videos and make a report of each one

[XJTUmg]

Report for 1st video

• accumulate
  • Function object may produce a side-effect by returning a return code different from input parameter.
  • Differs from for_each
• transform
  • Similiar with for_each except completely different.
  • If the input range(s) and result range are the same, or overlap, mutates objects in-place.
  • Returns iterator pointing one past last element in result range.

[XJTUmg]

Report for 2nd video

• Correctness, tests must verity the requirements of the system are met.
• Readability, tests should be obvious to the future reader.
• Completeness, including common inputs, corner cases, outlandish cases, etc.
• Demonstrability, tests should serve as a demonstration of how the API works.
• Resilience, hermetic, only breaks when there is an unacceptable behavior change.

[XJTUmg]

Report for 5th video

• Book <A Tour of C++>
• Don't use owning *, new, or delete. Use make_unique and make_shared instead.
  • Never pass smart pointers (by value or by reference) unless you actually want to manipulate the pointer -> store, change, or let go of a reference.
  • Express ownership using unique_ptr wherever possible, including when you don't know whether the object will actually ever be shared.
  • Else use make_shared up front wherever possible, if object will be shared.
• Use forwarding reference.

[XJTUmg]

Report for 3rd video

• Many C-isms are bad C++
  • A collection of functions with related names is not as good as a class. (strlen, strcmp, strcpy etc).
  • No RAII.
  • No iterators.
  • Less type safety.
• Just because you can learn C++ as an add-on to C doesn't mean those who know neither should learn C first. The following are disadvantages:
  • Creates programmers who are less proficent in C++ than they would otherwise have been.
  • Reduces their enjoyment of the learning process dramatically.
  • Hides the true benefits of C++.
  • Creates a false complexity.
  • Obscures connections to other languages invented in the intervening decades.

[XJTUmg]

Report for 6th video

• Type safety.
• Resource safety.
• Performance and Predictability.
• Teachability.

C++14 guidelines:

• Use make_shared_ptr or make_unique_ptr instead of new.
• Do not use protected for data.
• No universal base class.
• Objects must be in dynamic memory, involves: Allocation, Indirect access to object, de-allocation cost etc.

[XJTUmg]

Report for 4th video

Some points:

• Attention at type safety.
• Prefer compile-time checking.
• Do not leak any resource.
• Do not waste time or space.
• No dangling pointers.

There are so many rules, but we shouldn't remeber all of these. We should change the way of writing code by rules, tools, comment, review and editor.

Note: GSL