Object Oriented Programmingwith C++

Moshe FreskoBar-Ilan University

2007-2008

Course Requirements Goals

To learn basics of Object Oriented Programming

To program in C++ Practically see Design Paradigms

Exercises Exercises will be 20% of the final grade

Exam 80% of the final grade

Resources Books

C++ Programming Language, by Bjarne Stroustrup Thinking in C++, by Bruce Eckel C++ Professional in Hebrew Design Patterns, by Gamma, Helm, Johnson, and

Vlissidis

Compilers Visual C++ Borland C++ GNU C++ (gcc)

Introduction to C++

History C++ is written by Bjarne Stroustrup

from AT&T Bell Laboratories C++ is the extension into ANSI-C Procedural Programming

Object Oriented Programming It supports

Object Oriented Programming Generic Programming etc.

History History

1980 C with classes 1983 Name C++ is given 1985 Version 1.0 (Basics) 1987 Standardization Process 1989 ANSI C++ 1989 Version 2.0

(Multi-inheritance, Operator Overloading) 1991 Version 3.0

(Templates) 1995 Standard Template Library (STL),

namespace, RTTI

C++ Design has been influenced from languages Simula67, Algol68, and SmallTalk.

Introduction to C++ Advantageous

Largely used Extension to C Object Oriented Programming Standard Template Library Efficient Programs can be written

Disadvantageous Complicated Language No support for Concurrent Programming No support for Serialization

Program Execution Language Translation

The translation of Human-Understandable Code into Machine-Understandable

Two types of Translation1. Interpreter2. Compiler

C++ Compilation Process1. Preprocessor

Optionally also does Global Optimizations2. Compiler

1. First Pass: Creates parse tree2. Second Pass: Creates object modules (*.obj) Optionally also does Peephole Optimizations

3. Linker From a list of Object Files creates an executable

Declaration vs. Definition Declaration and Definition in C++

Declaration: Introduces a name to the compiler. This name might be a user defined type, a variable, or

a function. Definition: It says make this function/variable

here. It allocates storage for the name.

For any name many declarations can be done, but exactly one definition must exist.

Declaration vs. Definition Functions

Definitionint func1(char, float) { /*…the code…*/ }

Declarationint func1(char, float);

Variables Definition

int a ; Declaration

extern int a ;

Declaration vs. Definition// File: Exemple1.cppextern int i; // Declaration without definitionextern float f(float); // Function declaration

float b; // Declaration & definition floatfloat f(float a) { // Definition

return a + 1.0; } int i; // Definition int h(int x) { // Declaration & definition

return x + 1; } int main() {

b = 1.0; i = 2; f(b); h(i);

}

Header Files A header file is a file containing the external declarations for a

library.

It conventionally has a file name *.h.

To include a header file, use the #include preprocessor directive.

Search the file in “implementation-defined way.” #include “local.h”

Search the file in “include search path” #include <header>

Old style vs. New Style Libraries#include <iostream.h> #include <iostream>#include <stdio.h>#include <cstdio>

Using Libraries

For using libraries1. Include the library’s header file.2. Use the functions and variables in

the library.3. Link the library into the executable

program.

First C++ Program – Hello.cpp

// Hello.cpp

#include <iostream> //Stream declarations using namespace std;

int main() {

cout << "Hello, World! I am " << 8 << " Today!" << endl;

}

// To Compile: gcc Hello.cpp// or g++ Hello.cpp// or cl Hello.cpp

Some C++ Examples Number Conversion

// Numconv.cpp // Converts decimal to octal and hex

#include <iostream> using namespace std;

int main() {

int number; cout << "Enter a decimal number: "; cin >> number; cout << "value in octal = 0"

<< oct << number << endl; cout << "value in hex = 0x"

<< hex << number << endl; }

Some C++ Examples string class

// HelloStrings.cpp // The basics of the Standard C++ string class #include <string> #include <iostream> using namespace std;

int main() { string s1, s2; // Empty strings string s3 = "Hello, World."; //

Initialized string s4("I am"); // Also initialized

s2 = "Today"; // Assigning to a string s1 = s3 + " " + s4; // Combining strings s1 += " 8 "; // Appending to a string cout << s1 + s2 + "!" << endl;

}

Some C++ ExamplesFile Input Output

// Scopy.cpp // Copy one file to another, a line at a time

#include <string> #include <fstream> using namespace std;

int main() { ifstream in(“File1.txt"); // Open for reading ofstream out(“File2.txt"); // Open for writing

string s; while(getline(in, s)) // Discards newline char

out << s << "\n"; // ... must add it back }

Some C++ ExamplesFill String

// FillString.cpp // Read an entire file into a single string

#include <string> #include <iostream> #include <fstream> using namespace std;

int main() { ifstream in(“File.txt”); string s, line; while(getline(in, line))

s += line + "\n”; cout << s;

}

Some C++ Examplesvector class

// Fillvector.cpp // Copy an entire file into a vector of string #include <string> #include <iostream> #include <fstream> #include <vector> using namespace std;

int main() { vector<string> v; ifstream in("Fillvector.cpp"); string line; while(getline(in, line))

v.push_back(line); // Add the line to the end

// Add line numbers: for(int i = 0; i < v.size(); i++)

cout << i << ": " << v[i] << endl; }

Some C++ Examplesvector with integers

// Intvector.cpp // Creating a vector that holds integers #include <iostream> #include <vector> using namespace std; int main() {

vector<int> v; for(int i = 0; i < 10; i++)

v.push_back(i); for(int i = 0; i < v.size(); i++)

cout << v[i] << ", "; cout << endl; for(int i = 0; i < v.size(); i++)

v[i] = v[i] * 10; // Assignment for(int i = 0; i < v.size(); i++)

cout << v[i] << ", "; cout << endl;

}

Exercises1. Using Numconv.cpp as guidelines, create a program that asks for

the radius of a circle and prints the area of that circle. 2. Create a program that opens a file and counts the whitespace-

separated words in that file.3. Change Fillvector.cpp so that it prints the lines (backwards) from

last to first.4. Display a file a line at a time, waiting for the user to press the

“Enter” key after each line.5. Create a vector<float> and put 25 floating-point numbers into it

using a for loop. Display the vector.6. Create three vector<float> objects and fill the first two as in the

previous exercise. Write a for loop that adds each corresponding element in the first two vectors and puts the result in the corresponding element of the third vector. Display all three vectors.

7. Create a vector<float> and put 25 numbers into it as in the previous exercises. Now square each number and put the result back into the same location in the vector. Display the vector before and after the multiplication.

Types and Declarations

Types and Declarations Consider

x = y + f(2) ;

To make it meaningful for C++float x ; // x is a floating point variableint y = 7 ; // y is an integer variable// initialized to 7float f(int) ; // f is a function taking argument // type integer and returning// floating point number

Fundamental Types Boolean Type

bool Character Types

such as char Integer Types

such as int Floating-Point Types

such as double Absence of

Information Typevoid

Enumeration Typesenum

Pointer Typesint*

Array Typeschar[]

Reference Typesdouble&

Structures and Classesstru { … }class { … }

Booleans bool is either true or false.

Examples:void f(int a, int b) {

bool check = a==b ; // …

}bool is_open(File*) ;bool greater(int a, int b) { return a>b ; }

Implicit Conversions bool to int

false 0 true 1 int to bool

0 false Non-zero true

Character Types char holds a character of implementation’s character

set

Example: char ch = ‘a’ ;

Two typessigned char -127 … 127unsigned char0 … 255

For Unicodewchar_t

Character Literals‘a’ ‘0’ ‘\n’ ‘\t’ L’ab’

Integer Types Three forms

intsigned int ( or signed )unsigned int ( or unsigned )

Three sizesshort int ( or short )intlong int ( or long )

Integer LiteralsDecimal: 0 63Octal: 00 077Hexadecimal: 0x0 0x3f

U for Unsigned Literals 63UL for Long Literals 63L

Floating Point Types

Three Sizesfloatdoublelong double

Floating Point Literals1.23 .23 0.23 1.1.0 1.2e10 1.23e-15Suffix F for float 3.1416f 2.0F

Fundamental Types

sizeof(…) gives the size of any type in terms of chars

sizeof(char) == 1

Voidvoid x ; // errorvoid f() ; // function does not return a valuevoid* pv ; // pointer to unknown type

Enumerations An enumeration is a type that can hold a set of values

specified by the user. It is used like an integer type.

Example:enum { ASM , AUTO , BREAK } ; // ASM==0, AUTO==1, BREAK==2

Or enum keyword { ASM , AUTO , BREAK } ;

void f(keyword key) { switch(key) {case ASM : // do somethingbreak ;case BREAK : // do somethingbreak ; }}

Declarations and Definitions Before an identifier can be used it must be declared (or

defined), to inform the compiler what kind of entity the name refers

char ch ; // NO VALstring s ; // NO VALint count = 1 ;const double pi = 3.1415926535897932385 ;extern int error_number ; // NO DEFchar* name = “Haim” ;char* season [ ] = { “spring”, “summer”, “fall”, “winter” } ;struct Date { int d, m, y ; } ; int day(Date* p) { return p->d ; }double sqrt(double) ; // NO DEFtemplate<class T> T abs(T a) { return a<0 ? –a : a ; }typedef complex<short> Point ;struct User ; // NO DEFenum Beer { Carlsberg, Tuborg, Macabi } ;namespace NS { int a; }

Declarations and Definitions Some definitions do not have pre-declarations

double sqrt(double) { /*…*/ }int error_number = 1 ; struct User { /*…*/ }

Declaring/Defining multiple namesint* p, y; // int*p; int y;int x, *q; // int x; int*q;int v[10], *pv; // int v[10]; int* pv;

Name Starts with letter or underscore and consists of letters,

underscores and digits

Scope A definition introduces a name into a scope.

int x; // Globalvoid f() {

int x; // Local x hides global xx=1; // Assign to local x::x=4; // Assign to global x{ int x; // Hides previous local x

x=2; // Assign to second local x}x=3; // Assign to first local x

}int* p=&x; // Take address of global x

Initialization Initialization

int a ; // a is 0double d ; // d is 0.0void f() {

int x ; // x is not initialized}int arr[]={1,2} ; // Array InitializationPoint z(1,2) ; // Constructor Initializationint f() ; // Function declaration

lvalue : Expression that refers to an object, that is modifiable.

*p[a+10] = 7 ; Typedef :

Declares a new name typedef char* PChar ;PChar p1, p2 ;

Advices1. Keep scopes small2. Don’t use the same name in both a scope and an enclosing scope3. Declare one name per declaration4. Keep common and local names short, and uncommon and non-local

names longer5. Avoid similar-looking names6. Maintain a consistent naming style7. Choose names to reflect meaning rather then implementation8. Use a typedef to define a meaningful name for a built-in type in

cases in which the built in type used to represent a value might change

9. Use typedefs to define synonyms for types; use enumerations and classes to define new types

10. Do not make assumptions on the size of integers/Objects11. Do not make assumptions on the range of floating-point types12. Avoid unsigned arithmetic13. View conversions with suspicion. Like signed to unsigned and vice

verse, floating-point to integer, int to char, etc.

Pointers, Arrays, and Structures

Pointers

For a type T, T* is “pointer to T” A variable of type T* can hold the

address of an object of type T. Example:

char c = ‘a’ ;char* p = &c ; // p holds the address of c

c:

p: &c

‘a’

Pointers Pointer Examples

int* pi ; // pointer to intchar** ppc ; // pointer to pointer to charint* ap[15] ; // array of 15 pointers to intint (*fp)(char*) ; // pointer to functionint* f(char*) ; // function

Dereferencingchar c = ‘a’ ;char* p = &c ; // p holds the address of cchar c2 = *p ; // c2 is assigned the value pointed by p

Zero NULL : const int NULL = 0 ;

Arrays For a type T, T[size] is “array of size elements of

T.” Index from 0 to size-1. Examples

float v[3] ; // array of 3 floats, v[0], v[1] and v[2]char* a[32] ; // array of 32 pointers to charvoid f(int i) {

int v1[i] ; // Errorvector<int> v2(i) ; // OK

} int d2[10][20] ; // Array of 10 arrays of 20 integersint v1[] = {1,2,3,4} ;char v4[3] = {‘a’, ‘b’, 0}

Arrays String Literals

“this is a string” ;sizeof(“Arik”)==5 ; // const char[5], last char is ‘\0’const char* errorMessage()

{ /*…*/ return “Range-Error” ; } // Statically allocated

cout << “End of the message\n” ; // New Line

Pointers into Arraysint v[]={1,2,3,4} ;int* p1 = v ; int* p2 = &v[0] ;int* p3 = &v[4] ; 1 2 3 4v:

p1 p2 p3

Arrays Implicit conversion

extern “C” int strlen(const char*); // from <string.h>void f() {

char v[] = “Wonderful Life” ;char* p=v ; // Implicit conversion from char[] to char*strlen(p) ;strlen(v) ; // Implicit conversion from char[] to const char*// v = p ; // Error; Cannot assign into array

}

Navigating Arraysvoid fi(char v[]) {

for (int i=0;v[i]!=0;++i) use(v[i]) ;}void fp(char v[]) {

for (char* p=v;*p!=0;++p) use(*p) ;}

Pointer Arithmetic Pointer Address

#include <iostream>int main() {

int vi[10] ;short vs[10] ;std::cout << &vi[0] << ‘ ‘ << &vi[1] << endl ;std::cout << &vs[0] << ‘ ‘ << &vs[1] << endl ;

}// Produces : 0x7fffaef0 0x7fffaef4// 0x7fffaedc 0x7fffaede

Pointer Addition, Subractionvoid f() {

int v1[10] ; int v2[10] ;int i1 = &v1[5]-&v1[3] ; // 2int i2 = &v1[5]-&v2[3] ; // Result undefinedint* p1 = v2+2; // p1=&v2[2] ;int* p2 = v2-2 ; // *p2 is undefined

}

Constants const values doesn’t change directly

const int model=90 ; // model is a constantconst int v[]={1,2,3} ; // v[i] is a constantconst int x ; // Error: No Initializervoid f() {

model=200; // Errorv[2]++ ; // Error

} const parameters

void g(const X* p) {// can’t modify *p here

}void h() {

X val ;g(&val) ;

Pointers and Constants Pointers involve two objects. The Value

pointed to and the pointer.void f1(char*p) {

char s[]=“Mediterranean” ;const char* pc=s; // pointer to constantpc[3]=‘m’; // Errorpc=p; // Okchar *const cp=s; // constant pointercp[3]=‘m’; // Okcp=p; // Errorconst char *const cpc=s; // const pointer to constcpc[3]=‘m’; // Errorcpc=p; // Error

}

References A reference is an alternative name for an object.

void f() {int i=1;int& r=i; // r and i refer to the same intint x=r; // x is 1r=2; // i is 2

}

void g() {int i=1;int& r=i;int* p=&r;r++; // i is 2(*p)++; // i is 3

}

References Reference can be used as Copy-by-Reference

argument to a functionvoid increment ( int & a) { ++a ; }void incr ( int* p ) { ++(*p) ; }int next ( int i ) { return i+1 ; }void g() {

int x = 1 ; increment (x) ; // x is 2incr ( &x) ; // x is 3x = next (x) ; // x is 4

}

Pointer to void Any pointer can be assigned to void*, and void* can be

explicitly converted to any pointervoid f ( int* pi ) {

void* pv = pi ; // implicit conversion*pv ; // error. Cannot dereference void*pv++ ; // error. Cannot increment void*int* pi2 = static_cast<int*>(pv) ; // explicit conversion to int*double* pd1=pv; // errordouble* pd2=pi; // errordouble* pd3=static_cast<double*>(pv); // unsafe

}

Allocation into void*void* my_alloc(size_t n) ; // allocate n bytes from the

heap

Structures A struct is an aggregate of elements of arbitrary types.

struct Address {char* name ; // “Moshe Levy”long int id ; // 123456789char* street ; // “Jabotinsky 33”char* city ; // “Ramat Gan”long zip ; // 34567}

void f() {Address a ;a.name = “Moshe Levy” ; a.id = 123456789 ;}

Address ad = { “Moshe Levy”, 123456789, “Jabotinsky 33”, “Ramat Gan”, 34567” }

Structuresvoid print_addr ( Address* p ) {

cout << p->name << “\n”<< p->id << “\n”<< p->street << “\n” << p->town << “\n” << p->zip << “\n” ;

}

Address current ;Address setCurrent ( Address next ) {

Address prev = current ;current = next ;return prev ;

}

Structures The name is immediately available

struct Link {Link *prev ;Link *next ;int value ;

}struct NoGood {

NoGood member ; // Error}

Pre Definitionstruct S ;extern S a ;S f() ;void g(S) ;void k(S* p) {

S a ; // Error: Size neededf() ; // Error: Size needed to return a

valuep->m=7; // Error: Member not

known S* q=h(p); // Ok}

Advice1. Avoid non-trivial Pointer Arithmetic2. Take care not to write beyond the

bounds of an array3. Use vector instead of built in arrays4. Use string instead of ‘\0’ terminated

char arrays5. Minimize use of plain reference

arguments6. Avoid void* except in low-level code7. Avoid non-trivial literals. Instead define

and use symbolic constants.

A bit Background to C

Functions Function Prototyping (Declaration)

The declaration of a function can be given in any place in the program

int translate (float x, float y, float z); In prototyping argument names are optional

int translate (float, float, float);

Function definition The definition must be done only once. The argument names must be given since they are

referenced inside the definitionint translate (float x, float y, float z)

{ return x + y * z ; }

Functions Return value type must be specified

int f1(void); // Returns an int, takes no arguments int f2(); // Like f1() in C++ float f3(float, int, char, double); // Returns a float void f4(void); // Takes no arguments, returns nothing

Return value must be returned in the definition// Return.cpp // Use of "return" #include <iostream> using namespace std; char cfunc(int i) {

if(i == 0) return 'a'; return 'c';

} int main() {

cout << "type an integer: "; int val; cin >> val; cout << cfunc(val) << endl;

}

Parameter-Passing Function Parameters

Pass-by-value: a copy of that argument is made inside the function

// PassByValue.cpp void f(int a) { a = 6; } int main() { int x = 48;

f(x);int y = x; // x and y are 48

} Pass-by-reference: An alias of the passed name

// PassByValue.cpp void f(int& a) { a = 6; } int main() {

int x = 48; f(x);int y = x; // x and y are 6

}

Parameter-Passing Examples We can pass-by-reference effect by passing

pointer// PassByPointer.cpp

void f(int* a) { *a = 6; } int main() { int x = 48;

f(&x);int y = x; // x and y are 6

}

Some Examples void f1(char c, int i, float f, double d); void f2(short int si, long int li, long double ld); void f3(char* cp, int* ip, float* fp, double* dp); void f4(char& cr, int& ir, float& fr, double& dr);

Control Statements

C++ Control Statements if-else while do-while for switch goto

Control Statementsif-elseif(expression)

statement OR

if(expression) statement

else statement

Expression must evaluate to true or false Statement must be in { } in case it has more

then once command

Control Statements - if-else

// Ifthen.cpp // Demonstration of if and if-else conditionals #include <iostream> using namespace std;

int main() { int i; cout << "type a number and 'Enter'" << endl; cin >> i; if(i > 5)

cout << "It's greater than 5" << endl; else

if(i < 5) cout << "It's less than 5 " << endl;

else cout << "It's equal to 5 " << endl;

}

Control Statements - while The statement is repeated until the expression is false

while (expression) statement

The expression is evaluated once at the beginning of the loop and again before each further iteration of the statement

Example// Guess.cpp // Guess a number (demonstrates "while") #include <iostream> using namespace std; int main() {

int secret = 15; int guess = 0; while (guess != secret) { // Compound statement

cout << "guess the number: "; cin >> guess;

} cout << "You guessed it!" << endl;

}

Control Statements – do-while

do statement

while (expression); The expression is evaluated after the first loop if it is true

the next iteration is done before checking it again Example

// Guess2.cpp // The guess program using do-while #include <iostream> using namespace std; int main() {

int secret = 15; int guess; // No initialization needed here

do { cout << "guess the number: "; cin >> guess; // Initialization happens

} while (guess != secret); cout << "You got it!" << endl;

}

Control Statements - forfor ( initialization; conditional; step)

statement The initialization code executes once at the very

beginning. The conditional is tested before each iteration (if it evaluates to false at the beginning, the statement never executes). At the end of each loop, the step executes.

Example: // Charlist.cpp

// Display all the ASCII characters // Demonstrates "for" #include <iostream> using namespace std; int main() { for ( int i = 0; i < 128; i = i + 1) if (i != 26) // ANSI Terminal Clear screen cout << " value: " << i << " character: " << char(i) << endl; }

Control Statements -break and continue statements break quits the loop without executing the rest of the

statements in the loop. continue stops the execution of the current iteration and goes

back to the beginning of the loop to begin a new iteration. Example

// Menu.cpp // Simple menu program demonstrating the use of "break" and "continue" #include <iostream> using namespace std; int main() { char c; // To hold response while(true) { cout << "MAIN MENU:" << endl << “l: left, r: right, q: quit -> "; cin >> c; if(c == 'q') break; if(c == 'l') { /* … Do something … */ continue; } if(c==‘r’) { /* … Do something … */ continue ; } cout << “Error!” << endl ; }}

Control Statements -switch A switch statement selects from among

pieces of codeswitch(selector) {

case integral-value1 : statement; break; case integral-value2 : statement; break; case integral-value3 : statement; break; (...) default: statement;

}

Control Statements -switch

//: C03:Menu2.cpp // A menu using a switch statement #include <iostream> using namespace std; int main() { bool quit = false; // Flag for quitting while(quit == false) { cout << "Select a, b, c or q to quit: "; char response; cin >> response; switch(response) { case 'a' : cout << "you chose 'a'" << endl; break; case 'b' : cout << "you chose 'b'" << endl; break; case 'c' : cout << "you chose 'c'" << endl; break; case 'q' : cout << "quitting menu" << endl; quit = true; break; default : cout << "Please use a,b,c or q!" << endl; } } }

Auto-Increment/Decrement ++i increments i and returns the new value i++ increments i and returns the previous values --i decrements i and returns the new value i-- decrements i and returns the previous value Example

// AutoIncrement.cpp // Shows use of auto-increment and auto-decrement operators. #include <iostream> using namespace std; int main() {

int i = 0; int j = 0; cout << ++i << endl; // Pre-increment prints cout << j++ << endl; // Post-incrementcout << --i << endl; // Pre-decrement cout << j-- << endl; // Post decrement

}

Scoping The variables are available within their scope

from the point they are defined.

void main() {// no variablesint i1 ;// i1 is available here{

// i1 is available here, but not i2int i2 ;// i1 and i2 are available here

}// i1 is available here but not i2

}

Dynamic Object Creation

Dynamic Object Creation Not always we know the exact quantity, type, and lifetime of

the objects in a program. We need to create and destroy objects at runtime.

Dynamic Memory allocation in C void* malloc(int size); void* calloc(int num,int size); void* realloc(void*,int size); void free(void*);

These methods allocates/frees blocks of memory on the heap

This will not work in C++ for Objects, since One can forget to initialize the object One can accidentally do something to the object before it is

initialized Hand it the wrong-sized object.

C’s approach for Memory Allocation in C++

// MallocClass.cpp // Malloc with class objects. What you'd have to do if not for "new“. #include <cstdlib> // malloc() & free() #include <iostream> using namespace std;

class Obj { void initialize() // Can't use constructor

{ cout << "initializing Obj" << endl; }void destroy() const // Can't use destructor

{ cout << "destroying Obj" << endl; } };

int main() { Obj* obj = (Obj*)malloc(sizeof(Obj)); obj->initialize(); // ... sometime later: obj->destroy(); free(obj); }

Dynamic Object Creation

When a C++ object is created1. Storage is allocated for the object.2. The constructor is called to initialize

that storage.

Storage can be allocated Before the program begins, in the static

storage area. Storage can be created on the stack Storage can be allocated from the heap

Dynamic Object Creation Dynamic Memory allocation in C++

Allocating one object with new operator MyType *fp = new MyType; // Default Constructor MyType *fp = new MyType(1,’a’); // Another

constructor Freeing one object with delete operator

delete fp;

Allocating an array of objects with new[] operator MyType* fparr = new MyType[100]; // Only Default

Constructor Freeing a list of objects with delete[] operator

delete[] fparr;

Dynamic Object CreationExample

// Stack.h// Stack: LIFO: It allows to insert and to get numbers in// The number to be get next is the one inserted more recentlyclass Stack { private:

int* arr ; // The list of numbers is kept hereint size ; // The size of the numbers in the stackint capacity ; // The capacity of the arrayvoid resize() ;

public:Stack() { size=0; capacity=10; arr=new int[capacity] ; }~Stack() { delete [] arr ; }void put(int next) ;int get() ; bool isEmpty() { return size==0 ; }

};

Dynamic Object CreationExample

// Stack.cpp : The definitions for some functions of Stackvoid Stack::put(int next)

{ if (size==capacity)resize() ;

arr[size++] = next ; }int Stack::get()

{ return arr[--size] ; }void Stack::resize() {

capacity *= 2 ;int* narr = new int[capacity] ;for (int i=0;i<size;++i)

*(narr+i) = *(arr+i) ;delete [] arr ;arr = narr ;

}

Dynamic Object CreationExample

// StackUsage.cpp // Trying the Stack Class #include <iostream> using namespace std;

int main() { Stack stack;stack.put(10) ; stack.put(20) ;stack.put(30) ; while (! stack.isEmpty())

cout << “The next number get: “<< stack.get() << endl ;

} // Prints in order: 30, 20, and 10

Exercises

1. Write class Queue. It will work as a FIFO. The element will exit in the same order they are inserted.

2. Write class String that can grow infinitely. It will have a default ctor will start with an empty internal string. Function append(const char*) adds the given string into the end of the internal string. Reminder: The string in C is a character array ending with ‘\0’.