Improve your C++! John Richardson. Lab Study Meeting 2013

Transcription

1 Improve your C++! John Richardson Lab Study Meeting 2013

2 Objectives How do I use the standard library correctly? What is C++11? Should I use it? Skills for debugging...? What kind of profiling is possible for C++?

3 A quick introduction: Clang An excellent C++ compiler Runs on LLVM framework Good support for C++11 Clear error messages Open source

4 Topics for today How do I use the standard library correctly? What is C++11? Should I use it? Skills for debugging...? What kind of profiling is possible for C++?

5 Standard Template Library (STL) Quick review of simple data structures: string, vector, map A look at some more advanced/new structures: unordered_map, set, list, deque,... Smart pointers: auto_ptr, scoped_ptr, shared_ptr,...

6 std::string (vs C char*) Wrapper for character array with useful functions Dynamically resizes and frees memory Not encoding-safe (just byte array) Does not necessarily end in \0 like C char* string char*???? b o o k b o o k... \0

7 std::vector (vs C array) Dynamic array, resizes automatically. Stored in a continuous block of memory, so quick for random lookup (e.g. vec[3] or vec[25]). It takes a long time to allocate memory, so if you know how much you need, use reserve. vector<t> T*???? v[0] v[1] v[2] v[3] v[0] v[1] v[2] v[3]...

8 std::map (no equivalent in C) Sorted map of key-value pairs (std::pair) Most implementations are red-black trees Commonly misused! dic.first = 'ball'.second = ' ボール ' dic['golf'] dic['ball']

9 std::list Doubly linked list. Not stored in continuous memory, so takes linear time for random access! However very fast (constant) to add/remove elements. Opposite performance to std::vector! t... l... a... k

10 std::set 5 Ordered set of elements 3 8 Unique keys Dynamically sorted/resized Typical implemenation is binary-search tree (red-black tree) {1, 2, 3, 5, 8, 22}

11 Queues and Stacks std::queue: Simple queue with push/pop operations. A C D std::deque (double-ended queue): A vector allowing amortised constant push/pop from both ends. A B B C D std::stack: A stack with push/pop operations. A B C D

12 std::unordered_{set, map} Same as set/map but not ordered! Usually implemented as hash map. Constant lookup! 本 book 水... water

13 Warning: Implementations Implementation not part of standard, only complexity. e.g. GNU stdlibc++ uses red-black trees for map, but not always the case. unordered_map and others only part of STL since C++11. Most containers are implemented in Boost (some in TR1/2 too).

14 There are many others! multiset, multimap,... bitset valarray rope

15 Exercise: Algorithms! 1. What is complexity of finding the size of a string vs. a char*? 2. Which is quicker to search: a vector or a set? 3. In what cases should you use map instead of unordered_map?

16 (Now for the scary part!) Smart Pointers Hoge *x = new Hoge; Hoge *y = x; delete x; delete y;?????? smart_ptr<hoge> x(new Hoge); smart_ptr<hoge> y = x; old, dangerous method new, safe method

17 So which type do I use??? Single ownership (transferable) Single ownership auto_ptr scoped_ptr Shared ownership (reference count) shared_ptr unique_ptr obsolete scoped_ptr speed unique_ptr shared_ptr functionality

18 Topics for today How do I use the standard library correctly? What is C++11? Should I use it? Skills for debugging...? What kind of profiling is possible for C++?

19 New Standard (C++11) Some new features: auto, for loops and initialisation Implementations: how do I use it?

20 New Features auto std::vector<std::map<std::string, double>> table; for (auto it = table.begin(); it!= table.end(); ++it) { auto copy = it->first;... } for loops std::vector<int> int_vec;... for (int i : int_vec) { std::cout << i << std::endl; } initialisation std::vector<std::string> words = { cat, fish }; std::vector<std::vector<int>> hoge = {{1}, {3, -1}}; Foo bar{1, hi };

21 New Features Lambda functions, nullptr,... Many, many more... New features in std library: regex, thread,... (basically Boost libraries are made 'official')

22 Implementations gcc ~ orchid: orchid40+: ~4.1 - zinnia: ~john/tools/gcc[-orchid]: clang ~ ~john/bin/clang: 3.3

23 Topics for today How do I use the standard library correctly? What is C++11? Should I use it? Skills for debugging...? What kind of profiling is possible for C++?

24 Debugging Errors/warnings gdb overview Using assert valgrind

25 Errors and Warnings Warnings: use them! -Wall -Werror Errors: use clang to make them clearer...

26 clang vs. g++ error messages a.cpp:7: error: conversion from std::vector<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > to non-scalar type std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > requested

27 clang vs. g++ error messages a.cpp:7:40: error: no viable conversion from 'std::vector<std::string>' to 'std::map<std::string, std::string>'

28 gdb overview Compile with debug options: (g++/clang) $ g++ -g a.cpp -o a.out Run gdb: $ gdb./a.out backtrace (bt) list (l) print (p)... (many others!)

29 [DEMO]

30 A memory checker and much more!

31 valgrind demo Compile with -g flag $ valgrind a.out Tools: --tool=cachegrind --tool=massif Useful options: --leak-check=full --track-origins=yes

32 [DEMO]

33 Topics for today How do I use the standard library correctly? What is C++11? Should I use it? Skills for debugging...? What kind of profiling is possible for C++?

34 Profiling gprof call sampler massif heap profiler kcachegrind cache profiler

35 gprof demo Compile with -pg flags: $ g++ -pg a.cpp Run the program: $./a.out Run gprof: $ gprof./a.out less

36 [DEMO]

37 massif demo Heap profiler Compile with debugging info $ valgrind --tool=massif./a.out $ ms_print massif.out.{pid} less

38 ASCII art!

39 [DEMO]

40 (k)cachegrind demo Cache and branch-prediction profiler Compile with debug symbols $ valgrind --tool=cachegrind./a.out $ kcachegrind cachegrind.out.{pid}

41 [DEMO]

42 Bonus section Pointers vs. References Obj x; Obj *ptr = &x; ptr++; *ptr = 3; Obj x; Obj &ref = x; ref = 3;

43 When should I use references? Obj x; Obj *ptr = &x; ptr++; *ptr = 3; Convenient: no more stars! Safe: always points to the same object Obj x; Obj &ref = x; ref = 3;

44 A very important example void print(std::string str) { std::cout << str << std::endl; } void print(std::string *str) { std::cout << *str << std::endl; } void print(std::string &str) { std::cout << str << std::endl; } (Yes, it would be better to use const, but it's nearly 5pm...)

45 A very important example void print(std::string str) { std::cout << str << std::endl; } void print(std::string *str) { std::cout << *str << std::endl; } void print(std::string &str) { std::cout << str << std::endl; } No! Makes a copy! (Yes, it would be better to use const, but it's nearly 5pm...)

46 A very important example void print(std::string str) { std::cout << str << std::endl; } void print(std::string *str) { std::cout << *str << std::endl; } void print(std::string &str) { std::cout << str << std::endl; } No! Makes a copy! Mehh... hard to read and not safe. (Yes, it would be better to use const, but it's nearly 5pm...)

47 A very important example void print(std::string str) { std::cout << str << std::endl; } void print(std::string *str) { std::cout << *str << std::endl; } void print(std::string &str) { std::cout << str << std::endl; } No! Makes a copy! Mehh... hard to read and not safe. Yes! Safe, simple. (Yes, it would be better to use const, but it's nearly 5pm...)

48 Now you are a C++ expert! Thanks for listening.