QA Systems Akademie

Wer Bestes leisten will, braucht bestes Werkzeug und das Wissen, wie man damit umgeht. Wie die Möglichkeiten von Programmiersprachen besser genutzt und Werkzeuge optimal eingesetzt werden, erfahren Sie bei den Schulungen und Workshops von QA Systems. Nutzen Sie das Know-how und die Erfahrung weltweit führender Experten. In unserer Akademie stehen sie Ihnen regelmäßig Rede und Antwort. Allen voran der Autor, Consultant und C++-Experte Dr. Scott Meyers.

Seminardetails

NEUES SEMINAR: Effective C++11/14 Programming

Termin: 14. - 15. November 2013
Dauer: 9:00 Uhr bis ca. 17:00 Uhr
Ort: Steigenberger Graf Zeppelin, Stuttgart
Sprache: Englisch
Referent: Dr. Scott Meyers
Frühbucherrabatt: 1.850,- € zzgl. MwSt. bei Anmeldung bis 14.08.2013
Kosten: 1.990,- € zzgl. MwSt. inklusive Buchgutschein für "Effective C++11"
Paketpreis bei Buchung mit dem Seminar "An Overview of the New C++ (C++11/14)": 3.500,- € bzw. 3.250,- € als Frühbucher! (je zzgl. MwSt.) Wird - bei Eingang beider Anmeldungen - automatisch vermerkt!

Diese Seminarbeschreibung dient als grober Anhaltspunkt. Da es sich um ein brandneues Seminar handelt, werden die Seminarinhalte von Dr. Scott Meyers kontinuierlich aktualisiert.

Software developers familiar with the fundamentals of C++11 are ready to advance from knowing what's in C++11 to understanding how to apply it effectively. This seminar, based on information in Scott Meyers´ forthcoming Effective C++11, highlights the insights and best practices of the most accomplished C++11 programmers: the things they almost always do (or almost always avoid doing) to produce clear, correct, efficient code.

Who should attend

Systems designers, programmers, and technical managers involved in the design, implementation, and maintenance of production libraries and applications using C++11. Participants should understand the basic features of C++11 (e.g., rvalue references, lambda expressions, smart pointers, threads and futures, variadic templates), but expertise is not required. One way to acquire the necessary background is to participate in Scott’s companion seminar, Overview of the New C++ (C++11/14).

Format

The seminar is based on lecture presentations, with ample time for questions and discussion by attendees. There are no hands–on exercises, but participants are welcome – encouraged! – to use their C++ development environments to experiment with the ideas in the seminar as they are presented.

What you will learn

Topics to be addressed in the seminar are listed below. Most take the form of guidelines, but the topics listed for the C++11 threading API are currently in a different form ("secrets" instead of guidelines). It is anticipated that these topics will ultimately also be addressed in the form of usage guidelines.

Moving from C++98 to C++11

  • Prefer auto to explicit type declarations.
  • Remember that auto + { expr } = std::initializer_list.
  • Prefer nullptr to 0 and NULL.
  • Prefer enum classes to enums.
  • Prefer alias templates to typedefs.
  • Declare overriding functions override.
  • Distinguish () and {} when creating objects.
  • Prefer emplacement to insertion.
  • Declare functions noexcept whenever possible.
  • Make const member functions thread-safe.
  • Avoid std::enable_if in function signatures.
  • Handle iterators where copying means moving.

Rvalue References, move semantics, and perfect forwarding

  • Distinguish universal references from rvalue references.
  • Avoid overloading on universal references.
  • Pass and return rvalue references via std::move, universal references via std::forward.
  • Assume that move operations are not present, not cheap, and not used.
  • Be aware of perfect forwarding failure cases.

Secrets of the C++ 11 Threading API

  • Thread construction may throw.
  • Destroying a joinable thread calls terminate.
  • Arguments passed to std::thread, std::async, and std::call_once are unconditionally copied.
  • std::async is really two different functions with somewhat different APIs.
  • Futures from std::async are special.
  • void futures can be used for interthread communication.
  • To poll a future, use wait_for with a zero timeout.
  • Native handles let you go beyond the C++11 API.
  • Clock adjustments affect _until functions.

Lambda expressions

  • Prefer lambdas to std::bind.
  • Prefer lambdas to variadic arguments for threading functions.
  • Beware default captures in member functions.

Smart pointers

  • Use std::make_shared whenever possible.
  • Prefer pass–by–ref–to–const to pass–by–value for std::shared_ptrs.

Miscellaneous

  • Pass by value when you'll copy your parameter.
  • Keep abreast of standardization developments.

Seminarbeschreibung mit Anmeldeformular als PDF finden Sie hier.

zurückJetzt anmelden
Jetzt anmelden