Advanced C++
| Course length: | 3 days |
| Dates/Locations: | see course schedule |
| Price: | € 1425,– (excluding VAT) |
| Included: all course materials, lunch, coffee, tea, soda, and snacks | |
| Registration: | Online registration form |
This course can also be given in-house. Contact us for more information.
Target audience
You are a software developer who has been working comfortably at the junior level for some while, but you have reached a plateau. You are ready to move to the next level, and use the C++ features you already know in new and better ways, so that the software you build becomes more elegant, is easier to write, understand, to adapt to changing requirements, has fewer errors, and is more efficient as well.
Prerequisites: you have at least one year of programming experience in C++ or a syntactically similar language (e.g., C, C#, Java), and you are familiar with the basics of C++: syntax, built-in data types, control structures, unions, structs, classes, (copy) constructors, destructors, assignment operator, parameter passing mechanisms, access specifiers, arrays and pointers, simple STL usage (strings, vectors), basic exception handling, polymorphism, memory management with new and delete.
Contact us if you are unsure if this is the right course for you.
What you will learn
Although you will learn some new features and properties of C++, the main focus of this course is on higher-level, idiomatic aspects of C++ programming. You will learn to make an informed and balanced choice between design options, such as inheritance versus composition versus delegation, or run-time versus compile-time polymorphism. You will deepen your understanding of the STL and boost, see how the containers, algorithms, iterators, and function objects fit together extremely well and have a wider application in your own code than you have ever thought before. You will learn techniques that make memory leaks a problem of the past, and you will see how the same techniques can be applied to avoid leaking other kinds of resources, such as database connections, file handles, and synchronisation locks. You will gain a deeper understanding of exception handling, see how it fits in an overall error handling strategy to make your code more robust, and you will see the strong connection between exception handling and safe resource management. You will learn when it makes sense to optimise code and when not, how to identify performance bottlenecks, and how to remove them.
All techniques you learn in this course are applicable in your daily programming work. This course not only makes your work more interesting and fun, but will also enable you to write significantly better code in at least 10% less time. You will look forward to your next performance review.
Course format
The balance between theory and practice in this course is about 70% to 30%. We will not do programming assignments in class, since at this course level, the the time spent on non-trivial programs does not pay off. Instead, in the practical assignments you will be asked to make design decisions—the very kind of decisions you encounter in practice—and to motivate them, based on what you learned in the theoretical part of the course. Some of the assignments are done individually, others in pairs.
The group size is at most 12 persons, so that the difference in experience between participants will not be too large, and such that we can cater to the individual needs and learning goals of all participants.
If all participants speak Dutch, the course is given in Dutch; otherwise, the course is given in English. All course materials are in English.
As all other 59bits courses, this course is intensive and high-paced, but with sufficient smaller and larger breaks to rejuvenate, and to enable you to to process and retain all course content.
Please make sure to read our general course information.
Course topics/keywords
The following list of topics is not exhaustive, and is meant to give you an impression of what you can expect:
- Class design: class responsibilities; encapsulation; coupling and cohesion; delegation and composition
- Proper use of inheritance: Liskov substitution principle
- Detailed exception handling: basic, strong and no-fail guarantee; exception specifications; uncaught_exceptions
- Fail-safe resource management: the RAII idiom, smart pointers
- Generic programming: writing template classes and functions
- STL and boost: containers, iterators, algorithms, and function objects; lambdas,
adapters, inserters, stream iterators; associative containers: sets, maps, hash-maps - Performance: profiling and tuning
- C++0x: language features in the new standard