Sequential Containers. Ali Malik
|
|
|
- Madison Hines
- 6 years ago
- Views:
Transcription
1 Sequential Containers Ali Malik
2 Game Plan Recap Overview of STL Sequence Containers std::vector std::deque Container Adapters
3 Announcements
4 Recap
5
6 getline vs >> Bug favnum = fullname = What happens if we mix cin and getline? position \n
7 getline vs >> Bug favnum = fullname = What happens if we mix cin and getline? 7 position int favnum; cin >> favnum; 2 9 \n
8 getline vs >> Bug favnum = fullname = What happens if we mix cin and getline? 7 position int favnum; cin >> favnum; 2 9 \n
9 getline vs >> Bug favnum = 729 fullname = What happens if we mix cin and getline? \n position
10 getline vs >> Bug favnum = 729 fullname = What happens if we mix cin and getline? \n position string fullname; getline(cin, fullname);
11 getline vs >> Bug favnum = 729 fullname = What happens if we mix cin and getline? \n position string fullname; getline(cin, fullname);
12 getline vs >> Bug favnum = 729 fullname = "" What happens if we mix cin and getline? \n position
13 getline vs >> Bug We can fix this by consuming the newline character after using cin! int favnum; cin >> favnum; cin >> ws; // extracts as many whitespace chars as possible from current position in stream string fullname; getline(cin, fullname); // no residual newline char in stream
14 Useful Aside
15
16 Structs You can define your own mini-types that bundle multiple variables together: struct point { int x; int y; }; Useful for Assignment
17 Structs struct point { int x; int y; }; point p; p.x = 2; p.y = ;
18 Overview of STL
19 Overview of STL As mathematicians learned to lift theorems into their most general setting, so I wanted to lift algorithms and data structures - Alex Stepanov, inventor of the STL
20 Overview of STL Algorithms Iterators Allocators Containers Functors/Lambdas Adapters
21 Overview of STL Algorithms Iterators Allocators Containers Functors/Lambdas Adapters
22 Where we are going... Here is a program that generates a vector with random entries, sorts it, and prints it, all in one go! const int knumints = 200; std::vector<int> vec(knumints); std::generate(vec.begin(), vec.end(), rand); std::sort(vec.begin(), vec.end()); std::copy(vec.begin(), vec.end(), std::ostream_iterator<int>(cout, "\n"));
23 Sequence Containers
24 Provides access to sequences of elements. Examples: std::vector<t> std::list<t> std::deque<t> Sequence Containers
25 std::vector<t>
26 std::vector<t> A vector represents a sequence of elements of any type. You specify the type when using the vector: std::vector<int> vecint; // vector of ints std::vector<string> vecstr; // vector of string std::vector<mystruct> vecstruct; // vector of mystructs std::vector<std::vector<string>> vecofvec; // vector of vector<string>
27 Summary of std::vector<t> vs Stanford Vector<T> What you want to do Stanford Vector<int> std::vector<int> Create an empty vector Vector<int> v; vector<int> v; Create a vector with n copies of zero Vector<int> v(n); vector<int> v(n); Create a vector with n copies of a value k Vector<int> v(n, k); vector<int> v(n, k); Add k to the end of the vector v.add(k); v.push_back(k); Clear vector v.clear(); v.clear(); Get the element at index i (verify that i is in bounds) int k = v.get(i); int k = v[i]; int k = v.at(i); Check if the vector is empty if (v.isempty())... if (v.empty())... Replace the element at index i (verify that i is in bounds) v.get(i) = k; v[i] = k; v.at(i) = k;
28 Summary of std::vector<t> vs Stanford Vector<T> What you want to do Stanford Vector<int> std::vector<int> Create an empty vector Vector<int> v; vector<int> v; Create a vector with n copies of zero Vector<int> v(n); vector<int> v(n); Create a vector with n copies of a value k Vector<int> v(n, k); vector<int> v(n, k); Add k to the end of the vector v.add(k); v.push_back(k); Clear vector v.clear(); v.clear(); Get the element at index i (verify that i is in bounds) int k = v.get(i); int k = v[i]; int k = v.at(i); Check if the vector is empty if (v.isempty())... if (v.empty())... Replace the element at index i (verify that i is in bounds) v.get(i) = k; v[i] = k; v.at(i) = k;
29 Summary of std::vector<t> vs Stanford Vector<T> What you want to do Stanford Vector<int> std::vector<int> Create an empty vector Vector<int> v; vector<int> v; Create a vector with n copies of zero Vector<int> v(n); vector<int> v(n); Create a vector with n copies of a value k Vector<int> v(n, k); vector<int> v(n, k); Add k to the end of the vector v.add(k); v.push_back(k); Clear vector v.clear(); v.clear(); Get the element at index i (verify that i is in bounds) int k = v.get(i); int k = v[i]; int k = v.at(i); Check if the vector is empty if (v.isempty())... if (v.empty())... Replace the element at index i (verify that i is in bounds) v.get(i) = k; v[i] = k; v.at(i) = k;
30 Summary of std::vector<t> vs Stanford Vector<T> What you want to do Stanford Vector<int> std::vector<int> Create an empty vector Vector<int> v; vector<int> v; Create a vector with n copies of zero Vector<int> v(n); vector<int> v(n); Create a vector with n copies of a value k Vector<int> v(n, k); vector<int> v(n, k); Add k to the end of the vector v.add(k); v.push_back(k); Clear vector v.clear(); v.clear(); Get the element at index i (verify that i is in bounds) int k = v.get(i); int k = v[i]; int k = v.at(i); Check if the vector is empty if (v.isempty())... if (v.empty())... Replace the element at index i (verify that i is in bounds) v.get(i) = k; v[i] = k; v.at(i) = k;
31 Some Differences - std::vector<t> vs Stanford Vector<T> Get the element at index i without bounds checking // Impossible! int a = x[i]; Change the element at index i without bounds checking // Impossible! x[i] = v; Add an element to the beginning of a vector // Impossible! (or at least slow) // Impossible! (or at least slow) Apply a function to each element in x x.mapall(fn) // We'll talk about this in another lecture... Concatenate vectors v and v2 v += v2; // We'll talk about this in another lecture...
32 std::vector<t> Problem: Write a program that reads a list of integers and finds the median. Vector Median (VecMedian.pro)
33 Some new stuff there: std::vector<t> const int knumints = ; using vecsz_t = std::vector<int>::size_type; std::sort(vec.begin(), vec.end());
34 std::vector<t> Some new stuff there: const int knumints = ; This is a promise to the compiler that this variable won t change. using vecsz_t = std::vector<int>::size_type; std::sort(vec.begin(), vec.end());
35 std::vector<t> Some new stuff there: const int knumints = ; using vecsz_t = std::vector<int>::size_type; std::sort(vec.begin(), vec.end()); This let s us use vecsz_t as an alias/synonym for the type std::vector<int>::size_type;
36 std::vector<t> Some new stuff there: const int knumints = ; using vecsz_t = std::vector<int>::size_type; std::sort(vec.begin(), vec.end()); This takes a range of the vector and sorts it
37 Some Differences - std::vector<t> vs Stanford Vector<T> Get the element at index i without bounds checking // Impossible! int a = x[i]; Change the element at index i without bounds checking // Impossible! x[i] = v; Add an element to the beginning of a vector // Impossible! (or at least slow) // Impossible! (or at least slow) Apply a function to each element in x x.mapall(fn) // We'll talk about this in another lecture... Concatenate vectors v and v2 v += v2; // We'll talk about this in another lecture...
38 Some Differences - std::vector<t> vs Stanford Vector<T> Get the element at index i without bounds checking // Impossible! int a = x[i]; Change the element at index i without bounds checking // Impossible! x[i] = v; Add an element to the beginning of a vector // Impossible! (or at least slow) // Impossible! (or at least slow) Apply a function to each element in x x.mapall(fn) // We'll talk about this in another lecture... Concatenate vectors v and v2 v += v2; // We'll talk about this in another lecture... Why these differences?
39 Some Differences - std::vector<t> vs Stanford Vector<T> Get the element at index i without bounds checking // Impossible! int a = x[i]; Change the element at index i without bounds checking // Impossible! x[i] = v; Add an element to the beginning of a vector // Impossible! (or at least slow) // Impossible! (or at least slow) Apply a function to each element in x x.mapall(fn) // We'll talk about this in another lecture... Concatenate vectors v and v2 v += v2; // We'll talk about this in another lecture... Why these differences?
40 Some Differences - std::vector<t> vs Stanford Vector<T> Get the element at index i without bounds checking // Impossible! int a = x[i]; Change the element at index i without bounds checking // Impossible! x[i] = v; Add an element to the beginning of a vector // Impossible! (or at least slow) // Impossible! (or at least slow) Apply a function to each element in x x.mapall(fn) // We'll talk about this in another lecture... Concatenate vectors v and v2 v += v2; // We'll talk about this in another lecture... Why these differences?
41 Why the Differences? Why doesn t std::vector bounds check by default? Hint: Remember our discussion of the philosophy of C++ If you write your program correctly, bounds checking will just slow your code down.
42 Some Differences - std::vector<t> vs Stanford Vector<T> Get the element at index i without bounds checking // Impossible! int a = x[i]; Change the element at index i without bounds checking // Impossible! x[i] = v; Add an element to the beginning of a vector // Impossible! (or at least slow) // Impossible! (or at least slow) Apply a function to each element in x x.mapall(fn) // We'll talk about this in another lecture... Concatenate vectors v and v2 v += v2; // We'll talk about this in another lecture... Why these differences?
43 Some Differences - std::vector<t> vs Stanford Vector<T> Get the element at index i without bounds checking // Impossible! int a = x[i]; Change the element at index i without bounds checking // Impossible! x[i] = v; Add an element to the beginning of a vector // Impossible! (or at least slow) // Impossible! (or at least slow) Apply a function to each element in x x.mapall(fn) // We'll talk about this in another lecture... Concatenate vectors v and v2 v += v2; // We'll talk about this in another lecture... Why these differences?
44 Why is push_front slow? Requires shifting over of the other elements in the vector down one by one (bad). Illustration: Say we have a small vector 3 0th index 4
45 Why is push_front slow? Suppose push_front existed and we used it. 3 0th index 4
46 Why is push_front slow? Suppose push_front existed and we used it. vec.push_front(7); 7 3 0th index 4
47 Why is push_front slow? Suppose push_front existed and we used it. vec.push_front(7); 7 Need to shift these elements up to make space in the 0th position. 3 0th index 4
48 Why is push_front slow? Suppose push_front existed and we used it vec.push_front(7); 7 Need to shift these elements up to make space in the 0th position. 3 0th index 4
49 Why is push_front slow? Suppose push_front existed and we used it vec.push_front(7); 7 Need to shift these elements up to make space in the 0th position. 3 0th index 4
50 Why is push_front slow? Suppose push_front existed and we used it vec.push_front(7); 7 Need to shift these elements up to make space in the 0th position. 3 0th index 4
51 Why is push_front slow? Suppose push_front existed and we used it vec.push_front(7); 7 Need to shift these elements up to make space in the 0th position. 3 0th index 4
52 Why is push_front slow? Suppose push_front existed and we used it vec.push_front(7); 7 Need to shift these elements up to make space in the 0th position. 3 0th index 4
53 Why is push_front slow? Suppose push_front existed and we used it vec.push_front(7); 7 Need to shift these elements up to make space in the 0th position. 3 0th index 4
54 Why is push_front slow? Suppose push_front existed and we used it vec.push_front(7); 7 Need to shift these elements up to make space in the 0th position. 3 0th index 4
55 Why is push_front slow? Suppose push_front existed and we used it vec.push_front(7); 7 Need to shift these elements up to make space in the 0th position. 3 0th index 4
56 Why is push_front slow? Suppose push_front existed and we used it vec.push_front(7); 7 Need to shift these elements up to make space in the 0th position. 3 0th index 4
57 Why is push_front slow? Suppose push_front existed and we used it vec.push_front(7); 7 Need to shift these elements up to make space in the 0th position. 3 0th index 4
58 Why is push_front slow? Suppose push_front existed and we used it vec.push_front(7); 7 3 0th index 4
59 Why is push_front slow? Suppose push_front existed and we used it vec.push_front(7); 7 Now we can insert the new element. 3 0th index 4
60 Why is push_front slow? Suppose push_front existed and we used it vec.push_front(7); 7 0th index 3 4
61 Why is push_front slow? th index 3 4
62 Why is push_front slow? Let s get a sense of the difference: Insertion Speed (InsertionSpeed.pro)
63 The results: Why is push_front slow?
64 Why is push_front slow? A vector is the prime tool of choice in most applications! Fast Lightweight Intuitive However, we just saw vectors only grow efficiently in one direction. Sometimes it is useful to be able to push_front quickly! C++ has a solution!
65 std::deque<t>
66 std::deque<t> A deque (pronounced deck ) is a double ended queue. Can do everything a vector can do and also Unlike a vector, it is possible (and fast) to push_front and pop_front.
67 std::deque<t> We can see the efficiency of push_front with a std::deque Deque Speed (DequeSpeed.pro)
68 The results: std::deque<t>
69 std::deque<t> The results: Same scale as previous graph
70 std::deque<t> The results: There are the lines!
71 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: NULL
72 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: NULL
73 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: deq.push_front(7); NULL
74 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: deq.push_front(7); NULL
75 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: deq.push_front(7); NULL
76 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: NULL
77 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: deq.push_back(3); NULL
78 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: deq.push_back(3); NULL
79 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: deq.push_back(3); NULL
80 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: NULL
81 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: deq.push_back(); NULL
82 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: deq.push_back();
83 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: deq.push_back();
84 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: deq.push_back();
85 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: deq.push_back();
86 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this:
87 Wait a minute...
88 Question If deque can do everything a vector can do and also has a fast push_front... Why use a vector at all?
89 Downsides of std::deque<t> Deques support fast push_front operations. However, for other common operations like element access, vector will always outperform a deque. Vector vs Deque (VecDeqSpeed.pro)
90 The results: Downsides of std::deque<t>
91 Which to Use? vector is the type of sequence that should be used by default... deque is the data structure of choice when most insertions and deletions take place at the beginning or at the end of the sequence. - C++ ISO Standard (section ):
92 Questions
93 Container Adapters
94 Recall stacks and queues: Container Adapters stack
95 Container Adapters Recall stacks and queues: push stack
96 Recall stacks and queues: Container Adapters stack
97 Container Adapters Recall stacks and queues: pop stack
98 Recall stacks and queues: Container Adapters stack
99 Container Adapters Recall stacks and queues: back 2 stack queue
100 Container Adapters Recall stacks and queues: back 2 stack push_back queue
101 Container Adapters Recall stacks and queues: back 2 stack queue
102 Container Adapters Recall stacks and queues: pop_front back 2 stack queue
103 Container Adapters Recall stacks and queues: back 2 stack queue
104 Container Adapters How can we implement stack and queue using the containers we have? Stack: Just limit the functionality of a vector/deque to only allow push_back and pop_back. Queue: Just limit the functionality of a deque to only allow push_back and pop_front. Plus only allow access to top element
105 Container Adapters For this reason, stacks and queues are known as container adapters.
106 Container Adapters For this reason, stacks and queues are known as container adapters.
107 Container Adapters For this reason, stacks and queues are known as container adapters.
108 Next Time Associative Containers and Iterators
109
Sequential Containers. Ali Malik
Sequential Containers Ali Malik malikali@stanford.edu Game Plan Recap Stream wrapup Overview of STL Sequence Containers std::vector std::deque Container Adapters Announcements Recap stringstream Sometimes
Sequence Containers. Cristian Cibils
Sequence Containers Cristian Cibils (ccibils@stanford.edu) The Design of C++ Classes & Inheritance Algorithms Iterators Templates Containers Streams Atomic Types Structs A struct is an easy way to bundle
Associative Containers and Iterators. Ali Malik
Associative Containers and Iterators Ali Malik malikali@stanford.edu Game Plan Recap Associative Containers Iterators Map Iterators The auto keyword (maybe) Range-Based for Loops (maybe) Recap Structs
Ali Malik Handout 12 CS106L Winter 2018 Jan 30th, C++ Reference
Ali Malik Handout 12 CS106L Winter 2018 Jan 30th, 2018 C++ Reference The purpose of this handout is to provide a summary and reference of the concepts covered in lecture as well as common constructs used
STL: C++ Standard Library
STL: C++ Standard Library Encapsulates complex data structures and algorithms CSC 330 OO Software Design 1 We ve emphasized the importance of software reuse. Recognizing that many data structures and algorithms
Template based set of collection classes STL collection types (container types)
STL Collection Types Template based set of collection classes STL collection types (container types) Sequences vector - collection of elements of type T list - doubly linked list, only sequential access
Polymorphism. Programming in C++ A problem of reuse. Swapping arguments. Session 4 - Genericity, Containers. Code that works for many types.
Session 4 - Genericity, Containers Polymorphism Code that works for many types. Dr Christos Kloukinas City, UoL http://staff.city.ac.uk/c.kloukinas/cpp (slides originally produced by Dr Ross Paterson)
STL components. STL: C++ Standard Library Standard Template Library (STL) Main Ideas. Components. Encapsulates complex data structures and algorithms
STL: C++ Standard Library Standard Template Library (STL) Encapsulates complex data structures and algorithms is a library of generic container classes which are both efficient and functional C++ STL developed
SSE2034: System Software Experiment 3
SSE2034: System Software Experiment 3 Spring 2016 Jinkyu Jeong (jinkyu@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu STL Collection Types Template based set of collection
Purpose of Review. Review some basic C++ Familiarize us with Weiss s style Introduce specific constructs useful for implementing data structures
C++ Review 1 Purpose of Review Review some basic C++ Familiarize us with Weiss s style Introduce specific constructs useful for implementing data structures 2 Class The Class defines the data structure
Chapter 5. The Standard Template Library.
Object-oriented programming B, Lecture 11e. 1 Chapter 5. The Standard Template Library. 5.1. Overview of main STL components. The Standard Template Library (STL) has been developed by Alexander Stepanov,
Chapter 17: Linked Lists
Chapter 17: Linked Lists 17.1 Introduction to the Linked List ADT Introduction to the Linked List ADT Linked list: set of data structures (nodes) that contain references to other data structures list head
Standard Template Library
Standard Template Library Wednesday, October 10, 2007 10:09 AM 9.3 "Quick Peek" STL history 1990s Alex Stepanov & Meng Lee of HP Labs 1994 ANSI/IS0 standard Components Container class templates Iterators
COMP6771 Advanced C++ Programming
1. COMP6771 Advanced C++ Programming Week 7 Part One: Member Templates and 2016 www.cse.unsw.edu.au/ cs6771 2. Member Templates Consider this STL code: 1 #include 2 #include 3 #include
Outline. Variables Automatic type inference. Generic programming. Generic programming. Templates Template compilation
Outline EDAF30 Programming in C++ 4. The standard library. Algorithms and containers. Sven Gestegård Robertz Computer Science, LTH 2018 1 Type inference 2 3 The standard library Algorithms Containers Sequences
THE STANDARD TEMPLATE LIBRARY (STL) Week 6 BITE 1513 Computer Game Programming
THE STANDARD TEMPLATE LIBRARY (STL) Week 6 BITE 1513 Computer Game Programming What the heck is STL???? Another hard to understand and lazy to implement stuff? Standard Template Library The standard template
TDDD38 - Advanced programming in C++
TDDD38 - Advanced programming in C++ STL II Christoffer Holm Department of Computer and information science 1 Iterators 2 Associative Containers 3 Container Adaptors 4 Lambda Functions 1 Iterators 2 Associative
Chapter 18: Stacks And Queues
Chapter 18: Stacks And Queues 18.1 Introduction to the Stack ADT Introduction to the Stack ADT Stack a LIFO (last in, first out) data structure Examples plates in a cafeteria return addresses for function
use static size for this buffer
Software Design (C++) 4. Templates and standard library (STL) Juha Vihavainen University of Helsinki Overview Introduction to templates (generics) std::vector again templates: specialization by code generation
Lecture 12. Monday, February 7 CS 215 Fundamentals of Programming II - Lecture 12 1
Lecture 12 Log into Linux. Copy files on csserver in /home/hwang/cs215/lecture12/*.* Reminder: Practical Exam 1 is Wednesday 3pm-5pm in KC-267. Questions about Project 2 or Homework 6? Submission system
Chapter 17: Linked Lists
Chapter 17: Linked Lists Copyright 2009 Pearson Education, Inc. Copyright Publishing as Pearson 2009 Pearson Addison-Wesley Education, Inc. Publishing as Pearson Addison-Wesley 17.1 Introduction to the
CS24 Week 3 Lecture 1
CS24 Week 3 Lecture 1 Kyle Dewey Overview Some minor C++ points ADT Review Object-oriented Programming C++ Classes Constructors Destructors More minor Points (if time) Key Minor Points const Motivation
CSCI-1200 Data Structures Fall 2010 Lecture 8 Iterators
CSCI-1200 Data Structures Fall 2010 Lecture 8 Iterators Review from Lecture 7 Designing our own container classes Dynamically allocated memory in classes Copy constructors, assignment operators, and destructors
Computer Science II Lecture 2 Strings, Vectors and Recursion
1 Overview of Lecture 2 Computer Science II Lecture 2 Strings, Vectors and Recursion The following topics will be covered quickly strings vectors as smart arrays Basic recursion Mostly, these are assumed
Lectures 19, 20, 21. two valid iterators in [first, last) such that i precedes j, then *j is not less than *i.
Lectures 19, 20, 21 1. STL library examples of applications Explanations: The member function pop_back removes the last element of the controlled sequence. The member function pop_front removes the first
Templates and Vectors
Templates and Vectors 1 Generic Programming function templates class templates 2 the STL vector class a vector of strings enumerating elements with an iterator inserting and erasing 3 Writing our own vector
CSCI-1200 Data Structures Fall 2014 Lecture 8 Iterators
Review from Lecture 7 CSCI-1200 Data Structures Fall 2014 Lecture 8 Iterators Designing our own container classes Dynamically allocated memory in classes Copy constructors, assignment operators, and destructors
CS 103 Unit 11. Linked Lists. Mark Redekopp
1 CS 103 Unit 11 Linked Lists Mark Redekopp 2 NULL Pointer Just like there was a null character in ASCII = '\0' whose ue was 0 There is a NULL pointer whose ue is 0 NULL is "keyword" you can use in C/C++
Stacks and their Applications
Stacks and their Applications Lecture 23 Sections 18.1-18.2 Robb T. Koether Hampden-Sydney College Fri, Mar 16, 2018 Robb T. Koether Hampden-Sydney College) Stacks and their Applications Fri, Mar 16, 2018
CS 103 Unit 15. Doubly-Linked Lists and Deques. Mark Redekopp
1 CS 103 Unit 15 Doubly-Linked Lists and Deques Mark Redekopp 2 Singly-Linked List Review Used structures/classes and pointers to make linked data structures Singly-Linked Lists dynamically allocates each
CS 103 Unit 12 Slides
1 CS 103 Unit 12 Slides Standard Template Library Vectors & Deques Mark Redekopp 2 Templates We ve built a list to store integers But what if we want a list of double s or char s or other objects We would
EE 355 Unit 11b. Doubly-Linked Lists and Deques. Mark Redekopp
1 EE 355 Unit 11b Doubly-Linked Lists and Deques Mark Redekopp 2 Singly-Linked List Review Used structures/classes and pointers to make linked data structures Singly-Linked Lists dynamically allocates
Exercise 6.2 A generic container class
Exercise 6.2 A generic container class The goal of this exercise is to write a class Array that mimics the behavior of a C++ array, but provides more intelligent memory management a) Start with the input
STL Quick Reference for CS 241
STL Quick Reference for CS 241 Spring 2018 The purpose of this document is to provide basic information on those elements of the C++14 standard library we think are most likely to be needed in CS 241.
Containers in C++ and Java
Containers in C++ and Java 1 1. Which of the following statements is true? a) Equality on the basis of reference implies equality on the basis of content. b) Equality on the basis of content implies equality
CS24 Week 4 Lecture 2
CS24 Week 4 Lecture 2 Kyle Dewey Overview Linked Lists Stacks Queues Linked Lists Linked Lists Idea: have each chunk (called a node) keep track of both a list element and another chunk Need to keep track
Arrays - Vectors. Arrays: ordered sequence of values of the same type. Structures: named components of various types
Arrays - Vectors Data Types Data Type: I. set of values II. set of operations over those values Example: Integer I. whole numbers, -32768 to 32767 II. +, -, *, /, %, ==,!=, , =,... Which operation
Memory and Pointers written by Cathy Saxton
Memory and Pointers written by Cathy Saxton Basic Memory Layout When a program is running, there are three main chunks of memory that it is using: A program code area where the program itself is loaded.
Introduction to Linked List: Review. Source:
Introduction to Linked List: Review Source: http://www.geeksforgeeks.org/data-structures/linked-list/ Linked List Fundamental data structures in C Like arrays, linked list is a linear data structure Unlike
Patterns: Working with Arrays
Steven Zeil October 14, 2013 Outline 1 Static & Dynamic Allocation Static Allocation Dynamic Allocation 2 Partially Filled Arrays Adding Elements Searching for Elements Removing Elements 3 Arrays and Templates
In this chapter, you will learn about: An Array Type for Strings. The Standard string Class. Vectors. Introduction Computer Science 1 CS 23021
Chapter 8 In this chapter, you will learn about: An Array Type for Strings The Standard string Class Vectors The C Language Representation of Strings (C-Strings) The C-String Variable: Array of Characters
GridKa School 2013: Effective Analysis C++ Standard Template Library
GridKa School 2013: Effective Analysis C++ Standard Template Library Introduction Jörg Meyer, Steinbuch Centre for Computing, Scientific Data Management KIT University of the State of Baden-Wuerttemberg
Concurrent Data Structures in C++ CSInParallel Project
Concurrent Data Structures in C++ CSInParallel Project July 26, 2012 CONTENTS 1 Concurrent Data Structures in C++: Web crawler lab 1 1.1 Your goals................................................ 1 1.2
Arrays. Returning arrays Pointers Dynamic arrays Smart pointers Vectors
Arrays Returning arrays Pointers Dynamic arrays Smart pointers Vectors To declare an array specify the type, its name, and its size in []s int arr1[10]; //or int arr2[] = {1,2,3,4,5,6,7,8}; arr2 has 8
The Standard Template Library. EECS 211 Winter 2018
The Standard Template Library EECS 211 Winter 2018 2 Problem: finding the maximum element of a vector A simple fixed-size vector struct: struct Int_vec int* data; size_t size; ; 3 Solution: max_int_vec
Modern and Lucid C++ for Professional Programmers. Part 7 Standard Containers & Iterators. Department I - C Plus Plus
Department I - C Plus Plus Modern and Lucid C++ for Professional Programmers Part 7 Standard Containers & Iterators Prof. Peter Sommerlad / Thomas Corbat Rapperswil, 8.11.2017 HS2017 STL Containers: General
CSCI-1200 Data Structures Fall 2017 Lecture 9 Iterators & STL Lists
Review from Lecture 8 CSCI-1200 Data Structures Fall 2017 Lecture 9 Iterators & STL Lists Designing our own container classes Dynamically allocated memory in classes Copy constructors, assignment operators,
STL. Prof Tejada Week 14
STL Prof Tejada Week 14 Standard Template Library (STL) What is the STL? A generic collection of commonly used data structures and algorithms In 1994, STL was adopted as a standard part of C++ Why used
CS31 Discussion 1E. Jie(Jay) Wang Week3 Oct.12
CS31 Discussion 1E Jie(Jay) Wang Week3 Oct.12 Outline Problems from Project 1 Review of lecture String, char, stream If-else statements Switch statements loops Programming challenge Problems from Project
PIC 10A. Lecture 23: Intro to STL containers
PIC 10A Lecture 23: Intro to STL containers STL STL stands for Standard Template Library There are many data structures that share similar features These data structures can be manipulated by a common
Lesson 13 - Vectors Dynamic Data Storage
Lesson 13 - Vectors Dynamic Data Storage Summary In this lesson we introduce the Standard Template Library by demonstrating the use of Vectors to provide dynamic storage of data elements. New Concepts
Character Functions & Manipulators Arrays in C++ CS 16: Solving Problems with Computers I Lecture #10
Character Functions & Manipulators Arrays in C++ CS 16: Solving Problems with Computers I Lecture #10 Ziad Matni Dept. of Computer Science, UCSB Lecture Outline Useful character manipulators & functions
Chapter 18: Stacks And Queues
Chapter 18: Stacks And Queues 18.1 Introduction to the Stack ADT Introduction to the Stack ADT Stack: a LIFO (last in, first out) data structure Examples: plates in a cafeteria return addresses for function
CS 103 Unit 11. Linked Lists. Mark Redekopp
1 CS 103 Unit 11 Linked Lists Mark Redekopp 2 NULL Pointer Just like there was a null character in ASCII = '\0' whose ue was 0 There is a NULL pointer whose ue is 0 NULL is "keyword" you can use in C/C++
Priority Queues and Huffman Trees
Priority Queues and Huffman Trees 1 the Heap storing the heap with a vector deleting from the heap 2 Binary Search Trees sorting integer numbers deleting from a binary search tree 3 Huffman Trees encoding
ECE 2400 Computer Systems Programming Fall 2017 Topic 15: C++ Templates
ECE 2400 Computer Systems Programming Fall 2017 Topic 15: C++ Templates School of Electrical and Computer Engineering Cornell University revision: 2017-11-08-09-37 1 Function Templates 2 2 Class Templates
Chapter 18: Stacks And Queues. Pearson Education, Inc. Publishing as Pearson Addison-Wesley
Chapter 18: Stacks And Queues Copyright 2009 Pearson Education, Inc. Copyright Publishing as Pearson 2009 Addison-Wesley Pearson Education, Inc. Publishing as Pearson Addison-Wesley 18.1 Introduction to
Topics. bool and string types input/output library functions comments memory allocation templates classes
C++ Primer C++ is a major extension of c. It is similar to Java. The lectures in this course use pseudo-code (not C++). The textbook contains C++. The labs involve C++ programming. This lecture covers
Sixth lecture; classes, objects, reference operator.
Sixth lecture; classes, objects, reference operator. 1 Some notes on the administration of the class: From here on out, homework assignments should be a bit shorter, and labs a bit longer. My office hours
Outline. 1 Function calls and parameter passing. 2 Pointers, arrays, and references. 5 Declarations, scope, and lifetimes 6 I/O
Outline EDAF30 Programming in C++ 2. Introduction. More on function calls and types. Sven Gestegård Robertz Computer Science, LTH 2018 1 Function calls and parameter passing 2 Pointers, arrays, and references
auto map<deque<string>, vector<string>> mymap; for(auto iter = mymap.begin(); iter!= mymap.end(); ++iter) {
auto auto auto How can we clean this up better? The auto keyword! map mymap; for(auto iter = mymap.begin(); iter!= mymap.end(); ++iter) { } dosomething(*(iter).first, *(iter).second);
Copyright 2003 Pearson Education, Inc. Slide 1
Copyright 2003 Pearson Education, Inc. Slide 1 Chapter 11 Strings and Vectors Created by David Mann, North Idaho College Copyright 2003 Pearson Education, Inc. Slide 2 Overview An Array Type for Strings
Streams. Ali Malik
Streams Ali Malik malikali@stanford.edu Game Plan Recap Purpose of Streams Output Streams Input Streams Stringstream (maybe) Announcements Recap Recap - Hello, world! #include int main() { std::cout
Linear Structures. Linear Structure. Implementations. Array details. List details. Operations 4/18/2013
Linear Structure Linear Structures Chapter 4 CPTR 318 Every non-empty linear structure has A unique element called first A unique element called last Every element except last has a unique successor Every
In Java we have the keyword null, which is the value of an uninitialized reference type
+ More on Pointers + Null pointers In Java we have the keyword null, which is the value of an uninitialized reference type In C we sometimes use NULL, but its just a macro for the integer 0 Pointers are
Type Aliases. Examples: using newtype = existingtype; // C++11 typedef existingtype newtype; // equivalent, still works
Type Aliases A name may be defined as a synonym for an existing type name. Traditionally, typedef is used for this purpose. In the new standard, an alias declaration can also be used C++11.Thetwoformsareequivalent.
18. Dynamic Data Structures I. Dynamic Memory, Addresses and Pointers, Const-Pointer Arrays, Array-based Vectors
590 18. Dynamic Data Structures I Dynamic Memory, Addresses and Pointers, Const-Pointer Arrays, Array-based Vectors Recap: vector 591 Can be initialised with arbitrary size n 591 Recap: vector
Linear Structures. Linear Structure. Implementations. Array details. List details. Operations 2/10/2013
Linear Structure Linear Structures Chapter 4 CPTR 318 Every non-empty linear structure has A unique element called first A unique element called last Every element except last has a unique successor Every
Lecture 8. Xiaoguang Wang. February 13th, 2014 STAT 598W. (STAT 598W) Lecture 8 1 / 47
Lecture 8 Xiaoguang Wang STAT 598W February 13th, 2014 (STAT 598W) Lecture 8 1 / 47 Outline 1 Introduction: C++ 2 Containers 3 Classes (STAT 598W) Lecture 8 2 / 47 Outline 1 Introduction: C++ 2 Containers
Advanced Associative Containers. Ali Malik
Advanced Associative Containers Ali Malik malikali@stanford.edu Game Plan Recap Map Iterators Further Usage Multimap auto and Range Based for Recap Associative Containers Useful abstraction for associating
1. The term STL stands for?
1. The term STL stands for? a) Simple Template Library b) Static Template Library c) Single Type Based Library d) Standard Template Library Answer : d 2. Which of the following statements regarding the
CSCI-1200 Data Structures Fall 2013 Lecture 9 Iterators & Lists
Review from Lecture 8 CSCI-1200 Data Structures Fall 2013 Lecture 9 Iterators & Lists Explored a program to maintain a class enrollment list and an associated waiting list. Unfortunately, erasing items
Queues and Unit Testing
Queues and Unit Testing Shreya Shankar Stanford CS 106B 3 July 2018 Based on slides created by Ashley Taylor, Marty Stepp, Chris Gregg, Keith Schwarz, Julie Zelenski, Jerry Cain, Eric Roberts, Mehran Sahami,
Working with Batches of Data
Hartmut Kaiser hkaiser@cct.lsu.edu http://www.cct.lsu.edu/ hkaiser/fall_2012/csc1254.html 2 Abstract So far we looked at simple read a string print a string problems. Now we will look at more complex problems
Standard Library. Lecture 27. Containers. STL Containers. Standard Library
Standard Library Lecture 27 Containers (templates) Streams (I/O facilities) Standard Library Portable, type-safe, efficient Try to use as much as possible Heavy use of templates Streams: #include
STL Containers, Part I
CS106L Handout #06 Fall 2007 October 10, 2007 STL Containers, Part I Introduction Arguably the most powerful library in the C++ language, the Standard Template Library (STL) is a programmer's dream. It
19. Dynamic Data Structures II
Different Memory Layout: Linked List 19. Dynamic Data Structures II Linked Lists, Vectors as Linked Lists No contiguous area of memory and no random access Each element points to its successor Insertion
EE 355 Unit 10. C++ STL - Vectors and Deques. Mark Redekopp
1 EE 355 Unit 10 C++ STL - Vectors and Deques Mark Redekopp 2 Templates We ve built a list to store integers But what if we want a list of double s or char s or other objects We would have to define the
Advanced C++ STL. Tony Wong
Tony Wong 2017-03-25 C++ Standard Template Library Algorithms Sorting Searching... Data structures Dynamically-sized array Queues... The implementation is abstracted away from the users The implementation
Prefix Trees Tables in Practice
Prefix Trees CS 311 Data Structures and Algorithms Lecture Slides Friday, December 7, 2007 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks CHAPPELLG@member.ams.org 2005
Functions. Ali Malik
Functions Ali Malik malikali@stanford.edu Game Plan Recap Operator Overloading Functions Lambdas Announcements Recap Classes - Issues C++ doesn t know how to use operators on types defined by us An algorithm
C++ TEMPLATES. Templates are the foundation of generic programming, which involves writing code in a way that is independent of any particular type.
C++ TEMPLATES http://www.tutorialspoint.com/cplusplus/cpp_templates.htm Copyright tutorialspoint.com Templates are the foundation of generic programming, which involves writing code in a way that is independent
Queue Implementations
Queue Implementations 1 Circular Queues buffer of fixed capacity improvements and cost estimates 2 Deques the double ended queue queue as double linked circular list MCS 360 Lecture 17 Introduction to
Lecture Notes. char myarray [ ] = {0, 0, 0, 0, 0 } ; The memory diagram associated with the array can be drawn like this
![Lecture Notes. char myarray [ ] = {0, 0, 0, 0, 0 } ; The memory diagram associated with the array can be drawn like this](/thumbs/80/81612702.jpg "Lecture Notes. char myarray [ ] = {0, 0, 0, 0, 0 } ; The memory diagram associated with the array can be drawn like this")
Lecture Notes Array Review An array in C++ is a contiguous block of memory. Since a char is 1 byte, then an array of 5 chars is 5 bytes. For example, if you execute the following C++ code you will allocate
September 19,
September 19, 2013 1 Problems with previous examples Changes to the implementation will require recompilation & relinking of clients Extensions will require access to the source code Solutions Combine
C++ 11 and the Standard Library: Containers, Iterators, Algorithms
and the Standard Library:,, Comp Sci 1575 Outline 1 2 3 4 Outline 1 2 3 4 #i n clude i n t main ( ) { i n t v a l u e 0 = 5 ; // C++ 98 i n t v a l u e 1 ( 5 ) ; // C++ 98 i n t v a
CSCI-1200 Data Structures Spring 2016 Lecture 7 Iterators, STL Lists & Order Notation
Today CSCI-1200 Data Structures Spring 2016 Lecture 7 Iterators, STL Lists & Order Notation Another vector operation: pop back Erasing items from vectors is inefficient! Iterators and iterator operations
Programming with Haiku
Programming with Haiku Lesson 2 Written by DarkWyrm All material 2010 DarkWyrm In our first lesson, we learned about how to generalize type handling using templates and some of the incredibly flexible
COEN244: Class & function templates
COEN244: Class & function templates Aishy Amer Electrical & Computer Engineering Templates Function Templates Class Templates Outline Templates and inheritance Introduction to C++ Standard Template Library
You must include this cover sheet. Either type up the assignment using theory3.tex, or print out this PDF.
15-122 Assignment 3 Page 1 of 12 15-122 : Principles of Imperative Computation Fall 2012 Assignment 3 (Theory Part) Due: Thursday, October 4 at the beginning of lecture. Name: Andrew ID: Recitation: The
Functions. Ali Malik
Functions Ali Malik malikali@stanford.edu Game Plan Recap Operator Overloading Functions Lambdas Announcements Recap Classes - Issues C++ doesn t know how to use operators on types defined by us: We can
Linked Lists. Linked list: a collection of items (nodes) containing two components: Data Address (link) of the next node in the list
Linked Lists Introduction : Data can be organized and processed sequentially using an array, called a sequential list Problems with an array Array size is fixed Unsorted array: searching for an item is
CS 32. Lecture 5: Templates
CS 32 Lecture 5: Templates Vectors Sort of like what you remember from Physics but sort of not Can have many components Usually called entries Like Python lists Array vs. Vector What s the difference?
CSE 333 Midterm Exam 5/10/13
Name There are 5 questions worth a total of 100 points. Please budget your time so you get to all of the questions. Keep your answers brief and to the point. The exam is closed book, closed notes, closed
Dynamic Data Structures
Dynamic Data Structures We have seen that the STL containers vector, deque, list, set and map can grow and shrink dynamically. We now examine how some of these containers can be implemented in C++. To
COMP6771 Advanced C++ Programming
1. COMP6771 Advanced C++ Programming Week 6 Part Three: 2016 www.cse.unsw.edu.au/ cs6771 2. Why? In C++, class names cannot be overloaded. Thus: 1 class IntStack { 2 public: 3 void push(int&); 4 void pop();
l Determine if a number is odd or even l Determine if a number/character is in a range - 1 to 10 (inclusive) - between a and z (inclusive)
Final Exam Exercises Chapters 1-7 + 11 Write C++ code to: l Determine if a number is odd or even CS 2308 Fall 2016 Jill Seaman l Determine if a number/character is in a range - 1 to 10 (inclusive) - between
COMP322 - Introduction to C++
COMP322 - Introduction to C++ Lecture 05 - I/O using the standard library, stl containers, stl algorithms Dan Pomerantz School of Computer Science 5 February 2013 Basic I/O in C++ Recall that in C, we
CMSC 341 Lecture 6 Templates, Stacks & Queues. Based on slides by Shawn Lupoli & Katherine Gibson at UMBC
CMSC 341 Lecture 6 Templates, Stacks & Queues Based on slides by Shawn Lupoli & Katherine Gibson at UMBC Today s Topics Data types in C++ Overloading functions Templates How to implement them Possible
COP Programming Assignment #7
1 of 5 03/13/07 12:36 COP 3330 - Programming Assignment #7 Due: Mon, Nov 21 (revised) Objective: Upon completion of this program, you should gain experience with operator overloading, as well as further