C++23 Fundamentals with Projects & Algorithms from Udemy

Master Modern C++ with Real-World Projects & Industry Tools

C++ is one of the most powerful programming languages, but learning it the right way makes all the difference. C++23 Fundamentals with Projects & Algorithms is not just another beginner’s course—it’s designed to teach you modern C++ the way professionals use it.

Unlike courses that focus on small, standalone code snippets, this course immerses you in real-world development from the start. You'll build structured projects using industry-standard tools like modern CMake, vcpkg, and third-party libraries—the same tools used by professional C++ developers.

What You'll Learn:

C++ Standards: C++11, C++14, C++20, and C++23 – Master the latest features while ensuring you can work with and improve legacy codebases.
Structured projects, not just toy examples – Learn to organize code across multiple files and build projects like in real development environments.
Industry-standard tools – Get hands-on experience with modern CMake, vcpkg, and external libraries to develop scalable applications.
Algorithms & data structures – Strengthen your problem-solving skills with key algorithmic concepts.
Debugging & compile time computations – Write efficient, compile-time friendly C++ and learn how to troubleshoot issues.
File I/O, GUI development & more – Work with files, create user interfaces, and explore advanced C++ topics.

This course is built by the instructor of the popular C++20 Masterclass and pushes things even further—bringing you closer to how C++ is actually used in practice. Whether you're new to C++ or looking to modernize your skills, this course will equip you with the right tools and mindset for real-world development.

What's inside

Learning objectives

Modern c++23 – write efficient, maintainable, and modern c++ code using the latest language features.
Using pro tools – build projects with cmake, vcpkg, and third-party libraries like a professional.
Debugging like a pro – learn debugging techniques using the debugger coming with your compiler.
Handleing file i/o – work with modern c++ file handling using std::filesystem and streams.
Building gui apps – create graphical applications using libraries like sfml and ftxui

Memory management – understand raii, smart pointers, and modern memory management techniques.
Working with containers – use stl containers effectively and understand their best use cases.
Writing modular code – build scalable projects with c++20 modules and best design practices.
Optimizing performance – write high-performance c++ using smart pointers, compile time computations, move semantics, and efficient algorithms.

Modern c++23 – write efficient, maintainable, and modern c++ code using the latest language features.
Using pro tools – build projects with cmake, vcpkg, and third-party libraries like a professional.
Debugging like a pro – learn debugging techniques using the debugger coming with your compiler.
Handleing file i/o – work with modern c++ file handling using std::filesystem and streams.
Building gui apps – create graphical applications using libraries like sfml and ftxui
Memory management – understand raii, smart pointers, and modern memory management techniques.
Working with containers – use stl containers effectively and understand their best use cases.
Writing modular code – build scalable projects with c++20 modules and best design practices.
Optimizing performance – write high-performance c++ using smart pointers, compile time computations, move semantics, and efficient algorithms.

Syllabus

Introduction

Welcome

Get The Most

What You Will Achieve

Turn your project upside down and understand how it's put together. Let's go!

Traffic lights

Read about what's good

what should give you pause

and possible dealbreakers

Covers C++11, C++14, C++20, and C++23, ensuring learners can work with modern features and improve legacy codebases, which is essential for professional development

Uses industry-standard tools like modern CMake and vcpkg, providing practical experience relevant to real-world C++ development environments, which is highly valued in the industry

Includes hands-on experience with external libraries, enabling learners to develop scalable applications, which is a core skill for professional C++ developers

Strengthens problem-solving skills with key algorithmic concepts, which is crucial for efficient and effective C++ programming in various applications

Teaches debugging techniques using the debugger coming with your compiler, which is essential for identifying and resolving issues in C++ code

Requires learners to set up a development environment using tools like Docker, which may present a barrier for some beginners without prior experience, but is standard in the industry

Reviews summary

Modern c++ with real-world focus

According to learners, this course provides a strong foundation in modern C++23, emphasizing practical application with industry-standard tools like CMake and vcpkg. Students particularly appreciate the focus on building structured projects rather than simple code snippets, mirroring real-world development environments. While the comprehensive syllabus covers a wide range of topics from fundamentals to advanced areas like GUI and performance, some beginners might find the pace or complexity challenging, especially when navigating the toolchain setup. Overall, it appears well-suited for those looking to develop professional C++ skills.

Wide range of topics covered.

"The syllabus is very extensive, covering many C++ concepts."

"From basics to GUI and performance, it touches on many areas."

"A broad overview of the C++ ecosystem."

Teaches up-to-date C++ versions.

"I really appreciated the emphasis on C++23 and recent standards."

"Covers modern features that are relevant in current development."

"Updates on C++11, 14, 20, and 23 were very helpful."

Hands-on experience with industry tools.

"Learning to use CMake and vcpkg from the start was a game-changer."

"The projects felt like real tasks I'd encounter professionally."

"Building projects across multiple files is much better than simple examples."

Pace may be fast for absolute newcomers.

"As a beginner, I sometimes felt the pace was quite fast."

"Some advanced topics require prior programming understanding."

"Might be better suited if you have a little C++ background already."

Setting up the required tools can be difficult.

"Getting CMake and vcpkg configured correctly took some effort."

"Environment setup instructions could be clearer for different systems."

"Troubleshooting toolchain issues was the hardest part for me."

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in C++23 Fundamentals with Projects & Algorithms with these activities:

Review C++ Basics

Show steps

Solidify your understanding of fundamental C++ concepts before diving into the advanced topics covered in this course. This will help you grasp the new material more easily.

Show steps

Review basic syntax, data types, and operators.
Practice writing simple programs using loops and conditional statements.
Familiarize yourself with pointers and memory management concepts.

Review 'Effective Modern C++'

Show steps

Deepen your understanding of modern C++ idioms and best practices. This book will help you write more efficient and maintainable code.

View Effective Modern C++ on Amazon

Show steps

Read through the chapters relevant to the course syllabus.
Try out the code examples provided in the book.
Take notes on key concepts and techniques.

Write a Blog Post on Modern C++ Features

Show steps

Solidify your understanding of modern C++ features by explaining them in a blog post. This will force you to think critically about the concepts and communicate them effectively.

Show steps

Choose a specific modern C++ feature (e.g., move semantics, lambda expressions, constexpr).
Research the feature thoroughly and understand its benefits and drawbacks.
Write a clear and concise explanation of the feature with code examples.
Proofread and edit your blog post.
Publish your blog post online.

Four other activities

Expand to see all activities and additional details

Show all seven activities

Implement Data Structures and Algorithms

Show steps

Reinforce your understanding of data structures and algorithms by implementing them from scratch. This will improve your problem-solving skills and prepare you for more complex projects.

Show steps

Choose a data structure or algorithm to implement (e.g., linked list, binary search tree, sorting algorithm).
Write the code in C++ using modern C++ features.
Test your implementation thoroughly with various inputs.
Refactor your code for clarity and efficiency.

Build a Simple Game with SFML

Show steps

Apply your C++ knowledge to build a graphical application using SFML. This will give you hands-on experience with GUI development and solidify your understanding of C++ concepts.

Show steps

Set up SFML in your development environment.
Design the game mechanics and user interface.
Implement the game logic using C++ and SFML.
Test and debug your game.
Add features and polish the game.

Review 'C++ Concurrency in Action'

Show steps

Expand your knowledge of concurrency and multithreading in C++. This book will help you write efficient and robust concurrent applications.

View C++ Concurrency in Action on Amazon

Show steps

Read the chapters on threads, mutexes, and condition variables.
Experiment with the code examples provided in the book.
Try to apply concurrency techniques to your own projects.

Contribute to a C++ Open Source Project

Show steps

Gain real-world experience by contributing to a C++ open source project. This will expose you to industry coding standards, collaborative development practices, and complex codebases.

Show steps

Find a C++ open source project that interests you.
Read the project's documentation and contribution guidelines.
Identify a bug or feature to work on.
Submit a pull request with your changes.
Respond to feedback from the project maintainers.

Career center

Learners who complete C++23 Fundamentals with Projects & Algorithms will develop knowledge and skills that may be useful to these careers:

Game Developer

A game developer brings virtual worlds to life, and C++ is a cornerstone language in the industry. This course helps build a foundation in modern C++, which is heavily used in game engines like Unreal Engine. You'll gain experience with industry-standard tools like CMake and vcpkg, essential for managing dependencies in complex game projects. The course emphasizes building structured projects rather than just toy examples, mirroring the demands of game development, where organizing code across multiple files is critical. Furthermore, the focus on algorithms and data structures will be incredibly useful for optimizing game performance. Learning debugging techniques is essential, as performance is critical.

See salaries and explore the career path for Game Developer

Software Engineer

Software engineers design, develop, test, and deploy software applications. The focus on modern C++ makes this a strong pick, due to its performance and control. This course helps build a foundation in modern C++, covering standards up to C++23. The course's focus on structured projects and industry-standard tools like CMake and vcpkg is invaluable, as these are the tools professionals use to manage complex software projects. Moreover, the emphasis on algorithms, data structures, and debugging techniques ensures that you can write efficient and maintainable code. Furthermore, it may be useful to learn how to build scalable applications using C++20 modules.

See salaries and explore the career path for Software Engineer

Robotics Engineer

Robotics engineers design and develop robots and robotic systems, and C++ is often used to program them. This course helps build a foundation in modern C++, which is crucial for writing efficient and reliable robot control software. You will gain hands-on experience with industry-standard tools like CMake, which are essential for managing the dependencies. The emphasis on algorithms and data structures is also critical for robot path planning, and debugging techniques will prove invaluable. Robots must function in a reliable automated way, so skills like modularity and memory management are useful.

See salaries and explore the career path for Robotics Engineer

Embedded Systems Engineer

Embedded systems engineers work on the software and hardware that power devices like IoT gadgets. This course helps build a foundation in modern C++, which embedded systems heavily rely on due to its performance and low-level control. You will gain experience with industry-standard tools like CMake and vcpkg, which are beneficial for managing cross-compilation and dependencies. The lessons on algorithms, data structures, and debugging techniques are also highly relevant, as is the focus on writing high-performance code using smart pointers, compile-time computations, and move semantics. Finally, the course's mention of file I/O is helpful.

See salaries and explore the career path for Embedded Systems Engineer

Quantitative Analyst

Quantitative analysts, or quants, use mathematical and statistical methods to solve problems in finance, and C++ is sometimes used for high-performance computing. This course helps build a foundation in modern C++, which is useful for writing efficient and fast financial models. You will learn about algorithms and data structures, which are used for processing financial data. The emphasis on optimization techniques, smart pointers, and move semantics will also be highly relevant. Finally, the course's lessons about working with modular code should prove useful.

See salaries and explore the career path for Quantitative Analyst

Compiler Developer

Compiler developers work on the programs that translate human-readable code into machine-executable instructions. This course may offer valuable knowledge for such a role. You will gain a deep understanding of C++ standards up to C++23, which is essential for understanding how compilers process the language. The emphasis on compile-time computations and optimization techniques will prove invaluable. By building skills in debugging, you might be able to resolve compiler issues.

See salaries and explore the career path for Compiler Developer

Operating Systems Developer

Operating systems developers work on the core software that manages computer hardware and resources. This course helps build a foundation in modern C++, which is often used in operating systems development. You will gain a solid awareness of memory management techniques, which are crucial for writing stable and efficient operating system code. The lessons on debugging techniques and performance optimization will also be of great benefit to your career.

See salaries and explore the career path for Operating Systems Developer

Database Engineer

Database engineers design, implement, and maintain databases. This course may be helpful due to the high-performance requirements of many databases. You will learn about algorithms and data structures, which are essential for optimizing database queries. Gaining experiences with C++20 modules will help you design scalable systems.

See salaries and explore the career path for Database Engineer

Financial Software Developer

Financial software developers create and maintain the software used by financial institutions. This course may be helpful because of the high-performance requirements of financial software. You will learn about algorithms and data structures, which are essential for processing financial data efficiently. The emphasis on modern C++ standards will help you write code that is easier to maintain and evolve and the course's lessons regarding modularity can give you a start to designing scalable systems.

See salaries and explore the career path for Financial Software Developer

High-Performance Computing Engineer

High performance computing engineers design and maintain systems for computationally intensive tasks. While this course is not specifically geared towards high performance computing, it may be useful by building a foundation in modern C++, which is often used in the field. You will learn about algorithms and data structures, which are essential for optimizing code. The emphasis on debugging can help you get to the bottom of performance issues.

See salaries and explore the career path for High-Performance Computing Engineer

Compiler Verification Engineer

Compiler verification engineers ensure the correctness and reliability of compilers through testing and validation. While this course does not specifically address compiler verification, it may be helpful for understanding the intricacies of C++ and how compilers process it. By learning debugging techniques, you can catch compiler issues.

See salaries and explore the career path for Compiler Verification Engineer

Kernel Developer

Kernel developers work on the core of an operating system. While this course does not directly focus on kernel development, it may be useful through its instruction on modern C++. Knowledge of memory management is also emphasized. The lessons on modularity can help you design scalable kernels.

See salaries and explore the career path for Kernel Developer

Application Developer

Application developers create software applications for various platforms, and C++ can be used for certain types of applications. While this course does not specifically focus on application development, it may be useful as an introduction to the language. You will be provided with tools to design modular code. Finally, the course touches on graphical user interfaces.

See salaries and explore the career path for Application Developer

Software Architect

Software architects design the structure of software systems. The course may be helpful due to the emphasis on C++20 modules. You will learn about industry-standard tools like CMake, which are essential for maintaining projects. This can help you design scalable application architectures.

See salaries and explore the career path for Software Architect

Technical Writer

Technical writers create documentation for software. This course may be useful for gaining a deeper understanding of C++, which can then be translated into clear and accurate documentation. By understanding the C++ standards, you can be a more effective technical writer. The skills taught in debugging can help you understand error messages.

See salaries and explore the career path for Technical Writer

C++23 Fundamentals with Projects & Algorithms

What's inside

Learning objectives

Syllabus

Traffic lights

Save this course

Reviews summary

Modern c++ with real-world focus

Activities

Career center

Reading list

Share

Similar courses