Sequential Containers. Ali Malik
|
|
|
- Anne Byrd
- 5 years ago
- Views:
Transcription
1 Sequential Containers Ali Malik
2 Game Plan Recap Stream wrapup Overview of STL Sequence Containers std::vector std::deque Container Adapters
3 Announcements
4 Recap
5 stringstream
6 Sometimes we want to be able to treat a string like a stream. Useful scenarios: stringstream Converting between data types Tokenizing a string
7 stringstream #include <sstream> std::string line = " Hello"; std::stringstream stream(line); int myint; double mydouble; std::string mystring; stream >> myint >> mydouble >> mystring; std::cout << myint << std::endl; std::cout << mydouble << std::endl; std::cout << mystring << std::endl;
8 stringstream Let s write some of the Stanford simpio library! Simple IO (OurSimpIO.pro)
9
10 Useful Aside
11
12 Structs You can define your own mini-types that bundle multiple variables together: struct point { int x; int y; }; Useful for Assignment 1
13 Structs struct point { int x; int y; }; point p; p.x = 12; p.y = 15;
14 Overview of STL
15 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
16 Overview of STL Algorithms Functors/Lambdas Iterators Adapters Allocators Containers
17 Overview of STL Algorithms Functors/Lambdas Iterators Adapters Allocators Containers
18 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"));
19 Sequence Containers
20 Provides access to sequences of elements. Examples: std::vector<t> std::list<t> std::deque<t> Sequence Containers
21 std::vector<t>
22 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>
23 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;
24 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;
25 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;
26 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;
27 Some Differences - std::vector<t> vs Stanford Vector<T> Get the element at index i without bounds checking Change the element at index i without bounds checking // Impossible! int a = x[i]; // Impossible! x[i] = v; Add an element to the beginning of a vector Apply a function to each element in x // Impossible! (or at least slow) x.mapall(fn) // Impossible! (or at least slow) // We'll talk about this in another lecture... Concatenate vectors v1 and v2 v1 += v2; // We'll talk about this in another lecture...
28 std::vector<t> Problem: Write a program that reads a list of integers and finds the median. Vector Median (VecMedian.pro)
29 Some new stuff there: std::vector<t> const int knumints = 5; using vecsz_t = std::vector<int>::size_type; std::sort(vec.begin(), vec.end());
30 std::vector<t> Some new stuff there: const int knumints = 5; 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());
31 Some new stuff there: std::vector<t> const int knumints = 5; 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;
32 Some new stuff there: std::vector<t> const int knumints = 5; using vecsz_t = std::vector<int>::size_type; std::sort(vec.begin(), vec.end()); This takes a range of the vector and sorts it
33 Some Differences - std::vector<t> vs Stanford Vector<T> Get the element at index i without bounds checking Change the element at index i without bounds checking // Impossible! int a = x[i]; // Impossible! x[i] = v; Add an element to the beginning of a vector Apply a function to each element in x // Impossible! (or at least slow) x.mapall(fn) // Impossible! (or at least slow) // We'll talk about this in another lecture... Concatenate vectors v1 and v2 v1 += v2; // We'll talk about this in another lecture...
34 Some Differences - std::vector<t> vs Stanford Vector<T> Get the element at index i without bounds checking Change the element at index i without bounds checking // Impossible! int a = x[i]; // Impossible! x[i] = v; Add an element to the beginning of a vector Apply a function to each element in x // Impossible! (or at least slow) x.mapall(fn) // Impossible! (or at least slow) // We'll talk about this in another lecture... Concatenate vectors v1 and v2 v1 += v2; // We'll talk about this in another lecture... Why these differences?
35 Some Differences - std::vector<t> vs Stanford Vector<T> Get the element at index i without bounds checking Change the element at index i without bounds checking // Impossible! int a = x[i]; // Impossible! x[i] = v; Add an element to the beginning of a vector Apply a function to each element in x // Impossible! (or at least slow) x.mapall(fn) // Impossible! (or at least slow) // We'll talk about this in another lecture... Concatenate vectors v1 and v2 v1 += v2; // We'll talk about this in another lecture... Why these differences?
36 Some Differences - std::vector<t> vs Stanford Vector<T> Get the element at index i without bounds checking Change the element at index i without bounds checking // Impossible! int a = x[i]; // Impossible! x[i] = v; Add an element to the beginning of a vector Apply a function to each element in x // Impossible! (or at least slow) x.mapall(fn) // Impossible! (or at least slow) // We'll talk about this in another lecture... Concatenate vectors v1 and v2 v1 += v2; // We'll talk about this in another lecture... Why these differences?
37 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.
38 Some Differences - std::vector<t> vs Stanford Vector<T> Get the element at index i without bounds checking Change the element at index i without bounds checking // Impossible! int a = x[i]; // Impossible! x[i] = v; Add an element to the beginning of a vector Apply a function to each element in x // Impossible! (or at least slow) x.mapall(fn) // Impossible! (or at least slow) // We'll talk about this in another lecture... Concatenate vectors v1 and v2 v1 += 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 Change the element at index i without bounds checking // Impossible! int a = x[i]; // Impossible! x[i] = v; Add an element to the beginning of a vector Apply a function to each element in x // Impossible! (or at least slow) x.mapall(fn) // Impossible! (or at least slow) // We'll talk about this in another lecture... Concatenate vectors v1 and v2 v1 += v2; // We'll talk about this in another lecture... Why these differences?
40 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 th index
41 Why is push_front slow? Suppose push_front existed and we used it th index
42 Why is push_front slow? Suppose push_front existed and we used it. 7 vec.push_front(7); th index
43 Why is push_front slow? Suppose push_front existed and we used it. 7 vec.push_front(7); Need to shift these elements up to make space in the 0th position th index
44 Why is push_front slow? Suppose push_front existed and we used it 7 vec.push_front(7); Need to shift these elements up to make space in the 0th position th index
45 Why is push_front slow? Suppose push_front existed and we used it 7 vec.push_front(7); Need to shift these elements up to make space in the 0th position th index
46 Why is push_front slow? Suppose push_front existed and we used it 7 vec.push_front(7); Need to shift these elements up to make space in the 0th position th index
47 Why is push_front slow? Suppose push_front existed and we used it 7 vec.push_front(7); Need to shift these elements up to make space in the 0th position th index
48 Why is push_front slow? Suppose push_front existed and we used it 7 vec.push_front(7); Need to shift these elements up to make space in the 0th position th index
49 Why is push_front slow? Suppose push_front existed and we used it 7 vec.push_front(7); Need to shift these elements up to make space in the 0th position th index
50 Why is push_front slow? Suppose push_front existed and we used it 7 vec.push_front(7); Need to shift these elements up to make space in the 0th position th index
51 Why is push_front slow? Suppose push_front existed and we used it 7 vec.push_front(7); Need to shift these elements up to make space in the 0th position th index
52 Why is push_front slow? Suppose push_front existed and we used it 7 vec.push_front(7); Need to shift these elements up to make space in the 0th position th index
53 Why is push_front slow? Suppose push_front existed and we used it 7 vec.push_front(7); Need to shift these elements up to make space in the 0th position th index
54 Why is push_front slow? Suppose push_front existed and we used it 7 vec.push_front(7); th index
55 Why is push_front slow? Suppose push_front existed and we used it 7 vec.push_front(7); Now we can insert the new element th index
56 Why is push_front slow? Suppose push_front existed and we used it vec.push_front(7); th index
57 Why is push_front slow? th index
58 Why is push_front slow? Let s get a sense of the difference: Insertion Speed (InsertionSpeed.pro)
59 The results: Why is push_front slow?
60 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!
61 std::deque<t>
62 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.
63 std::deque<t> We can see the efficiency of push_front with a std::deque Deque Speed (DequeSpeed.pro)
64 The results: std::deque<t>
65 std::deque<t> The results: Same scale as previous graph
66 std::deque<t> The results: There are the lines!
67 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: NULL
68 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this: NULL
69 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
70 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
71 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
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_back(3); 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_back(3); 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_back(3); 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(5); 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(5);
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(5);
80 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(5);
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(5);
82 How does std::deque<t> work? There is no single specific implementation of a deque, but one common one might look like this:
83 Wait a minute...
84 Question If deque can do everything a vector can do and also has a fast push_front... Why use a vector at all?
85 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)
86 The results: Downsides of std::deque<t>
87 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 ):
88 Questions
89 Container Adapters
90 Recall stacks and queues: Container Adapters stack
91 Recall stacks and queues: Container Adapters push stack
92 Recall stacks and queues: Container Adapters stack
93 Recall stacks and queues: pop Container Adapters stack
94 Recall stacks and queues: Container Adapters stack
95 Recall stacks and queues: Container Adapters back stack queue
96 Recall stacks and queues: Container Adapters stack push_back queue back
97 Recall stacks and queues: Container Adapters stack queue back
98 Container Adapters Recall stacks and queues: pop_front stack queue back
99 Recall stacks and queues: Container Adapters stack queue back
100 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
101 Container Adapters For this reason, stacks and queues are known as container adapters.
102 Container Adapters For this reason, stacks and queues are known as container adapters.
103 Container Adapters For this reason, stacks and queues are known as container adapters.
104 Next Time Associative Containers and Iterators
105
Sequential Containers. Ali Malik
Sequential Containers Ali Malik malikali@stanford.edu Game Plan Recap Overview of STL Sequence Containers std::vector std::deque Container Adapters Announcements Recap getline vs >> Bug favnum = fullname
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
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
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
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
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
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
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
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
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
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
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
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
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)
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
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.
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
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
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
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
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.
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
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
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
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
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();
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
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
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
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
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
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
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
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
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
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
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
CSCI-1200 Data Structures Fall 2017 Lecture 2 STL Strings & Vectors
Announcements CSCI-1200 Data Structures Fall 2017 Lecture 2 STL Strings & Vectors HW 1 is available on-line through the website (on the Calendar ). Be sure to read through this information as you start
CSCI-1200 Data Structures Spring 2015 Lecture 2 STL Strings & Vectors
Announcements CSCI-1200 Data Structures Spring 2015 Lecture 2 STL Strings & Vectors HW 1 is available on-line through the website (on the Calendar ). Be sure to read through this information as you start
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
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
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
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
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
What will happen if we try to compile, link and run this program? Do you have any comments to the code?
1 # include < iostream > 2 3 int main () 4 { 5 std :: cout
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++
Function Templates. Consider the following function:
Function Templates Consider the following function: void swap (int& a, int& b) { int tmp = a; a = b; b = tmp; Swapping integers. This function let's you swap the contents of two integer variables. But
Computational Physics
Computational Physics numerical methods with C++ (and UNIX) 2018-19 Fernando Barao Instituto Superior Tecnico, Dep. Fisica email: fernando.barao@tecnico.ulisboa.pt Computational Physics 2018-19 (Phys Dep
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
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
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
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
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
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
CSE100. Advanced Data Structures. Lecture 4. (Based on Paul Kube course materials)
CSE100 Advanced Data Structures Lecture 4 (Based on Paul Kube course materials) Lecture 4 Binary search trees Toward a binary search tree implementation using C++ templates Reading: Weiss Ch 4, sections
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
TEMPLATES AND ITERATORS
TEMPLATES AND ITERATORS Problem Solving with Computers-I https://ucsb-cs24-sp17.github.io/ 2 Announcements Checkpoint deadline for pa04 (aka lab05) is due today at 11:59pm Be sure to push your code to
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
CSCI-1200 Data Structures Spring 2018 Lecture 14 Associative Containers (Maps), Part 1 (and Problem Solving Too)
CSCI-1200 Data Structures Spring 2018 Lecture 14 Associative Containers (Maps), Part 1 (and Problem Solving Too) HW6 NOTE: Do not use the STL map or STL pair for HW6. (It s okay to use them for the contest.)
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
Biostatistics 615/815 Lecture 6: Linear Sorting Algorithms and Elementary Data Structures
Biostatistics 615/815 Lecture 6: Linear Sorting Algorithms and Elementary Data Structures Hyun Min Kang Januray 25th, 2011 Hyun Min Kang Biostatistics 615/815 - Lecture 6 Januray 25th, 2011 1 / 32 Announcements
Programming, Data Structures and Algorithms Prof. Hema A Murthy Department of Computer Science and Engineering Indian Institute of Technology, Madras
Programming, Data Structures and Algorithms Prof. Hema A Murthy Department of Computer Science and Engineering Indian Institute of Technology, Madras Lecture - 54 Assignment on Data Structures (Refer Slide
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
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
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
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
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);
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
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
Introduction to C++ Introduction to C++ 1
1 What Is C++? (Mostly) an extension of C to include: Classes Templates Inheritance and Multiple Inheritance Function and Operator Overloading New (and better) Standard Library References and Reference
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
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
STL. Zoltán Porkoláb: C++11/14 1
STL Generic programming An example inserters, iterator-adapters, functors Efficiency Memory consuption characteristics Std::array Forward_list Unordered containers in C++11 Zoltán Porkoláb: C++11/14 1
Part X. Advanced C ++
Part X Advanced C ++ topics Philip Blakely (LSC) Advanced C++ 158 / 217 References The following are highly regarded books. They are fairly in-depth, and I haven t read them in their entirity. However,
The Standard Template Library. An introduction
1 The Standard Template Library An introduction 2 Standard Template Library (STL) Objective: Reuse common code Common constructs: Generic containers and algorithms STL Part of the C++ Standard Library
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
PHY4321 Summary Notes
PHY4321 Summary Notes The next few pages contain some helpful notes that summarize some of the more useful material from the lecture notes. Be aware, though, that this is not a complete set and doesn t
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
LECTURE 11 TREE TRAVERSALS
DATA STRUCTURES AND ALGORITHMS LECTURE 11 TREE TRAVERSALS IMRAN IHSAN ASSISTANT PROFESSOR AIR UNIVERSITY, ISLAMABAD BACKGROUND All the objects stored in an array or linked list can be accessed sequentially
Linked lists Tutorial 5b
Linked lists Tutorial 5b Katja Mankinen 6 October 2017 Aim Pointers are one of the most powerful tools in C++: with pointers, you can directly manipulate computer memory. However, at first glance they
Lectures 11,12. Online documentation & links
Lectures 11,12 1. Quicksort algorithm 2. Mergesort algorithm 3. Big O notation 4. Estimating computational efficiency of binary search, quicksort and mergesort algorithms 5. Basic Data Structures: Arrays
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.
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
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
Expression Trees and the Heap
Expression Trees and the Heap 1 Binary Expression Trees evaluating expressions splitting strings in operators and operands 2 C++ Binary Tree of Strings header files defining the methods 3 the Heap or Priority
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
Suppose that you want to use two libraries with a bunch of useful classes and functions, but some names collide:
COMP151 Namespaces Motivation [comp151] 1 Suppose that you want to use two libraries with a bunch of useful classes and functions, but some names collide: // File: gnutils.h class Stack {... ; class Some
CSCI-1200 Data Structures Fall 2017 Lecture 13 Problem Solving Techniques
CSCI-1200 Data Structures Fall 2017 Lecture 13 Problem Solving Techniques Review from Lecture 12 Rules for writing recursive functions: 1. Handle the base case(s). 2. Define the problem solution in terms
Looping and Counting. Lecture 3 Hartmut Kaiser hkaiser/fall_2012/csc1254.html
Looping and Counting Lecture 3 Hartmut Kaiser hkaiser@cct.lsu.edu http://www.cct.lsu.edu/ hkaiser/fall_2012/csc1254.html Abstract First we ll discuss types and type safety. Then we will modify the program
Slide Set 14. for ENCM 339 Fall Steve Norman, PhD, PEng. Electrical & Computer Engineering Schulich School of Engineering University of Calgary
Slide Set 14 for ENCM 339 Fall 2015 Steve Norman, PhD, PEng Electrical & Computer Engineering Schulich School of Engineering University of Calgary Fall Term, 2015 SN s ENCM 339 Fall 2015 Slide Set 14 slide
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++
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
Cours de C++ Introduction
Cours de C++ Introduction Cécile Braunstein cecile.braunstein@lip6.fr Cours de C++ 1 / 20 Généralité Notes Interros cours 1/3 Contrôle TP 1/3 Mini-projet 1/3 Bonus (Note de Participation) jusqu à 2 points
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
Data Structure using C++ Lecture 04. Data Structures and algorithm analysis in C++ Chapter , 3.2, 3.2.1
Data Structure using C++ Lecture 04 Reading Material Data Structures and algorithm analysis in C++ Chapter. 3 3.1, 3.2, 3.2.1 Summary Infix to Postfix Example 1: Infix to Postfix Example 2: Postfix Evaluation