C talk
This presentation is the property of its rightful owner.
Sponsored Links
1 / 29

C++ Talk PowerPoint PPT Presentation

  • Uploaded on
  • Presentation posted in: General

C++ Talk. The short version! :D. You’ll hopefully know the basics, so this talk covers: C++ templates C++11 cool things. Overview. Conceptually similar to Java generics More powerful though. C++ Templates. C++ Template Examples. C++ Template Examples. C++ Template Examples.

Download Presentation

C++ Talk

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

C talk

C++ Talk

The short version! :D


You’ll hopefully know the basics, so this talk covers:

  • C++ templates

  • C++11 cool things


C templates

  • Conceptually similar to Java generics

  • More powerful though

C++ Templates

C template examples

C++ Template Examples

C template examples1

C++ Template Examples

C template examples2

C++ Template Examples

C template thoughts

  • Generated granularly on-demand

    • “Granularly” explained in a minnit.

  • Can be inlined

  • Fast at runtime

C++ Template Thoughts

C talk

This part intentionally left blank.

C 11 cool things

  • Static_assert

  • STL threading (with a new memory model!)


  • Lambdas

  • Why you shouldn’t use normal arrays

  • Move semantics (the important part)

C++11 Cool THings

Static assert


Static assert continued

Static_Assert continued

First off lambdas

First off, Lambdas!

Lambdas capture group

(‘i’ is read-only in this context. So we can’t do ++i)

Lambdas – Capture Group

Lambdas argument return

Lambdas – Argument/Return



Threading native handle

Threading – native_handle()

Threading atomic data types

  • Under <atomic>

  • Everything from atomic_float to atomic_uint_fast32_t

Threading – Atomic Data TYpes

Rrid stuffs

  • Std::shared_ptr<T>

  • Std::unique_ptr<T>

  • Std::weak_ptr<T>

RRID Stuffs

Std shared ptr


Std unique ptr


Std weak ptr


Std vector std array

  • (std::vector | std::array) > raw arrays

    • Checked STL

    • [] guarantees 0 bounds checking with unchecked STL

    • Iterator support

    • Support for .size()/.max_size()


Std array


Std vector


Move semantics

  • Allow for no-fail moving from one variable to another

  • Really low overhead

  • Can be used in place of copying somewhat often

  • I like to move it, move it.

Move semantics

What are move semantics

  • Denoted by && ‘double-ref/ref-ref’

  • Basically:

    • One variable, A, kills another, b.

    • A steals b’s innards

    • A places b’s innards in itself

What are move semantics?

Why do we care

  • Example of strings using copy vs move constructors:

    • By doing copy = primary, invoke string copy constructor

      • Allocate new char[]

      • Copy from primary to copy…

    • By doing move = primary, invoke string move constructor

      • Steal char[] pointer from primary

      • “Primary” is no longer useable after this.

Why do we care?

Why do we care1

  • This code used to be bad:

    • It would call string::string(conststring&) once or twice

  • Now it calls string::string(string&&) once or twice

    • Now just a maximum of six assignments

      • As opposed to 2 allocs, 6 assignments, 2 memcpys

Why do we care?


  • Std::thread provides for easy threading

  • Templates are extremely flexible

    • Also generated on demand

  • Lambdas are great for one-off functions

  • Use std::unique_ptr and std::shared_ptr in place of raw pointers

  • Use std::array/std::vector instead of raw arrays


  • Login