EvoClass

Belajar lebih cerdas

Kembali ke Kursus
AI013 Profesional

Tutorial C++ Modern

Tutorial ini bertujuan untuk memberikan referensi cepat bagi pengembang berpengalaman mengenai fitur-fitur baru C++11/14/17/20. Ini mencakup peningkatan kenyamanan bahasa, peningkatan runtime, container baru, pointer cerdas dan manajemen memori, ekspresi reguler, pemrograman konkuren, serta gambaran singkat tentang C++20.

4.8
30.0h
318 siswa
10 lessons
2 suka
Kecerdasan Buatan
Mulai Belajar

Gambaran Umum Kursus

📚 Ringkasan Konten

Tutorial ini dirancang untuk memberikan referensi cepat bagi pengembang berpengalaman mengenai fitur-fitur baru C++11/14/17/20. Konten mencakup peningkatan kenyamanan bahasa, peningkatan runtime, penggunaan container baru, pointer pintar dan manajemen memori, ekspresi reguler, pemrograman konkuren, serta gambaran awal tentang C++20.

Cepat pahami C++11/14/17/20 dan langkah menuju dunia pemrograman C++ modern.

Penulis: 欧长坤 (Ou Changkun)

Ucapan Terima Kasih: Dilisensikan di bawah lisensi CC BY-NC-ND 4.0, terima kasih kepada semua kontributor GitHub dan dukungan komunitas terkait.

🎯 Tujuan Pembelajaran

  1. Mengidentifikasi dan memverifikasi lingkungan kompiler C++ dan arsitektur target menggunakan alat baris perintah.
  2. Menjelaskan kompatibilitas standar dan sejarah tumpang tindih antara C (C89, C99, C11) dan C++ (C++98, C++1x).
  3. Menerapkan tautan lintas bahasa secara fungsional dengan menggunakan header extern "C" dan alur kerja kompilasi multi-tahap.
  4. Menyelesaikan ambiguitas pointer menggunakan nullptr dan menerapkan logika compile-time menggunakan constexpr dan if constexpr.
  5. Menyederhanakan deklarasi kompleks menggunakan auto, decltype, dan alias tipe (using) sambil memastikan desain berbasis objek yang kuat dengan override dan final.
  6. Merancang kode yang sangat generik menggunakan template variadic, ekspresi lipat, dan deduksi parameter template non-type.
  7. Mendefinisikan dan menerapkan ekspresi Lambda dengan berbagai mode tangkapan (Nilai, Referensi, Ekspresi, dan Umum).
  8. Memanfaatkan std::function dan std::bind untuk membuat pembungkus fungsi fleksibel dan aplikasi parsial fungsi.
  9. Mengategorikan ekspresi menjadi Lvalue, Prvalue, dan Xvalue, serta menerapkan Semantik Pindah untuk mengoptimalkan manajemen sumber daya kelas.
  10. Membedakan antara model memori dan kasus penggunaan std::array (ukuran tetap, stack) dan std::vector (ukuran dinamis, heap).

Pelajaran 共 10 课时 · 预计 30.0h

Pelajaran

Lesson

1 Lesson 1

This lesson explores the evolution of C++ and the importance of adopting modern, type-safe coding practices over legacy C-style habits. Students will learn to utilize explicit casting operators and compiler diagnostics to improve code stability, security, and performance.

2 Lesson 2

This lesson explores modern C++ language usability by addressing the "NULL Trap" through the introduction of `nullptr` and examining how `constexpr` and `noexcept` shift computation and error handling to compile-time. Students will learn to improve code safety and performance by replacing legacy C-style macros and casts with modern, type-safe alternatives.

3 Lesson 3

This lesson explores performance optimization in modern C++ through move semantics, lambda expressions, and efficient memory management. Students will learn to leverage zero-cost abstractions like std::array and SFINAE to improve code performance and type safety in resource-constrained environments.

4 Lesson 4

This lesson explores the transition from legacy C-style arrays to the modern std::array, highlighting how the latter provides type safety and STL integration without sacrificing performance. Students will learn to leverage stack-based memory allocation, bounds-checking, and perfect forwarding to write more efficient and robust C++ code.

5 Lesson 5

This lesson explores the pitfalls of manual memory management, such as memory leaks and dangling pointers, and introduces RAII (Resource Acquisition Is Initialization) as a safer, automated alternative. Students will learn how to utilize smart pointers like std::unique_ptr, std::shared_ptr, and std::weak_ptr to ensure deterministic resource cleanup and exception safety in modern C++.

6 Lesson 6

This lesson explores the transition from imperative, manual string searching to declarative pattern matching using regular expressions and formal grammars. Students will learn to apply regex metacharacters and anchors to efficiently parse unstructured data while understanding the performance benefits of using Deterministic Finite Automata.

7 Lesson 7

This lesson explores the transition to standardized concurrency in C++11, which introduced a formal memory model and native thread support to replace platform-specific APIs. Students will learn to manage thread lifecycles, ensure cross-platform data consistency with standardized types, and use the noexcept specifier to maintain program stability in multi-threaded environments.

8 Lesson 8

This lesson explores the evolution of C++ from platform-specific coding to a unified, high-level abstraction layer, focusing on the transition from legacy macros to modern standards. Students will learn to leverage C++11 concurrency features and C++23 filesystem utilities to write portable, maintainable code that avoids OS-specific dependencies.

9 Lesson 9

This lesson explores modernizing C++ development by transitioning from platform-specific APIs to standardized, high-level abstractions like task-based parallelism and the C++11 memory model. Students will learn to improve code maintainability and safety by utilizing features such as std::future, std::atomic, and extended integer types like long long int.

10 Lesson 10

This lesson explores the evolution of C++20, focusing on the "Big Four" features—Concepts, Modules, Coroutines, and Ranges—that shift the language toward a more declarative and efficient programming model. Students will learn how these tools improve code safety, reduce build times, and replace complex template metaprogramming with clearer, constrained syntax.