c talk
Skip this Video
Download Presentation
C++ Talk

Loading in 2 Seconds...

play fullscreen
1 / 29

C++ Talk - PowerPoint PPT Presentation

  • Uploaded on

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.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about ' C++ Talk' - kylee

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

c template thoughts

Generated granularly on-demand

    • “Granularly” explained in a minnit.
  • Can be inlined
  • Fast at runtime
C++ Template Thoughts
c 11 cool things


  • STL threading (with a new memory model!)
  • Lambdas
  • Why you shouldn’t use normal arrays
  • Move semantics (the important part)
C++11 Cool THings
threading atomic data types

Under <atomic>

  • Everything from atomic_float to atomic_uint_fast32_t
Threading – Atomic Data TYpes
rrid stuffs


  • Std::unique_ptr<T>
  • Std::weak_ptr<T>
RRID Stuffs
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()
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