cs3101-2 programming languages – c++ lecture 5
DESCRIPTION
CS3101-2 Programming Languages – C++ Lecture 5. Matthew P. Johnson Columbia University Fall 2003. Agenda. hw3 was due last night Today: Templates Exceptions Other odds and ends The STL Grading and the final hw4 TBA tonight. Templates. - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/1.jpg)
CS3101-2, Lecture 5
CS3101-2Programming
Languages – C++Lecture 5
Matthew P. JohnsonColumbia University
Fall 2003
![Page 2: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/2.jpg)
CS3101-2, Lecture 5
Agenda hw3 was due last night Today:
Templates Exceptions Other odds and ends The STL Grading and the final
hw4 TBA tonight
![Page 3: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/3.jpg)
CS3101-2, Lecture 5
Templates Often want to do basically the same thing with
different things functions work on variables
only types specified algorithmic thinking computer science “functionalism” in phil. of mind abstraction human = “the rational animal” (Aristotle)
Sometimes want to do basically the same thing with different types of things Queue of ints, queue of widgets “abstract data types”
![Page 4: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/4.jpg)
CS3101-2, Lecture 5
max functions Suppose want the max of two numbers What kind of numbers?
ints chars floats doubles
All! How?
![Page 5: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/5.jpg)
CS3101-2, Lecture 5
max functions Soln 1: Write one, maxly general function double max(double a, double b) {
return a > b ? a : b;
} double x = max(2.5, 3.5); char c = (char)max(‘A’,’B’); This works but it’s not nice
All four types can widen to doubles but must be cast back
![Page 6: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/6.jpg)
CS3101-2, Lecture 5
max functions Soln 2: Write one function for each type int max(int a, int b) {
return a > b ? a : b;
} double max( … etc. Is allowed in C++ (though not in C) But manually duplicating code
for nontrivial ftns – bad hard to maintain
![Page 7: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/7.jpg)
CS3101-2, Lecture 5
max functions Soln 3: Use the C preprocessor macros #define max(a,b) (a > b ? a : b) C source code is preprocessed
#includes replaced with header files #ifndef, etc. macro calls replaced with macro content
int c = max(2,3); int c = (2 > 3 ? 2 : 3); Works too, but complications, e.g.:
z = max(x++, y++) z = (x++ > y++ ? x++ : y++)
x, y inc-ed twice Need many parens – sq(a+b), etc.
![Page 8: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/8.jpg)
CS3101-2, Lecture 5
max functions Soln 4: Use the CPP in a more sophisticated way Don’t use the CPP to generate expressions but to
generate functions #define define_max(t) \t max(t a, t b) { \
return a > b ? a : b;\}
define_max(char) define_max(int) etc. – no ; Avoids prev. CPP problems But reqs code for all poss types
Done manually
![Page 9: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/9.jpg)
CS3101-2, Lecture 5
Templates template <class T> result ftn(param-list) {…} The place-holder for the substituted type is t template and class are used as keywords can use typename in place of class
T is a type Primitive or class All occurrences in ftn replaced with real type
![Page 10: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/10.jpg)
CS3101-2, Lecture 5
max functions Soln 5: use templates
parameterized function expands per type as necessary
template<typename T>T max(T a, T b) {
return a > b ? a : b;}
Now can simply call the ftn: x = max(2.5,3.5);
Compiler autoly creates only theftn specializations needed
![Page 11: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/11.jpg)
CS3101-2, Lecture 5
Sorting things Consider problem of sorting:
Sorting ints Sorting doubles Sorting strings Sorting widgets
Point of sorting: put list in order Q: What does “in order” mean? A: Given an ordering relation < on the
members For x and y, tells whether x < y Reorder s.t. x is before y iff x < y
![Page 12: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/12.jpg)
CS3101-2, Lecture 5
Generic sorting Sort alg doesn’t depend of element type
Merge sort, quick sort, etc. Need only give means to compare to elms How? In C we pass in a pointer to a compare ftn: void qsort(void *base, int n, int size, int (*cmp)(const void *, void *));
Pass in pointer to ftn: int cmp(const void *a, void *b) {
Widget* w1 = (Widget*)a; …}
Works, but very awkward
![Page 13: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/13.jpg)
CS3101-2, Lecture 5
Generic sorting In Java, we pass a Comparable
implementer In the sort ftn we say if (a.compareTo(b) < 0) …
// means a < b Objects must implement this interface
compare with ftn call Primitives can’t implement
Compared with ops could put in wrappers…
![Page 14: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/14.jpg)
CS3101-2, Lecture 5
Generic sorting C++ soln 1: Define our own Comparable analog:
abstract class Has virtual compareTo Or, better: has virtual < == > operators
Any class extending our class can now be sorted Pass in array of Comparable-extending objects Sort uses polymorphism to treat as (mere) Comparables
Downside: can only sort objects if they extend Comparable
Mult inher: can always add Comp parent,but must do so
To sort primitives must create wrapper classes
![Page 15: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/15.jpg)
CS3101-2, Lecture 5
Generic sorting C++ soln 2: use templates! Let sort take an array of some arb. kind
Don’t need Comparable Don’t need compareTo
In sort, just say if (a < b) …
If these are numbers, this works If these are objects that overload
ops, this works Only requirement:
kind supports < == > ops
![Page 16: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/16.jpg)
CS3101-2, Lecture 5
Templates: swapping Remember our swap-with-ptrs ftn? void swap(int &a, int &b) {
int temp c = a;
a = b;
b = a;
} Suppose we want to swap other types templates
![Page 17: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/17.jpg)
CS3101-2, Lecture 5
Generic swapping template <class T>void swap(T &a,
T &b) {
T temp c = a;
a = b;
b = a;
} Now can swap any prim Can also swap any objects
As long as = op is public
![Page 18: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/18.jpg)
CS3101-2, Lecture 5
Fancier swapping Remember our fancier swap ftn? void swap(int &a, int &b) {
a ^= b ^= a ^= b;}
Fancier template function: template <class T>void swap(T &a,
T &b) {a ^= b ^= a ^= b;
} Now can swap ints, chars, longs But: cannot swap objects
Unless their ^= is overloaded – unlikely
![Page 19: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/19.jpg)
CS3101-2, Lecture 5
Template specialization string s,t … max(s,t); works But max(“hi”,”there”) doesn’t: if (“hi” < “there”) … compares two pointers -
where the char[]s start Not what we mean
Soln: create a specialization special version for this case We check for spec. before template
char *max(char *a, char *b) {
return strcmp(a,b) > 0 ?
a : b;
}
![Page 20: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/20.jpg)
CS3101-2, Lecture 5
Class templates Couple weeks ago: wrote a stack class
supported only integers We’ll abstract element type away
“Abstract data types” Only changes to declar:
1. prepend on class dfn: template <class T>class className {…}2. Replace int T
For ftn implems, we1. prepend the same2. replace className with className<T>3. Replace int T
template <class T>void Stack<T>::push(const T elm){}
To instantiate: Stack<string> strStack;
![Page 21: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/21.jpg)
CS3101-2, Lecture 5
Class specialization Similarly, can specialize member functions
of class templates: void stack<char*>::push(const char
*const item) {
data[count++] = item;
}
![Page 22: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/22.jpg)
CS3101-2, Lecture 5
Templates & statics Review: static data members
one inst shared by all class insts What about statics in templates classes? Q: Could one inst be shared by all insts? A: No – consider: template <class T> class C {
static T mem; …} mem couldn’t me shared by all insts shared by all insts
But: for C<int>, mem shared byall C<int> insts
![Page 23: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/23.jpg)
CS3101-2, Lecture 5
Templates & friends Given class, can declare some outside ftn or class
its friend We have a stack class Suppose: want to declare external sort ftn its
friend Before: had stack with ints
could use sort ftn based on ints Now: have Stack<T>
friend is template too template <class T>class Stack {friend void C<T>::f5(X<T>); …
![Page 24: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/24.jpg)
CS3101-2, Lecture 5
Odds and ends: Forward declarations Suppose classes Cat and Dog each depend on each
other class Cat {
void look(Dog d) { cout << “Meow!\n”; } }; class Dog {
void look(Cat c) { cout << “Bark!\n”; } }; Q: Will this compile? A: No - Dog is referenced before declared Soln: a forward declaration Put class Dog; before Cat def
Dog not yet complete but Dog will now be recognized, w/o Cat depend.
![Page 25: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/25.jpg)
CS3101-2, Lecture 5
Namespaces int i; namespace Example {
double PI = 3.14; int i = 8;void printVals();namespace Inner { int i = 9; }
} // no semi-colon! Can access:
Example::i, Example::Inner::i printVals implementation: void Example::printVals() {
i is Example::i::i is the global I
}
![Page 26: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/26.jpg)
CS3101-2, Lecture 5
Namespaces Now: can use
Example Example::Inner Example::Inner::i Example::i
Nested namespaces ~ Java packages Unfortly: #include (CPP) / using (C++) independent In general, use maximally narrow ranges
Prevent ambiguity Don’t say using namespace std;
Or can fully specify reference: std::std << std::endl;
![Page 27: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/27.jpg)
CS3101-2, Lecture 5
assert Old days: bad thing happens
writing to bad memory address divide by 0, etc. core dump, maybe don’t notice, etc.
void Stack::push(const int item) {data[count++] = item;
} no room overwrite wrong data, crash, etc.
Somewhat better: assert that everything is okay assert(count >= 0 && count < sizeof(data)/sizeof(data[0])); “Everything’s okay, right?”
If false, we quit with message offalse expression
![Page 28: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/28.jpg)
CS3101-2, Lecture 5
Exceptions Now: to some extent
bad behavior is prevented attempt “exception”
If bad things happen we halt, tell calling ftn maybe it halts, tells its calling ftn eventually, either
someone responds accordingly or main ftn passes to OS
try – throw – catch try to do something
maybe an exception gets thrown if so, we may catch it, and go on
![Page 29: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/29.jpg)
CS3101-2, Lecture 5
Exception handling void Stack::push(const int item)
throws BoundExp {
if (count < 0 || count >=
sizeof(data)/sizeof(data[0]))
throw BoundExp(“stack overflow”);
data[count++] = data; //ok if here
} What is BoundExp? A class we define
![Page 30: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/30.jpg)
CS3101-2, Lecture 5
Our exception class BoundExp: exception {
public:
BoundExp(const string &s) exception(s) {}
}; NB: It’s just a class
Its parent is exception but needn’t be Exception has what()
maybe other info
![Page 31: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/31.jpg)
CS3101-2, Lecture 5
Throwing and catching try {
Stack s; …s.push(25); …
}catch (BoundExp &exp) {
cout << “Error: “ << exp.what() << ‘\n’;} catch (ExpType2 &exp) {
// can catch mult kinds// only catch <= 1…
} catch (…) { // … is a wildcard!cout << “Unknown exception
caught.\n”;}
![Page 32: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/32.jpg)
CS3101-2, Lecture 5
Exception classes <exception> exception <stdexcept>
runtime_error, logic_error bad_alloc: new failed bad_cast: dynamic_cast failed
Can throw non-exception objs And even primitives But handling easer if don’t
![Page 33: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/33.jpg)
CS3101-2, Lecture 5
STL Ceteris paribus, libraries are good
Hard, subtle problems many mistakes don’t re-invent the wheel
Unless we’re wheel artists better to commodify the wheel Use an “off-the-shelf” wheel like everyone else
The standard wheel is reliable and efficient STL == Starbucks of programming
Lots of important algorithms,data structures in CS
Barring good reason use std versions
![Page 34: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/34.jpg)
CS3101-2, Lecture 5
Standard Template Library Many template classes, functions Abstract data types Three general categories:
1. Containers2. Iterators3. Algorithms
Three kinds of containers:1. Sequences2. Associative3. Adapted
![Page 35: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/35.jpg)
CS3101-2, Lecture 5
STL: “first-class” containers Sequences: vector: Dynamic-array-backed
const-time random-access const-time insert/delete at back
deque: double-ended queue fast random-access - how? fast insert/delete at front and back
list: doubly-linked list fast insert/delete anywhere
Associative: set: non-sequential, unique multiset: non-sequential, non-unique map: maps from keys to unique values multimap: maps to non-unique values
![Page 36: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/36.jpg)
CS3101-2, Lecture 5
STL: containers Container adapters:
use “first-class” containers by composition stack: LIFO queue: FIFO priority_queue
Near-containers: arrays string bitset valarray
![Page 37: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/37.jpg)
CS3101-2, Lecture 5
Container member ops & ftns copy constructor empty() size() swap First-class: begin() end() rbegin() rend() erase clear()
NB: These are allow very simple - little more than getters
![Page 38: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/38.jpg)
CS3101-2, Lecture 5
STL Iterators Standard way to traverse through
container: iteration Abstraction of both “index” and “pointer”
just: means of iterating forward, back, etc.
Iterator direction types:1. Forward iterator2. Reverse iterator
both supported by vector, list, etc.
3. Random-access iterator supported by vector
Also: its can be const or not
![Page 39: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/39.jpg)
CS3101-2, Lecture 5
Types of iterators I/O iterators are “one-pass”
can only move in one direction can only traverse once – p++
Other types: bidirectional: p++, p-- random-access: p + i, p - i, p[i] *(p+i), p1 < p2
vector: random-access deque: random-access list: bidirectional set/multiset: bidirectional map/multimap: bidirectional
![Page 40: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/40.jpg)
CS3101-2, Lecture 5
vector class Most commonly used container class
Fast random access random-access iterators
Can access mems with []s like arrays – unsafe with at(i) – checks bounds, throws exception – safer
Essentially: dynamic array hidden in obj add to/delete from back: const time unless run out of space autoly copy to larger array insert/del from middle: linear time
must move half of mems forward/back
![Page 41: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/41.jpg)
CS3101-2, Lecture 5
Vectors <vector> Similar to Java’s Vector in that:
dynamic-array-backed list same complexities
Different in that: takes insts of specified type
vector<int> nums; vector<double> vals(20);
size-20 vector of doubles vector<Base> objs;
takes Base objects vector<Base*> ptrs;
takes Base*s or Extended*s
![Page 42: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/42.jpg)
CS3101-2, Lecture 5
Template errors can be illegible Consider this ftn: template <class T>
void printReverse(const vector<T> &vect) {
for (vector<T>::reverse_iterator curr = vect.rbegin();
curr != vect.rend(); curr++)
cout << *curr << ",";
} Slightly different from before
how?
![Page 43: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/43.jpg)
CS3101-2, Lecture 5
Template errors can be illegible
When compiled: Error E2034 c:\Borland\Bcc55\include\rw/iterator.h 442:
Cannot convert 'const int *' to 'int *' in function reverse_iterator<int *>::reverse_iterator(const reverse_iterator<const int *> &)
Error E2094 vect.cpp 19: 'operator!=' not implemented intype 'reverse_iterator<int *>' for arguments of type 'reverse_iterator<const int *>' in function printReverse<int>(const vector<int,allocator<int> > &)
Error E2034 c:\Borland\Bcc55\include\rw/iterator.h 442: Cannot convert 'const int *' to 'int *' in function reverse_iterator<int *>::reverse_iterator(const reverse_iterator<const int *> &)
Warning W8057 c:\Borland\Bcc55\include\rw/iterator.h 442: Parameter 'x' is never used in function reverse_iterator<int *>::reverse_iterator(const reverse_iterator<const int *> &)
*** 3 errors in Compile *** Why? reverse_iterator not const_reverse_iterator
![Page 44: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/44.jpg)
CS3101-2, Lecture 5
Vectors e.g. – vect.cpp template <class T>
ostream& op<<(ostream& out, const vector<T> &vect) {out << "(";for (int i = 0; i < vect.size(); i++)
out << vect[i] << ",";out << ")"; return out; }
template <class T>void printReverse(const vector<T> &vect) {
cout << "(";for (vector<T>::const_reverse_iterator curr = vect.rbegin(); curr != vect.rend(); curr++) cout << *curr << ",";cout << ")";
}
![Page 45: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/45.jpg)
CS3101-2, Lecture 5
Vectors e.g. – vect.cpp void main() {
srand(time(NULL));vector<int> ints;cout << "Initial size == " << ints.size()
<< "\nInitial capacity == " << ints.capacity();for (int i = 0; i < 5; i++)
ints.push_back(rand() % 20);cout << "\nNow, size == " << ints.size() << "\nCapacity == " << ints.capacity();cout << "\nvector: " << ints;cout << "\nvector reversed: ";printReverse(ints);
![Page 46: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/46.jpg)
CS3101-2, Lecture 5
Vectors e.g. – vect.cpp try {
ints.at(100) = 20;} catch (out_of_range oor) {
cout << "\nTried to set mem 100,";
cout << "\nbut caught exception: " << oor.what();
}
sort(ints.begin(), ints.end());cout << "\nAfter sort, vect: “
<< ints;
}
![Page 47: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/47.jpg)
CS3101-2, Lecture 5
Vectors e.g. – vect.cpp Initial size == 0
Initial capacity == 0
Now, size == 5 Capacity == 256
vector: (7,3,16,14,17,)
vector reversed: (17,14,16,3,7,) Tried to set mem 100 to 20, but caught exception: index out of range in function: vector:: at(size_t) index: 100 is greater than max_index: 5
After sort, vector: (3,7,14,16,17,)
![Page 48: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/48.jpg)
CS3101-2, Lecture 5
STL interators – iterio.cpp Access set of values from one place Usually, place is a container But: input stream may be construed as a place #include <iostream> #include <iterator> using namespace std; void main() {cout << “Enter two nums: “;istream_iterator<int> intIn(cin);int x = *intIn;intIn++; x += *intIn;ostream_iterator<int> intOut(cout);cout << “The sum is: “;*intOut = x; cout << endl;
}
![Page 49: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/49.jpg)
CS3101-2, Lecture 5
I/O iterators – ioiter.cpp Code: int x = *intIn;
intIn++; x += *intIn; Output: C:\3101-2\lec5>ioiter
Enter two nums: 5 6The sum is: 11
But if code: int x = *intIn;
/*intIn++;*/ x += *intIn; Then output: C:\3101-2\lec5>ioiter
Enter two nums: 5 6The sum is: 10
![Page 50: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/50.jpg)
CS3101-2, Lecture 5
copy function – vect2.cpp Another way to print container:
use copy function if (!vect.empty()) {
ostream_iterator<T> out(cout, " ");copy(vect.begin(), vect.end(), out);
} copy(src begin it, src end it, dest it);
src begin it: vect.begin() src end it: vect.end()
dest it: ostream_iterator<T> out(cout, " ") it’s an ostream_iterator it’s wrapping around cout it’s outputting Ts it’s printing “ “ between the Ts
![Page 51: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/51.jpg)
CS3101-2, Lecture 5
shuffle, sort, search, min – vect2.cpp
void sort(begin it, end it) it-s must be random-access members must support ==, <
void random_shuffle(begin it, end it) same req’s
bool binary_search(begin, end, target) same req’s also: assumes sorted
min_element(v.begin(), v.end()) returns iterator
![Page 52: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/52.jpg)
CS3101-2, Lecture 5
shuffle, sort, search, min – vect3.cpp
All ftns translate automatically to strings
transform ftn – vect4.cpp transform(begin it, end it, dest it, ftn)
transform(v.begin(), v.end(), v.begin(), square);
cout << "\nAfter squaring, vector: " << v << endl;
![Page 53: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/53.jpg)
CS3101-2, Lecture 5
for_each ftn – vect4.cpp Another way to print container:
use for_each function for_each(begin it, end it, ftn) Our subroutine: template<class T>void print(T val) {
cout << val << "/";}
if (!vect.empty()) { for_each(vect.begin(),
vect.end(), print<T>);}
NB: print<T> is a function pointer
![Page 54: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/54.jpg)
CS3101-2, Lecture 5
Other containers list: doubly linked list
insert/delete anywhere: const time access: linear time bidirectional iterators
deque: double-ended queue insert/delete at front/back: const time insert/delete in middle: linear time access: constant time random-access iterators
![Page 55: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/55.jpg)
CS3101-2, Lecture 5
strings as containers Can traverse strings in the usual way: for (int i = 0; i < i.length(); i++)
cout << s[i]; Also: for (char::iterator curr = s.begin(); curr != s.end(); curr++)
cout << *curr;
![Page 56: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/56.jpg)
CS3101-2, Lecture 5
STL Algorithms - <algorithm> binary_search sort count: count(list.begin(),
list:end(), val, num); equal: compares containers for_each: applies ftn to each element copy: copies container reverse min/max Some in <numeric>
![Page 57: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/57.jpg)
CS3101-2, Lecture 5
Other algorithms Set-theoretic:
set_union set_intersection set_difference set_symmetric_difference
Sorting: sort_heap stable_sort
And many more…
![Page 58: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/58.jpg)
CS3101-2, Lecture 5
Algorithms in STL Important observation: STL class live in own headers
- <vector>, <list>, but STL algs live in places like <algorithm> and <numeric>
To sort, we pass access (it) to our obj to the sort ftn We don’t call obj.sort() Why? The STL doesn’t use inheritance! Why not? virtual functions are slow(er) No inher would have to dup. ftns No inher no encapsulation algorithms on their own
![Page 59: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/59.jpg)
CS3101-2, Lecture 5
STL e.g.: grades Goal: store grades for group of students
ordered set of assignments maybe students with same name
For each student, have grades want fast access to each grade use vector of chars typedef vector<int> Grades;
First, create map of students: map<string, Grades> roster;
![Page 60: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/60.jpg)
CS3101-2, Lecture 5
STL: add a student to map map represents a function: key maps to value map, basically: set of ordered pairs
pair<x,y> template void Roster::addStudent(const string &name) {
//check if already existsif (roster.find(name) != roster.end())
return;//check for roomif (roster.size() == MAX) waitList.push_back(name);else { Grades grades; roster.insert( pair<string,Grades>(name,grades));
}
![Page 61: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/61.jpg)
CS3101-2, Lecture 5
STL: add a student to map Notice find line: if (rost.find(name) != rost.end())
return; find function searches for an elm with our key if found, returns pointer to it if not, returns pointer to end()
points past, not to last member like: for (int i = 0; I < n; i++)
More precisely: these ptrs areiterators – inc/dec to step through seq
More precisely: these ptrs are iterators ops overloaded as though moving thru mem
![Page 62: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/62.jpg)
CS3101-2, Lecture 5
STL: add a student to map Notice insert line: roster.insert( pair<string,Grades>(name,grades));
Dissection: Add a member to a roster The member is a pair of two things
member ftns: first(), second() The things are string and Grades pair<X,Y>(x,y) is a constr call:
passes x and y to constr for type pair<X,Y>
![Page 63: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/63.jpg)
CS3101-2, Lecture 5
STL: drop a student void Roster::dropStudent(String &name) {
if (roster.find(name) == roster.end())return;
roster.erase(name);if (waitList.size() > 0) {
string wait = waitList.pop_front();
waitList.pop();Grades grades;roster.insert(
pair<string,Grades>(name,grades));}
}
![Page 64: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/64.jpg)
CS3101-2, Lecture 5
STL: set a grade void Roster::setGrade(const &string name,
const int assign, const char grade) {
map<string,Grades> stud = roster.find(name);
if (stud == roster.end()) {cerr << “not found\n”;return;
}if (stud->second().size() <= assign) stud->second().resize(assign+1);
stud->second[assign] = grade;}
![Page 65: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/65.jpg)
CS3101-2, Lecture 5
STL: print grades void Roster::print() { … } Already saw many print/<< functions…
That’s all we’ll cover of STL Many more classes, algs in STL Much more to C++ itself But: you now know enough
About the most import. Features To learn remaining details on own
![Page 66: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/66.jpg)
CS3101-2, Lecture 5
Next time: final exam Closed books/notes/everything 2 hours/class time Questions:
“Vocab”: protected, static, etc. Find errors/read code/predict output Write code
See web for a semi-definitive list of topics Jake will be proctoring the exams But we’ll have OH next week(end)
Come in if you have questions!
![Page 67: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/67.jpg)
CS3101-2, Lecture 5
Grading Final will be hard/challenging
Ave score probably near 70% Final grades are curved
Rule of thumb: mean ~ stdev Mean ~ B/B- +-stdev ~ one letter grade See mean/stdevs on web to estimate your
grade
![Page 68: CS3101-2 Programming Languages – C++ Lecture 5](https://reader036.vdocuments.us/reader036/viewer/2022062304/56814524550346895db1e936/html5/thumbnails/68.jpg)
CS3101-2, Lecture 5
The future Q: What happens when backward-compat is
removed from C++? A: C#
less complexity Microsoft approves
Better or worse than C++, Java? Find out in CS3101-4: C#, next spring
Tonight: hw4 TBA – due by final Please fill out course evals!
Link will be on classpage tonight Available until beginning of finals Get valuable extra credit on final
Sign in and good luck! Happy Thanksgiving!