CMSC 202

Lesson 25Miscellaneous Topics

Warmup

User iterators to print each item in a vector:

____________________________________________________________

____________________________________________________________

for ( ______________________________________________________ )

cout << ________________ << endl;

vector<int>::iterator iter;

iter = integers.begin(); iter != integers.end(); ++iter

vector<int> integers; // assume we initialize this…

*iter

Announcments 2 more days of class (after today)

Thursday Overload the dereferencing operator Bit-wise operators (important for 341)

Tuesday Review for final (cumulative, focus on 2nd

half) Homework:

Go over review questions Go over last semester’s final Bring a question that you want answered

Inline Functions Problem

Calling a 1-line function is inefficient Solution

Inline functions Compiler replaces function call with function body

Drawbacks? Mix definition and implementation Make executables bigger (ack!)

Writing Inline Functions 2 ways

Put the function body in the class definitionclass A{

public:int GetData() { return data; }

private:int data;

};

Put keyword ‘inline’ before the signature lineinline void foobar(){

/* some code */}

Friend Classes Problem:

Class A relies heavily on Class b Tightly coupled – lots of interconnectivity Both classes required to represent 1 data structure

Inefficient to use methods to access data Solution:

Declare Class A as a friend of Class B State that Class A has access to private data

of Class B Drawbacks:

“Break” Encapsulation and Information Hiding

Friend Classestemplate < class T >class List<T>; // a "forward declaration"

template< class T >class Node{ private: Node( );

Node* m_next; int m_data;

friend class List<T>;};

template < class T >class List{ public: List( );

// other public stuff

private: Node<T> *m_header;};

Nested Classes

Same Problem – tightly coupled classes

Solution: Nested Classes

Class defined INSIDE of another class If private?

Entirely hidden from everyone else If public?

Accessible THROUGH the outer-class

Nested Classestemplate< class T >class List{ public: List( ) { m_header = NULL; }

// other public stuff

private: template < class T1 > class Node { private: Node( );

Node<T1>* m_next; int m_data;

}; Node<T> *m_header;};

Node is “nested” inside of List class

If it were public, the Node’s classname

(and type!) would be:

List<T>::Node<T>

The node is scoped INSIDE the List class…

Namespaces Problem:

Your class-names, function-names, or variable-names clash with existing names

Example: You want your own ‘cout’ object You want to define your own ‘vector’ class

Solution: Namespaces

Groups of classes, functions, or variables Allow you to specify exactly which version

Kind of like overloading…

Namespaces Assume ‘Fred’ is a namespace… There are different ways to use Fred…

Using everything from a namespace using namespace Fred;

Use only ‘f’ from Fred using Fred::f;

Qualify each use of something from Fred Fred::f()

Instead of just f() Example:

using namespace std; using std::string; std::string myString = “Hello World!”; std::cout << myString << std::endl;

Creating a Namespace Really simple…

namespace <name>

{

/* functions, classes, or variables */

}

Example:namespace CMSC202

{

/* functions, classes, or variables */

}

Constants and Pointers Problem:

What happens with the following?const int age = 42;int *pAge = &age;*pAge = 57;

Solution: Pointers to Constants

const int age = 42;int age2 = 37;

const int *pAge = &age; // OK!

*pAge = 57; // compiler error!pAge = & age2; // OK!

Const Pointers Problem:

Want to define a pointer that cannot be changed i.e. it cannot point to a different object!

Solution Const Pointers

int width = 56;int length = 42;

int *const pLength = & length; // initialized,

unchangeable

*pLength = 86; // ok - length is not constpLength = &height;

// error - pLength is const

Const Pointer, Const Object Problem:

Can we make an unmovable pointer that points to an unchangeable object?

Solution: Const Pointer to a Const Object…(ack!)

int size = 43; // non-const intconst int weight = 89; // const int

const int *const pWeight = &weight; // const pointer to a

const int

*pWeight = 88; // compiler errorpWeight = &size; // compiler error

cout << *pWeight << endl; // ok - just

//dereferencing

Consts and Pointers… 4 different ways:

int *pInt;

const int *pInt;

int *const pInt;

const int *const pInt;

What do each of these mean???

Hint: read from the “inside” to the “outside…

Pointer to integer

Pointer to constant integer

Constant pointer to integer

Constant pointer to constant integer

STL Algorithms STL provides many algorithms for use with

container classes #include <algorithm>

Some are: for_each() – performs a function on each item

Pass by reference if you want to change the item transform() – performs for_each, but stores result in

another container fill() – fills every item with a supplied value replace() – replaces a subset of the items with value sort() – uses Quicksort to sort items based on some

comparison function

Examples Assume appropriate containers exist…

Square, print, and GreaterThan are user-defined functions (i.e. you must write them!)

for_each( myList.begin(), myList.end(), square );for_each( myList.begin(), myList.end(), print );

transform( v1.begin(), v1.end(), v2.begin(), square);

fill( vString.begin() + 1, vString.begin() + 3, "tommy");

replace( vString.begin(), vString.end(), string("steve"), string("bill"));

sort( v1.begin(), v1.end()); // default, uses operator<sort( v1.begin(), v1.end(), GreaterThan);

Function Objects

Problem: Can we dynamically build functions at

runtime? Solution:

Function Objects Classes (objects) that behave like

functions Overloading the operator( )

I told you it was possible!

Function Objects

Why? Functions that have more properties

than just the operator() Can store a state Separate copies, each with own state Can be initialized in constructor

Function Objects

class Add{ public: // const Add (int value) : m_value( value ) { };

void operator( ) (int& n ) const { n += m_value; }

private: int m_value; // value to add};

void print(const int& i)

{

cout << i << endl;

}

int main ( ){ vector<int> iVector;

// insert some data for (int i = 1; i < 10; i++) iVector.push_back( int(i) );

// print elements // 1 2 3 4 5 6 7 8 9

// create a function adds 42 to parameter Add add42( 42 );

// add 42 to each element of the set for_each( iVector.begin(), iVector.end(), add42);

// print the elements // 43 44 45 46 47 48 49 50 51 for_each( iVector.begin(), iVector.end(), print);};

Code in lecture notes used ‘set’

instead of ‘vector’.

Why won’t that work?

Function Objects

class RNG // Random Number Generator{ public: RNG (unsigned int seed = 1) : m_lastValue( seed ), m_seed( seed ) { srand(seed); }

unsigned int operator( ) () { // modify last Value for new value m_lastValue += rand() % m_seed;

return m_lastValue; }

private: unsigned int m_lastValue; unsigned int m_seed;};

int main ( ){ RNG rng ( 42 );

for (int i = 0; i < 10; i++) cout << rng() << endl;}

Key understanding:

Create functions on the fly!

Often used in Artifical

Intelligence applications!

Practice Which of the following is legal?

Assume that illegal statements are skipped…

BeachBall a(7.0); BeachBall b(6.0);const BeachBall c(5.0);const BeachBall* p = &a;BeachBall* const q = &b;

p->SetRadius(1.0); // 1q->SetRadius(2.0); // 2p = &c; // 3q = &c; // 4p->SetRadius(1.0); // 5q->SetRadius(2.0); // 6

Challenge

Use a Function Object to create a function that computes the polynomial of its parameter n2, n3, n4, …

Exponent is parameter in constructor

Use for_each to compute the square and cube of each float in a vector