{"id":17318072,"url":"https://github.com/yukunj/teach-myself-cpp","last_synced_at":"2025-04-14T13:32:39.798Z","repository":{"id":156607665,"uuid":"529618517","full_name":"YukunJ/Teach-Myself-CPP","owner":"YukunJ","description":"This is the repository containing self-study notes for modern C++ to better prepare myself for workplace once graduate.","archived":false,"fork":false,"pushed_at":"2025-04-12T19:17:54.000Z","size":9628,"stargazers_count":66,"open_issues_count":0,"forks_count":7,"subscribers_count":2,"default_branch":"main","last_synced_at":"2025-04-12T20:25:43.106Z","etag":null,"topics":["concurrency","cpp","data-structures-and-algorithms","modern-cpp","self-study"],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/YukunJ.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2022-08-27T15:08:07.000Z","updated_at":"2025-04-12T19:17:57.000Z","dependencies_parsed_at":null,"dependency_job_id":"01e8163f-e93c-4c13-a98d-cf0727c39461","html_url":"https://github.com/YukunJ/Teach-Myself-CPP","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/YukunJ%2FTeach-Myself-CPP","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/YukunJ%2FTeach-Myself-CPP/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/YukunJ%2FTeach-Myself-CPP/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/YukunJ%2FTeach-Myself-CPP/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/YukunJ","download_url":"https://codeload.github.com/YukunJ/Teach-Myself-CPP/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":248888795,"owners_count":21178105,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["concurrency","cpp","data-structures-and-algorithms","modern-cpp","self-study"],"created_at":"2024-10-15T13:18:45.029Z","updated_at":"2025-04-14T13:32:39.788Z","avatar_url":"https://github.com/YukunJ.png","language":"C++","readme":"# Teach-Myself-CPP\n\nHey! Welcome to this repository. This is the notes-keeping place for teaching myself C++, modern C++ in specific. It might also include some auxiliary topics about useful tools.\n\nI learned traditional C++98 a few years ago and didn't quite work on this programming language recently. In order to better prepare myself for workplace once I graduate from school, I will teach myself modern C++ in leisure time and update notes here. Hopefully, this notes could also help other people wishing to get onboard with modern C++.\n\nAside from book reading notes, mostly I will be borrowing good resources from all over the repos on github, and re-implement them for deepening understanding. Sources are pointed out in each one.\n\nI finished reading on \n\n+ [\\\u003cEffective C++\\\u003e](https://www.oreilly.com/library/view/effective-c-55/0321334876/)\n\n+ [\\\u003cMore Effective C++\\\u003e](https://www.oreilly.com/library/view/more-effective-c/9780321545190/)\n\n+ [\\\u003cEffetive STL\\\u003e](https://www.oreilly.com/library/view/effective-stl/9780321545183/)\n\n+ [\\\u003cEffective Modern C++\\\u003e](https://www.oreilly.com/library/view/effective-modern-c/9781491908419/)\n\n+ [\\\u003cC++ Concurrency in Action\\\u003e](https://www.manning.com/books/c-plus-plus-concurrency-in-action)\n\n+ [\\\u003cDesign Data-Intensive Application\\\u003e](https://www.oreilly.com/library/view/designing-data-intensive-applications/9781491903063/)\n\n+ [\\\u003cC++ Software Design: Design Principles and Patterns for High-Quality Software\\\u003e](https://www.oreilly.com/library/view/c-software-design/9781098113155/)\n\nRecently I've been reading over Google's leveldb source code and being thinking to write some low-level stuff to sharpen my C++ skills.\n\n## Content\n\n- [Google C++ Style Guidance](https://google.github.io/styleguide/cppguide.html)\n- [Google leveldb read notes](./level_db_note.md)\n- [Git tutorial](./Git-tutorial)\n- [Gdb tutorial](./Gdb-tutorial)\n- [Makefile tutorial](./Makefile-tutorial)\n- [Socket Programming tutorial](./Socket-Programming)\n- [How to intergate with **GoogleTest** using CMake](./CMake-googletest-tutorial)\n- [How to use Google's **Protocol Buffer**](./Protocol-buffer)\n- [How to write a Reader-Writer lock](./ReaderWriter-lock)\n- [How to design a Key-Value store using **SkipList**](./KV-store-skiplist)\n- [How to design a multi-user chatroom using **Socket Programming**](https://github.com/YukunJ/TurtleChat)\n- [How does **Webbench-1.5** work - source code annotation](https://github.com/YukunJ/annotated-webbench-1.5)\n- [How to write Smart Pointers](./Smart_ptr)\n    * [my **unique_ptr**](./Smart_ptr/README.md#unique_ptr)\n    * [my **shared_ptr**](./Smart_ptr/README.md#shared_ptr)\n- C++ New Features Clarification\n\t* [Variadic Template](./Modern-C++-features/varadic_template)\n- [**\u003cC++ Concurrency in Action\u003e**](./Concurrency-C++/C++_Concurrency_in_Action.pdf)\n\t* [Thread Management](./Concurrency-C++/thread_management.md)\n\t* [Sharing Data Between Threads](./Concurrency-C++/sharing_data_between_threads.md)\n    * [Synchronizing Concurrent Operations](./Concurrency-C++/synchronizing_concurrent_operations.md)\n\t* [Memory Model and Operations on Atmoic Types](./Concurrency-C++/memory_model_and_operations_on_atomic_types.md)\n- [**\u003cEffective Modern C++\u003e**](./Effective-Modern-C++/Effective-Modern-CPP.pdf)\n\t* Deducing Types\n        * [Understand template type deduction](./Effective-Modern-C++/Item-01)\n        * [Understand ***auto*** type deduction](./Effective-Modern-C++/Item-02)\n\t\t* [Understand ***decltype***](./Effective-Modern-C++/Item-03)\n\t\t* [Know how to view deduced types](./Effective-Modern-C++/Item-04)\n\t* **auto**\n\t\t* [Prefer **auto** to explicit type declarations](./Effective-Modern-C++/Item-05)\n\t\t* [Use the explicitly typed initializer idiom when **auto** deduces undesired types](./Effective-Modern-C++/Item-06)\n\t* Moving to Modern C++\n\t\t* [Distinguish between **()** and **{}** when creating objects](./Effective-Modern-C++/Item-07)\n        * [Prefer ***nullptr*** to **0** and ***NULL***](./Effective-Modern-C++/Item-08)\n\t\t* [Prefer alias declarations to ***typedef***s](./Effective-Modern-C++/Item-09)\n\t\t* [Prefer scoped **enum**s to unscoped **enum**s](./Effective-Modern-C++/Item-10)\n\t\t* [Prefer **delete**d functions to private undefined ones](./Effective-Modern-C++/Item-11)\n\t\t* [Declare overriding functions **override**](./Effective-Modern-C++/Item-12)\n\t\t* [Prefer **const_iterator**s to **iterator**s](./Effective-Modern-C++/Item-13)\n\t\t* [Declare functions **noexcept** if they won't emit exceptions](./Effective-Modern-C++/Item-14)\n        * [Use **constexpr** whenever possible](./Effective-Modern-C++/Item-15)\n\t\t* [Make **const** member functions thread safe](./Effective-Modern-C++/Item-16)\n        * [Understand special member function generation](./Effective-Modern-C++/Item-17)\n\t* Smart Pointers\n\t\t* [Use **std::unique_ptr** for exclusive-ownership resource management](./Effective-Modern-C++/Item-18) \n        * [Use **std::shared_ptr** for shared-ownership resource management](./Effective-Modern-C++/Item-19)\n\t\t* [Use **std::weak_ptr** for **std::shared_ptr**-like pointers that can dangle](./Effective-Modern-C++/Item-20)   \n\t\t* [Prefer **std::make_unique** and **std::make_shared** to direct use of **new**](./Effective-Modern-C++/Item-21)   \n\t\t* [When using the **Pimpl** Idiom, define special member functions in the implementation file](./Effective-Modern-C++/Item-22)   \n\t* Rvalue References, Move Semantics, and Perfect Forwarding\n        * [Understand **std::move** and **std::forward**](./Effective-Modern-C++/Item-23)\n        * [Distinguish universal references from rvalue references](./Effective-Modern-C++/Item-24)\n        * [Use **std::move** on rvalue references, **std::forward** on universal references](./Effective-Modern-C++/Item-25)\n\t\t* [Avoid overloading on universal references](./Effective-Modern-C++/Item-26)\n\t\t* [Familiarize yourself with alternatives to overloading on universal references](./Effective-Modern-C++/Item-27)\n\t\t* [Understand reference collapsing](./Effective-Modern-C++/Item-28)\n\t\t* [Assume that move operations are not present, not cheap, and not used](./Effective-Modern-C++/Item-29)\n\t\t* [Familiarize yourself with perfect forwarding failure cases](./Effective-Modern-C++/Item-30)\n\t* Lambda Expressions\n\t\t* [Avoid default capture modes](./Effective-Modern-C++/Item-31)\n\t\t* [Use init capture to move objects into closures](./Effective-Modern-C++/Item-32)\n\t\t* [Use **decltype** on **auto\u0026\u0026** parameters to **std::forward** them](./Effective-Modern-C++/Item-33)\n\t\t* [Prefer lambdas to **std::bind**](./Effective-Modern-C++/Item-34)\n\t* The Concurrency API\n\t\t* [Prefer task-based programming to thread-based](./Effective-Modern-C++/Item-35)\n\t\t* [Specify **std::launch::async** if asynchronicity is essential](./Effective-Modern-C++/Item-36)\n\t\t* [Make **std::thread**s unjoinable on all paths](./Effective-Modern-C++/Item-37)\n\t\t* [Be aware of varying thread handle destructor behavior](./Effective-Modern-C++/Item-38)\n\t\t* [Consider **void** futures for one-shot event communication](./Effective-Modern-C++/Item-39)\n\t\t* [Use **std::atomic** for concurrency, **volatile** for special memory](./Effective-Modern-C++/Item-40)\n- [**\u003cC++ Software Design Principles\u003e**](https://www.oreilly.com/library/view/c-software-design/9781098113155/)\n\t* The Art of Software Design\n\t\t* [Understand the Importance of Software Design](./C++-software-design/item1.md)\n\t\t* [Design for Change](./C++-software-design/item2.md)\n\t\t* [Separate Interfaces to Avoid Artificial Coupling](./C++-software-design/item3.md)\n\t\t* [Design for Testability](./C++-software-design/item4.md)\n\t\t* [Design for Extension](./C++-software-design/item5.md)\n\t* The Art of Building Abstractions\n\t\t* [Adhere to the Expected Behavior of Abstractions](./C++-software-design/item6.md)\n\t\t* [Understand the Similarities Between Base Classes and Concepts](./C++-software-design/item7.md)\n\t\t* [Understand the Semantic Requirements of Overload Sets](./C++-software-design/item8.md)\n\t\t* [Pay Attention to the Ownership of Abstractions](./C++-software-design/item9.md)\n\t\t* [Consider Creating an Architectural Document](./C++-software-design/item10.md)\n\t* The Purpose of Design Patterns\n\t\t* [Understand the Purpose of Design Patterns](./C++-software-design/item11.md)\n\t\t* [Beware of Design Pattern Misconceptions](./C++-software-design/item12.md)\n\t\t* [Design Patterns Are Everywhere](./C++-software-design/item13.md)\n\t\t* [Use a Design Pattern's Name to communicate Intent](./C++-software-design/item14.md)\n\t* The Visitor Design Pattern\n\t\t* [Design for the Addition of Types of Operations](./C++-software-design/item15.md)\n    \t* [Use Visitor to Extend Operations](./C++-software-design/item16.md)\n\t\t* [Consider std::variant for Implementing Visitor](./C++-software-design/item17.md)\n\t\t* [Beware the Performance of Acyclic Visitor](./C++-software-design/item18.md)\n\t* The Strategy and Command Design Patterns\n\t\t* [Use Strategy to Isolate How Things Are Done](./C++-software-design/item19.md)\n\t\t* [Favor Composition over Inheritance](./C++-software-design/item20.md)\n\t\t* [Use Command to Isolate What Things Are Done](./C++-software-design/item21.md)\n\t\t* [Prefer Value Semantics over Reference Semantics](./C++-software-design/item22.md)\n\t\t* [Prefer a Value-Based Implementation of Strategy and Command](./C++-software-design/item23.md)\n\t* The Adapter, Observer, and CRTP Design Patterns\n\t\t* [Use Adapters to Standardize Interfaces](./C++-software-design/item24.md)\n\t\t* [Apply Observers as an Abstract Notification Mechanism](./C++-software-design/item25.md)\n\t\t* [Use CRTP to Introduce Static Type Categories](./C++-software-design/item26.md)\n\t\t* [Use CRTP for Static Mixin Classes](./C++-software-design/item27.md)\n\t* The Bridge, Prototype, and External Polymorphism Design Patterns\n\t\t* [Build Bridges to Remove Physical Dependencies](./C++-software-design/item28.md)\n\t\t* [Be Aware of Bridge Performance Gains and Losses](./C++-software-design/item29.md)\n\t\t* [Apply Prototype for Abstract Copy Operations](./C++-software-design/item30.md)\n\t\t* [Use External Polymorphism for Nonintrusive Runtime Polymorphism](./C++-software-design/item31.md)\n\t* The Type Erasure Design Pattern\n\t\t* [Consider Replacing Inheritance Hierarchies with Type Erasure](./C++-software-design/item32.md)\n\t\t* [Be Aware of the Optimization Potential of Type Erasure](./C++-software-design/item33.md)\n\t\t* [Be Aware of the Setup Costs of Owning Type Erasure Wrappers](./C++-software-design/item34.md)\n\t* The Decorator Design Pattern\n\t\t* [Use Decorators to Add Customization Hierarchically](./C++-software-design/item35.md)\n\t\t* [Understand the Trade-off Between Runtime and Compile Time Abstraction](./C++-software-design/item36.md)\t\n\t* The Singleton Pattern\n\t\t* [Treat Singleton as Implementation Pattern, Not a Design Pattern](./C++-software-design/item37.md)\t\n\t\t* [Design Singletons for Change and Testability](./C++-software-design/item38.md)\t\n","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fyukunj%2Fteach-myself-cpp","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fyukunj%2Fteach-myself-cpp","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fyukunj%2Fteach-myself-cpp/lists"}