The C++ Language

C Evolves into C++ Object Oriented Programming

Classes and Objects Operator Overloading Inheritance Polymorphism Template classes
CS 103 1

C Evolves into C++

CS 103

C is Alive in C++
C++ is a superset of C. Any correct C program is also a correct C++ program, except for some loopholes in C that are not allowed in C++.

CS 103

What is still the same

The syntax of statements
if-else, switch, the ?: conditional for/while/do-while loops assignments arithmetic/logic/relational/ bitwise expressions declarations, struct/union/enum types, typedef pointers, arrays, casting

Same preprocessor commands in C &C++.

CS 103 4

C++: A Better C
Convenient syntax for inline comments: // Declaration anywhere Function overloading Default arguments Simplified IO: cin >>, cout<<, and more A new Boolean data type: bool Easier dynamic memory allocation: new & delete References (automatically dereferenced pointers) Function templates: data types as parameters Tag names as new data types Better type system: tighter use of void *
CS 103 5

Convenient Syntax for Inline Comments

Anything from // to the end of line is considered a comment and thus ignored by the compiler.
int i; // i is an integer that will index the next array double x[10]; // an array that will store user input // and will then be sorted.

The C-syntax for comments, /* */, can still be used for multi-tine comments.
CS 103 6

Declaration Anywhere
Declarations need no longer be at the head of blocks. Variables and functions can be declared any time, anywhere in a program, preferably as close to where a variable is used the first time. For example: note i is declared within for for (int i=0;i<n;i++)
CS 103 7

Function Overloading
In C++, two or more functions can share the same name as long as their parameter declarations are different. In this situation, the functions that share the same name are said to be overloaded, and the process is referred to as function overloading Two or more functions can have the same name but different parameters Example:

int max(int a, int b) { if (a>= b) return a; else return b; }

float max(float a, float b) { if (a>= b) return a; else return b; }

CPP 8

Default Arguments
A default argument is a value given in the function declaration that the compiler automatically inserts if the caller does not provide a value for that argument in the function call. Syntax:
return_type f(, type x = default_value,);
CS 103 9

Default Arguments (Examples)

double pow(double x, int n=2) // computes and returns xn

The default value of the 2nd argument is 2. This means that if the programmer calls pow(x), the compiler will replace that call with pow(x,2), returning x2
CS 103 10

Default Arguments (Rules)

Once an argument has a default value, all the arguments after it must have default values. Once an argument is defaulted in a function call, all the remaining arguments must be defaulted.
int f(int x, int y=0, int n) // illegal int f(int x, int y=0, int n=1) // legal
CS 103 11

Examples of Legal/Illegal Defaulting in Function Calls

Let substring be a function whose prototype is: char * substring (char *p, int length=10, int pos=0)
Assume char *p=hello; Which call to substring is OK and which is not OK? If OK, what is it equivalent to?
substring(p) substring(p,10) substring( )
CS 103 12

Default Arguments and Function Overloading

Default arguments and function overloading can give rise to an ambiguity Consider an overloaded function f where one declaration has default arguments that, if removed, makes the function look identical to a second declaration, as in
1. int f(int x, int y=0); returns 2. int f(int x); // returns 2x
CS 103

xy

If we call f(2), is it to f in (1) or (2)? The 1st returns 1. The 2nd returns 4.
13

Default Arguments and Function Overloading (Contd.)

If overloaded declarations of a function with default arguments cause ambiguity, the compiler gives an error message. It is the responsibility of the programmer not to cause such ambiguities.

CS 103

14

Example of Function Overloading and Default Args

// Precondition: x[] is a double array of length n. // n is a positive integer. If missing, it defaults to 10 // Postcondition: the output is the maximum in x[] double max(double x[], int n=10){ double M = x[0]; // M is the maximum so far for (int i=1;i<n;i++) if (x[i]>M) M=x[i]; return M; }
CS 103 15

Overloading & Defaulting Example (Contd.)

// Precondition: x[] is an int array of length n. // n is a positive integer. If missing, it defaults to 10 // Postcondition: the output is the maximum in x[] int max(int x[], int n=10){ int M = x[0]; // M is the maximum so far for (int i=1;i<n;i++) if (x[i]>M) M=x[i]; return M; }
CS 103 16

Simplified IO
Instead of the complicated syntax of printf and scanf, and the many variations of print and scan, C++ offers a much simpler syntax For standard output, use cout For standard input, use cin File IO is also simpler, and will be discussed later Note: one can still use the IO syntax of C in C++

CS 103

17

Cout
For printing output, use this syntax:
cout << a string or an expression;

This prints out the string or the value of the extpression. For output chaining, use this syntax
cout << S1 <<S2<<S3<<endl;

Each Si is a string or an expression. The effect is to print out the value of S1 followed by the value of S2, followed by the value of S3.
CS 103 18

Cout (Contd.)
The reserved word, endl, ensures that the next cout command prints its stuff on a new line. New lines can also be added using \n.

CS 103

19

Cout (Examples)
Statements
int x=3; double y =4.5; cout <<the value of x=<<x; cout<<; y=<<y<<endl; cout <<x+y<<x+y; int x=3; double y =4.5; cout <<x = <<x<<\n; cout<<y=<<y; cout <<\nx+y<<x+y;
CS 103

Output
the value of x=3; y=4.5

x+y=7.5
x=3 y=4.5 x+y=7.5
20

Cin
For reading input values into variables:
cin >> variableName1 >> variableName2 >> variableName3;

This reads the input from the standard input (say the screen for now), puts the first read value in variableName1, the second read value in variableName2, and the third read value in variableName3.
CS 103 21

Cin (Examples)
Suppose you want to read an int value and a double value into variables n and x. This code will do it (see next slide):
int n; double x; cout<<enter an int, a space, and a double: ;
cin>>n>>x; // use of cin cout<<You entered int n=<<n; cout<<, and double x=<<x<<endl;
CS 103 22

 If you run that code, you first get:

Enter an int, a space, and a double:

Lets say, you enter: -3 9.8

Enter an int, a space, and a double: -3 9.8

The code next will store 3 in n, and 9.8 in x, and print out to you:
You entered int n=-3, and double y=9.8

CS 103

23

A new Boolean data type:

bool
A bool variable is a variable that can have only two values: true or false. C does not have Boolean values or variables Instead, any non-zero was considered the equivalent of true , and 0 the equivalent of false.

CS 103

24

Example of bool
// Precondition: x[] is an integer array of length n. // n is a positive integer. // Postcondition: The output is true if the elements // of the input array are all positive,. Else, false. bool isAllPositive(int x[], int n){ for(int i=0;i<n;i++) if (x[i] <= 0) return false; return true; }
CS 103 25

Easier Dynamic Memory Allocation: new & delete

new corresponds to malloc/calloc in C delete corresponds to free in C The syntax of new has forms:
type *pointer = new type; // type is a built-in // or user-defined data type. type *pointer = new type[n]; // type as above The semantics of this syntax is explained next
CS 103 26

Semantics of new
For type *pointer = new type; :
The system allocates dynamically (during execution) a chunk of memory large enough to hold data of the specified type, and returns a pointer pointing to the address of that chunk. This pointer is stored in the user-provided pointer-variable pointer.

CS 103

27

Semantics of new [n]

For type *pointer = new type[n]; :
The system allocates dynamically an array of n memory chunks, each large enough to hold data of the specified type, and returns a pointer pointing to the address of that chunk. The difference between this type of arrays (called dynamic arrays) and conventional arrays is that the size of the latter is constant while the size of the former can vary.
CS 103 28

Example of new
// Precondition: n is a positive integer // Postcondition: computes and prints out the first n // elements of the Fibonacci sequence void fibonacci(int n){ int *x = new int [n]; // creation of a dynamic array x[0]=1; x[1]=1; for (int i=2;i<n;i++) x[i]=x[i-1]+x[i-2]; cout<<"The Fibonacci sequence of "<<n<<" values are:\n"; for (int i=0;i<n;i++) cout<<"x["<<i<<"]="<<x[i]<<endl; }
CS 103 29

Syntax and Semantics of delete

The syntax of delete has two forms: delete pointer ; delete [] pointer ;
The first releases the memory of the single memory chunk pointed to by pointer The second releases the memory allocated to the array pointed to by pointer.
CS 103 30

References
A reference is an autmatically dereferenced pointer Syntax of reference declaration:
Type& refname = variable;

Semantics: refname becomes another name (or alias) for variable. Any change to the value of variable causes the same change to refname, and vice versa.
CS 103 31

Illustration of References
Statements
int x=17; int& xref = x; cout<<x=<<x<<endl; cout<<xref=<<xref<<endl; x=x+5; cout<<x=<<x<<endl; cout<<xref=<<xref<<endl; xref = xref-10; cout<<x=<<x<<endl; cout<<xref=<<xref<<endl;

Outcome

x=17 xref=17
x=22 xref=22

x=12 xref=12
32

CS 103

References and Function Call by Reference

void swap(int x, int y){ int tmp=x; x=y; y=tmp; } void swap(int& x, int& y){ int tmp=x; x=y; y=tmp; }

int x=5; int y=10; swap(x,y); cout<<x<<, <<y; Outcome: 5, 10 // no swap

int x=5; int y=10; swap(x,y); cout<<x<<, <<y; Outcome: 10, 5 // it did swap
CS 103 33

Templates of Functions (Motivation)

Functions are a great construct because they all the programmer to specify fairly generic parameters (variable arguments), and later call a function multiple times with different argument values, thus saving on programming effort It will be equally convenient and effort-saving if one can specify generic types that can be substituted with any actual type whenever a function is called
CS 103 34

Templates of Functions (Purpose and Syntax)

Templates provide that great convenience They make the data type/types of function arguments and of the return value to be programmable Syntax for declaring template function: template<class type> function_declaration; -Ortemplate<typename type> function_declaration;
CS 103 35

Templates of Functions (Example)

// Precondition: x[] is an array of length n, of // a generic type. n is a positive integer. // Postcondition: the output is the minimum in x[] template<typename T> T min(T x[], int n){ T m = x[0]; // M is the minimum so far for (int i=1;i<n;i++) if (x[i]<m) m=x[i]; return m; }
CS 103 36

How to Call a Function Template

The syntax of calling a function template:
functionName<an-actual-type>(parameter-list);

Example:
int x[]={11, 13, 5, 7, 4, 10}; double y[]={4.5, 7.13, 3, 17}; int minx = min<int>(x,6); double miny=min<double>(y,4); cout<<the minimum of array x is: <<minx<<endl; cout<<the minimum of array y is: <<miny<<endl;
CS 103 37

Templates with More than One Generic Type

Templates can have several generic types Syntax for their declaration:
template<class type1,class type2> funct_decl; class can be replaced by typename.

CS 103

38