C++ Review

Lecture 1
Outline
 C++ basic features
 Programming paradigm and statement syntax
 Class definitions
 Data members, methods, constructor, destructor
 Pointers, arrays, and strings
 Parameter passing in functions
 Unlike the text book, in this course, we will not use
 Templates

 Friend

 Operator overloading

 I/O streams
 An example on file copy
 Makefile on unix

2
Functions & Memory
 Every function needs a place to
store its local variables. Memory
Collectively, this storage is called location
the stack i
 This storage (memory aka “RAM”), d2
is a series of storage spaces and
d1
their numerical addresses
 Instead of using raw addresses, y
we use variables to attach a x
name to an address
 All of the data/variables for a
particular function call are located void aFunc(int x, int y)
in a stack frame {
double d1, d2;
int i;
}
3
Functions & Memory (cont)
 When a function is called, a new stack
frame is set aside
 Parameters and return values are
passed by copy (ie, they’re copied into
and out of the stack frame)
 When a function finishes, its stack frame
is reclaimed

void aFunc(int x, int y) {

double d1 = x + y;
}
int main(int argc,
const char * argv[]) { d1
int x = 7;
aFunc(1, 2); y aFunc
aFunc(2, 3);
return 0;
x
}
x 7 main
4
Programming Paradigm: Modular Concept

 The main program coordinates calls to procedures in

separate modules and hands over appropriate data
as parameters 5
Modular Concept - Problems
 Advantages

 Disadvantages
 Decoupled Data and Operations
 The resulting module structure is oriented on the
operations rather than the actual data
 The defined operations specify the data to be
used.
 E.g.: in previous example, …

6
 Object-Oriented Concept (C++)

 Objects of the program interact by sending ‘messages’ to each

other
7
Basic C++
 Inherit all C syntax
 Primitive data types
 Supported data types: int, long, short, float,
double, char, bool, and enum
 The size of data types is platform-dependent
 Basic expression syntax
 Defining the usual arithmetic and logical operations such
as +, -, /, %, *, &&, !, and ||
 Defining bit-wise operations, such as &, |, and ~
 Basic statement syntax
 If-else, for, while, and do-while

8
Basic C++ (cont)
 Add a new comment mark
 // For 1 line comment
 /*… */ for a group of line comment
 New data type
 Reference data type “&”. Much likes pointer
int ix; /* ix is "real" variable */
int & rx = ix; /* rx is "alias" for ix */
ix = 1; /* also rx == 1 */
rx = 2; /* also ix == 2 */
 const support for constant declaration, just likes C
 Use this when…

9
Class Definitions
 A C++ class consists of data members and methods (member
functions).

class IntCell Initializer list: used to initialize the data

{ Avoid implicit type conversion members directly.
public:
explicit IntCell( int initialValue = 0 )
: storedValue( initialValue ) {}

int read( ) const

Member functions
{ return storedValue;} Indicates that the member’s invocation does
void write( int x ) not change any of the data members.
{ storedValue = x; }
private:
int storedValue; Data member(s)
}

10
Information Hiding in C++
 Two labels: public and private
 Determine visibility of class members
 A member that is public may be accessed by any method in
any class
 A member that is private may only be accessed by methods
in its class
 Information hiding
 Data members are declared private, thus restricting access
to internal details of the class
 Methods intended for general use are made public

11
Constructors
 A constructor is a special method that describes how an
instance of the class (called object) is constructed
 Whenever an instance of the class is created, its
constructor is called.
 C++ provides a default constructor for each class, which
is a constructor with no parameters. But, one can define
multiple constructors for the same class, and may even
redefine the default constructor
 How to distinguish them?
 E.g. How to create IntCell with
 storedValue=10?

 storedValue=0?

 Hint: C++ has an operator “new”

12
 Destructor
 A destructor is called when an object is deleted either
implicitly, or explicitly (using the delete operation)
 The destructor is called whenever an object goes out of
scope or is subjected to a delete.
 Typically, the destructor is used to free up any resources
that were allocated during the use of the object
 C++ provides a default destructor for each class
 The default simply applies the destructor on each data
member. But we can redefine the destructor of a class. A C+
+ class can have only one destructor.
 One can redefine the destructor of a class.
 A C++ class can have only one destructor

13
 Pointers
 A pointer is a variable which
contains addresses of other
variables
 Accessing the data at the x
(4104)
contained address is called
“dereferencing a pointer” or y
“following a pointer” (4100) 4096

pointer n
(4096) 7

14
 A Pointer Example

Box diagram
Memory Layout
The code

void doubleIt(int x, main

int * p)
{ p 8192
a 16 (8200)
*p = 2 * x;
} doubleIt
int main(int argc, const x 9
char * argv[]) (8196)
{
int a = 16;
a 16 main
doubleIt (8192)
doubleIt(9, &a);
return 0;
} x 9

a gets 18 p
15
Interface and Implementation
 In C++ it is more common to separate the class
interface from its implementation.
 The interface lists the class and its members (data
and functions).
 The implementation provides implementations of
the functions.

16
 IntCell::IntCell( int
initialValue )
class IntCell
: storedValue ( initialValue )
{ { }
public:
explicit IntCell( int int IntCell::read( ) const
initialValue = 0 );
{ return storedValue; }
int read( ) const;
void write( int x );
void IntCell::write( )
private:
{ storedValue = x; }
int storedValue;
}
IntCell.h IntCell.cpp

The interface is typically placed in a file that ends with .h. The
member functions are defined as:
ReturnType FunctionName(parameterList);
The implementation file typically ends with .cpp, .cc, or .C. The
member functions are defined as follows:
ReturnType ClassName::FunctionName(parameterList)
{ …… } Scoping operator
17
Object Pointer Declaration
 Declaration
IntCell * p; //defines a pointer to an object of class
IntCell
• The * indicates that p is a pointer variable; it is allowed
to point at an IntCell object.
• The value of p is the address of the object that it
points at
• P is uninitialized at this point
• The use of uninitialized pointers typically crashes
programs

18
Dereferencing Pointers
 Dynamic object creation
p = new IntCell; p 8888 8888

In C++ new returns a pointer to the newly created object.

 Garbage collection
 C++ does not have garbage collection

 When an object that is allocated by new is no longer

referenced, the delete operation must be applied to the

object
delete p;

19
Dereferencing Pointers (cont)
 Using a pointer
We can get the value of the object pointed at by a pointer
either by using operator *, or by using operator ->
IntCell a;
int b;
……
a = *p; //variable a gets the value of object pointed at by p
b = p->read( ); //the value of the data member storedValue of
// the object pointed at by p is assigned to b

20
 Array Declaration
 An array is a collection of objects with same type stored
consecutively in memory
 Declaring an array
IntCell arr[10]; //an array consisting of 10 IntCell
objects
10 11 12 13 14 15 16 17 18 19
arr
• The size of the array must be known at compile time.
• arr actually is a constant pointer. The value of arr cannot be
changed.
IntCell * p = new IntCell[10];
arr = p; // invalid
•The (i+1)-st object in the array arr can be accessed either by
using arr[i], or by *(arr+i).
 There is no index range checking for arrays in C++
 Cannot be copied with =
 Arrays are not passed by copy. Instead, the address of the first
element is passed to the function
21
int sumOfArray( int values[], int numValues )
Strings
 Built-in C-style strings are implemented as an array of
characters.
 Each string ends with the special null-terminator ‘\0’.
 strcpy: used to copy strings
strcmp: used to compare strings
strlen: used to determine the length of strings
 Individual characters can be accessed by the array
indexing operator 10 11 12 13 14 15 16 17 18 19
f o o l \0 f o o l \0
char s1[] = s1 s2
“fool”; 50 51 52 53 54 55 56 57 58 59
a b c d e f g \0
char s2[] =
s
“fool”;
10 11 12 13 14 15 16 17 18 19
strcpy(s1, s); a b c d e f g \0 l \0
char
//copy s to s1 s1
s[]=“abcdefg”;
//(s1 must have enough size) 50 51 52 53 54 55 56 57 58 59
a b c d e f g \0
22
//including \0 s
Function Call by Value
int f(int x) { cout << “value of x = “ << x << endl;
x = 4; }
main() { int v = 5;
f(v);
cout << “value of v = “ << v << endl;}

Output: Value of x = 5
Value of v = 5
 When a variable v is passed by value to a
function f, its value is copied to the
corresponding variable x in f
 Any changes to the value of x does NOT affect
the value of v in the main program
 Call by value is the default mechanism for
parameter passing in C++
23
 Function Call by Reference
int f(int &x) { cout << “value of x = “ << x << endl;
x = 4; }
main() { int v = 5;
f(v);
cout << “value of v = “ << v << endl;}

Output: Value of x = 5
Value of v = 4
 When a variable v is passed by reference to a
parameter x of function f, v and the corresponding
parameter x refer to the same variable
 Any changes to the value of x DOES affect the
value of v
24
Function Call by Constant Reference
int f( const int &x ) { cout << “value of x = “ << x << endl;
x = 4; // invalid
}
main() { int v = 5;
f(v);
cout << “value of v = “ << v << endl;
}

 Passing variable v by constant reference to

parameter x of f will NOT allow any change to the
value of x.
 It is appropriate for passing large objects that
should not be changed by the called function.

25
 Usage of Parameter Passing
 Call by value is appropriate for small objects that
should not be changed by the function
 Call by constant reference is appropriate for large
objects that should not be changed by the function
 Call by reference is appropriate for all objects that
may be changed by the function

26
 Reference Variables
 A reference (or constant reference) variable serves as
an alternative name for an object.
int m = 10;
int & j = m;
cout <<“value of m = “ << m << endl; //value of m printed is
10
j = 18;
cout << “value of m = “ << m << endl; //value of m printed is
18

27
 Reference Variables (cont)
 A reference variable is different from a pointer
 A pointer need NOT be initialized while defining, but a

reference variable should always refer to some other

object.
int * p;
int m = 10;
int & j = m; //valid
int & k; //compilation error

28
 References (Summary)
References are an additional name to an
existing memory location

If we wanted something called “ref” to refer to a variable x:

Pointer: Reference:

x 9 x
9
ref

ref
29
 Pointer vs. Reference
 A pointer can be assigned a new value to point at a
different object, but a reference variable always refers to
the same object. Assigning a reference variable with a
new value actually changes the value of the referred
object.
int * p;
int m = 10;
int & j = m; //valid
p = &m; //p now points at m, “p=address of m”
int n = 12;
j = n; // the value of m is set to 12. But j still refers to m,
not to n.
cout << “value of m = “ << m <<endl; //value of m printed is 12
n = 36;
Cout << “value of j = “ << j << endl; //value of j printed is 12
p = &n;

Cout << “value of p=“ << *p << endl; // value of p=?

30
 Pointer vs. Reference (cont)
 A constant reference variable v refers to an object whose
value cannot be changed through v.
int m = 8;
const int & j = m;
m = 16; //valid
j = 20; //compilation error

31
 Return by reference

int & foo(int &b){ const int & foo(int &b){

return b; return b;
} }

main(){ main(){
int j; int j;
int a = 5; int a = 5;

j=foo(a); //j is 5 j=foo(a); //j is 5

j=3; // a is still 5 j=3; // a is still 5

foo(a) = 10; //a is now 10 foo(a)= 10; // invalid

} }

32
 A C++ Example
 point.h
class Point {
private:
int _x, _y; // point coordinates

public: // begin interface section

void setX(const int val);
void setY(const int val);
int getX() { return _x; }
int getY() { return _y; }
};

Point apoint;

33
Class and Objects
 point.cc, point.cpp

void Point::setX(const int val) {

_x = val;
}

void Point::setY(const int val) {

_y = val;
}

34
 Main program
 main.cc, main.cpp
int main(int argc, char* argv[]) {
Point apoint;

apoint.setX(1); // Initialization
apoint.setY(1);

//
// x is needed from here, hence, we define it
here and
// initialize it to the x-coordinate of apoint
//

int x = apoint.getX();
}

35
 Constructor and Destructor
class Point {
private :
int _x, _y;
public:
Point() {
_x = _y = 0;
}
Point(const int x, const int y);
Point(const Point &from);
~Point() {void}

void setX(const int val);

void setY(const int val);
int getX() { return _x; }
int getY() { return _y; }
};

36
 Constructor and Destructor
Point::Point(const int x, const int y) : _x(x), _y(y) {
}

Point::Point(const Point &from) {

_x = from._x;
_y = from._y;
}

Point::~Point(void) {
/* nothing to do */
}

37
Standard Input/Output Streams
 Stream is a sequence of characters
 Working with cin and cout
 Streams convert internal representations to
character streams
 >> input operator (extractor)
 << output operator (inserter)

38
Reading Data >>
 Leading white space skipped
 Newline character <nwln> also skipped
 Until first character is located
cin >> ch;
 Also read character plus white space as a
character
 get and put functions

39
CountChars.cpp
Program Output
Enter a line or press CTRL-Z: This is the first line.
This is the first line.
Number of characters in line 1 is 23
Enter a line or press CTRL-Z: This is the second line
.
This is the second line.
Number of characters in line 2 is 24
Enter a line or press CTRL-Z: <CTRL-Z>
Number of lines processed is 2
Total number of characters is 47

40
CountChars.cpp (Header)
// File: CountChars.cpp
// Counts the number of characters and lines in
// a file

#include <iostream>
#include <string>

using namespace std;

#define ENDFILE "CTRL-Z” //ENDFILE is a string

41
CountChars.cpp (Setup)
int main()
{
const char NWLN = '\n'; // newline character

char next;
int charCount;
int totalChars;
int lineCount;

lineCount = 0;
totalChars = 0;

cout << "Enter a line or press "

<< ENDFILE << ": ";

42
CountChars.cpp (Main Loop)
while (cin.get(next)) { // a new line, if user hits
^Z,
// cin.get returns 0
charCount = 0;
while (next != NWLN && !cin.eof()){
cout.put(next);
charCount++;
totalChars++;
cin.get(next);
} // end inner while to get a line
cout.put(NWLN);
lineCount++;
cout << "Number of characters in line "
<< lineCount << " is " << charCount << endl;
cout << "Enter a line or press " << ENDFILE << ": ";
} // end outer while

43
CountChars.cpp (Output)
cout << endl << endl
<< "Number of lines processed is "
<< lineCount << endl;
cout << "Total number of characters is "
<< totalChars << endl;
return 0;
}

44
File I/O
 Declare the stream to be processed:
#include <fstream>
ifstream ins; // input stream
ofstream outs; // output stream
 Need to open the files
ins.open(inFile);
outs.open(outFile);

45
Files
 #define associates the name of the stream
with the actual file name
 fail() function - returns nonzero if file fails
to open
 Program CopyFile.cpp demonstrates the use
of the other fstream functions
 get, put, close and eof
 Copy from one file to another

46
CopyFile.cpp
Program Output

Input file copied to output file.

37 lines copied.

47
CopyFile.cpp (Header)
// File: CopyFile.cpp
// Copies file InData.txt to file OutData.txt

#include <cstdlib>
#include <fstream>

using namespace std;

// Associate stream objects with external file

// names
#define inFile "InData.txt"
#define outFile "OutData.txt"

48
CopyFile.cpp (Declarations)
// Functions used ...
// Copies one line of text
int copyLine(ifstream&, ofstream&);

int main()
{

// Local data ...

int lineCount;
ifstream ins;
ofstream outs;

49
CopyFile.cpp (Opening Input File)
// Open input and output file, exit on any
// error.
ins.open(inFile);
if (ins.fail ())
{
cerr << "*** ERROR: Cannot open " <<
inFile << " for input." << endl;
return EXIT_FAILURE; // failure return
} // end if

50
CopyFile.cpp (Opening Output File)
outs.open(outFile);
if (outs.fail()) {
cerr << "*** ERROR: Cannot open " << outFile
<< " for output." << endl;
return EXIT_FAILURE; // failure return
} // end if

51
CopyFile.cpp (Copy Line by Line)
// Copy each character from inData to outData.
lineCount = 0;
do{
if (copyLine(ins, outs) != 0)
lineCount++;
} while (!ins.eof());
// Display a message on the screen.
cout << "Input file copied to output file."
<< endl;
cout << lineCount << " lines copied." << endl;
ins.close();
outs.close();
return 0; // successful return
}

52
CopyFile.cpp (copyLine procedure)
// Copy one line of text from one file to another
// Pre: ins is opened for input and outs for
// output.
// Post: Next line of ins is written to outs.
// The last character processed from
// ins is <nwln>;
// the last character written to outs
// is <nwln>.
// Returns: The number of characters copied.

53
CopyFile.cpp (Character Reading)
int copyLine (ifstream& ins, ofstream& outs){
// Local data ...
const char NWLN = '\n';
char nextCh;
int charCount = 0;

// Copy all data characters from stream ins to

// stream outs.
ins.get(nextCh);
while ((nextCh != NWLN) && !ins.eof()){
outs.put(nextCh);
charCount++;
ins.get (nextCh);
} // end while

54
CopyFile.cpp (Detection of EOF)
// If last character read was NWLN write it
// to outs.
if (!ins.eof())
{
outs.put(NWLN);
charCount++;
}
return charCount;
} // end copyLine

55