C cpluplus 2

Introduction to C++ Programming

Csci 169

Prof.A.Bellaachia

And

Anasse Bari

Agenda Session 1

1. A Historical Perspective of C++

2. Major Differences between C and C++

3. Basics of C++

Structure of a program

Variables and Data types

Constants

Operators

Basic Input / output

4. Control Structures

Structures

Functions

5. Compound Data Types

Arrays

Characters

Pointers

Dynamic Memory

6. C++ and Object Oriented Programming

Classes

Objects

Constructors

Overloaded Constructors

Destructor

Copy Constructor

Inheritance ( Public and Private)

Function Overloading

Operator Overloading

Access Control

Friendship

Virtual Functions

Polymorphism

C++ : Historical Perspective

• What is C++ ?

• Who invented C++ ?

• Who are the users of C++ ?

C and C++

• C is a Procedural Language :

“Decide which procedures you want; use the best algorithms you can find”

• C++ is an Object Oriented Language:

“Decide which modules you want; partition the program so that data is hidden within modules”

• C was chosen to be the base of C++ because:

1.C is versatile and terse

2.C is adequate for most systems programming tasks

3.C runs everywhere and on everything

Basics of C++

• Structure of a C++ program

• Variables and Data types

• Constants

• Operators

• Basic Input / output

Our First C++ Program// my first program in C++

#include <iostream.h>

Using namespace std;

int main ()

{

cout << “Hello Cs169 / Fall 2009 Students“;

return 0;

}

7

Structure of a C++ Program

/* greeting.cpp greets its user.** Input: The name of the user* Output: A personalized greeting*********************************************************/#include <iostream> // cin, cout, <<, >>#include <string> // stringusing namespace std;int main(){cout << "Please enter your first name: ";string firstName;cin >> firstName;cout << "\nWelcome to the world of C++, " << firstName << "!\n";}

Comment

Compilerdirectives

Specifies standard related names

Main portion of program.

Contains C++ statements.

Variables and Data Types

• Variable : a portion of memory to store a determined value.

• How to distinguish variables ? Identifiers

• Identifiers:

– Combination of letters, digits, and underscores

– Variable names should start with letter or digit

• Important : C++ is a “case sensitive” language

Fundamental DataTypes

More on Variables

• Declaration – – int number1;– float number2;

• Initialization –– int number1 = 0;– int number2 = 3.3;

• Assignment-– number1=5;– number2=number1;

Scope of Variables

• Global Variables – variables that are declared above main() can be accessed anywhere after the declaration

• Local Variables – variables declared in section of code {}. Only accessible in that region.

Scope of Variables

Initialization of Variables

Two possibilities:

• type identifier = initial_value ;

• type identifier (initial_value) ;

Initialization of Variables// initialization of variables

#include <iostream.h>

Using namespace std;

int main ()

{

int x=5;

int y(2);

int result;

x = x + 3;

result = x - y

cout << result;

return 0;

}

Characters and Strings

• ‘X’ is a character• “hello Cs169-Fall2009” is a string• C++ library provides support for strings : string class

string mystring = "This is a string"; string mystring ("This is a string");

Strings Example

// my first string

#include <iostream>

#include <string>

using namespace std;

int main () {

string mystring;

mystring = “Hello Cs169, Fall 2009";

cout << mystring << endl;

mystring = “Hello Cs169, I wish you a great semester";

cout << mystring << endl;

return 0;

}

.

Defined Constants

• #define identifier value

#define PI 3.14159265 Example: Write a program that calculates the area and

circumference of a Circle of Radius 10.

Declared Constants (const)

• Use the “const” prefix you can declare constant with specific type

Examples:

– const int radius = 100;

– const char tabulator = '\t';

Arithmetic OperatorsAssignment Operator ( = ) // assignment operator

#include <iostream>


int main ()

{

int a, b; // a:?, b:?

a = 10; // a:10, b:?

b = 4; // a:10, b:4

a = b; // a:4, b:4

b = 7; // a:4, b:7

cout << "a:";

cout << a;

cout << " b:";

cout << b;

return 0;

}

Arithmetic Operators Compound assignment

Increment & Decrement ( ++,--)

Relational and equality operators ( ==, !=, >, <, >=, <= )

Arithmetic Operators Logical Operators ( !, &&, || )

Arithmetic Operators

• + addition

• - subraction

• * multiplication

• / division

• % modulo or remainder

Basic C++ I/O• “iostream” C++ library• Cout

cout << “Hello Cs169”; //Print Hello Cs169

cout << 120; // Print 120 on the screen

cout << x; // print the content of x in the screen• Cin

int age;

cin >> age;

cout << age

cin >> a >> b; is equivalent to cin>>a; cin>>b;

Agenda Session 1



3. Basics of C++



Constants

Operators



Structures

Functions


Arrays

Characters

Pointers

Dynamic Memory


Classes

Friendship and Inheritance

Polymorphism

Control structures

• if (cond) state1 else if (cond2) state2 else state3• while (expression) statement• do statement while (cond)• for (init; cond; increment) statement;

Control structuresExample

Control structuresExample

Switch Statement

switch (x) { \

case 1:

cout << "x is 1";

break;

case 2:

cout << "x is 2";

break;

default:

cout << "value of x unknown";

}

Functions

• We can use functions to achieve structured programmingInt add(int a, int b){

a = a+b; return (a);

}

• ‘int’ is the return type, ‘a’ and ‘b’ are arguments• When we call the function we must pass it

parameters matching the arguments

FunctionsExample

Passing Parameters

• Call By Value– This is what we usually do, we pass a function

the value of a variable

• Call By Reference– Instead of the value we will pass a pointer to

the variable. If we modify the passed variable the change will be seen by the caller

– We use ‘&parm’ to show that we are passing the variable at the memory location of parm

Agenda Session 1



3. Basics of C++



Constants

Operators



Structures

Functions


Arrays

Characters

Pointers

Dynamic Memory


Classes

Friendship and Inheritance

Polymorphism

Arrays

• An Array is a set of elements of the same type located in contiguous memory locations.

• An Array can be referenced using index

Arrays

• Intialization– int numbers[5]={0,1,2,3,4,};

• Accessing– num2 =numbers[1];– numbers[0]=99;

• Passing arrays as parameters– Declaration: int add(int numarray[])– Call:

int array[]={1,2,3};add(array);

ArraysExample

Pointers

• We used pointers in call by reference

• A reference of a variable is the address that locates a variable in Memory

• Pointer are Valuable in implementing data structures

Address Operator (&)

• The ‘&’ operator returns the ‘address of’ its operand.

• ‘&’ can be translated ‘address of’

Dereference Operator (*)(*) “Values pointed by”

• Notice the difference:

& is the reference operator and can be read as "address of"

* is the dereference operator and can be read as "value pointed by”

PointersExample

Sizeof()

• The Sizeof() function is used to determine how many bytes of a data type during compilation.

• Ex:sizeof(float) equals 4

float array[10];

sizeof(array) equals 4*10 which is40

Dynamic Memory

• Dynamic Memory allows us to determine and allocate memory to variables and data structures at ‘run time’.

• C++ uses new and delete;– pointer = new type;

• New returns a pointer to the allocated memory

– delete pointer;• Frees up the memory that was allocated

Dynamic MemoryExample

Structs

• Similar to records in Ada.struct person_t{

char fname[20];char lname[20];int age;

}person1, person2;

• Here we are declaring person1 and person2 as type person_t.

• By convention we use the _t

Accessing the struct members

• We use the ‘.’ to access members of a structcout << person1.fname;

person1.fname=“John”;

StructsExample

Pointers to Structs

• We can point to a struct like other structures.Person_t* person1Ptr;

person1Ptr = &person1;

• We can no longer use the ‘.’ to access the members in the struct we are pointing to.– The ‘->’ is used

Cout << person1Ptr->fname;

– Element fname of structed pointed by person1Ptr

– Same as *(person1Ptr.fname);

Agenda Session 1



3. Basics of C++



Constants

Operators



Structures

Functions


Arrays

Characters

Pointers

Dynamic Memory


Classes

Objects

Constructors

Overloaded Constructors

Destructor

Copy Constructor

Inheritance ( Public and Private)



Access Control

Friendship

Polymorphism

C++ Classes

• A Class is User-defined type

• An Object is an instance of a Class

• A Class has : – Members Variables

– Member Functions

– Constructor

– Destructor

C++ ClassesExample

Constructors

• A Constructor is a member function that initializes an Object of a Class

• A Constructor has the same name as the class it belongs to

• A Constructor can be overloaded

• The compiler select the correct one for each use

Good Practices:

• Always define a constructor and always initialize all data members

• If you do not create a constructor one is automatically defined (not recommended

• Warning: attempting to initialize a data member of a class explicitly without using a constructors is a syntax error.

.

ConstructorsExample

Class Date {

int d,m,y

Public:

//…

Date(int,int,int) //day,month, year

Date(int,int) //day, month, today’s year

Date(int) //day, today’s month and year

Date(); //default Date

Date(char*) // date in string representation

}

Date today(4);

Date july4(“july 4,1983)

Date guy(“5 nov”)

Date now;

Destructors• It is a member function which deletes an object.• A destructor function is called automatically when the

object goes out of scope: (1) the function ends (2) the program ends (3) a block containing temporary variables ends (4) a delete operator is called

• A destructor has: (i) the same name as the class but is preceded by a tilde

(~) (ii) no arguments and return no values

Destructors

• It is a member function which deletes an object.• A destructor function is called automatically when the

object goes out of scope. e.g. a block containing temporary variables ends

• A destructor has the same name as the class but is preceded by a tilde (~)

• A Destructor has no arguments and return no values

DestructorsExample

class mystring { private: char *str; int s; //size public: mystring(char *); // constructor ~mystring(); // destructor}; mystring::mystring(char *c){ size = strlen(c); str = new char[s+1]; strcpy(s,c);} mystring::~mystring(){ delete []str;}

Copy Constructor

• A member function which initializes an object using another object of the same class.

• Copy constructor prototype

myclass (const myname&);

class myrectangle { private: float height; float width; int x; int y; public: rectangle(float, float); // constructor rectangle(const myrectangle&); // copy constructor void draw(); // draw member function void posn(int, int); // position member function void move(int, int); // move member function};

Copy ConstructorExample

Importance of a copy constructors

• In the absence of a copy constructor, the C++ compiler builds a default copy constructor for each class which is doing a memberwise copy between objects.

• Default copy constructors work fine unless the class contains pointer data members ... why???

#include <iostream.h>#include <string.h> class mystring { private: char *s; int size; public: mystring(char *); // constructor ~mystring(); // destructor void print(); void copy(char *);}; void mystring::print(){ cout << s << endl;}

void string::copy(char *c)

{

strcpy(s, c);

}

void main()

{

string str1("George");

string str2 = str1; // default copy constructor

str1.print(); // what is printed ?

str2.print();

str2.copy("Mary");

str1.print(); // what is printed now ?

str2.print();

}

Defining a copy constructor

class mystring {

private:

char *s;

int size;

public:

mystring(char *); // constructor

~mystring(); // destructor

string(const mystring&); // copy constructor

void print();

void copy(char *);

};

string::string(const string& old_str){ size = old_str.size; s = new char[size+1]; strcpy(s,old_str.s);}

void main(){ string str1("George"); string str2 = str1;

str1.print(); // what is printed ? str2.print();

str2.copy("Mary");

str1.print(); // what is printed now ? str2.print(); }

-- same results can be obtained by overloading the assignment operator.

Inheritance• Objects are often defined in terms of hierarchical

classes with a base class and one or more levels of classes that inherit from the classes that are above it in the hierarchy.

• For instance, graphics objects might be defined as follows:

Inheritance

• This hierarchy could, of course, be continued for more levels.

• Each level inherits the attributes of the above level. Shape is the base class. 2-D and 3-D are derived from Shape and Circle, Square, and Triangle are derived from 2-D. Similarly, Sphere, Cube, and Tetrahedron are derived from 3-D.

Inheritanceclass A : base class access specifier B

{

member access specifier(s):

...

member data and member function(s);

...

}

Valid access specifiers include public, private, and protected

Public Inheritance

public base class (B)

public members

protected members

private members

derived class (A)

public

protected

inherited but not accessible

class A : public B{ // Class A now inherits the members of Class

B// with no change in the “access specifier” for

} // the inherited members

Private Inheritance

private base class (B)

public members

protected members

private members

derived class (A)

private

private

inherited but not accessible

class A : private B{ // Class A now inherits the members of Class

B// with public and protected members

} // “promoted” to private

Lect 28 P. 67 Winter Quarter

Inheritance (continued)class Shape {

public:int GetColor ( ) ;

protected: // so derived classes can access itint color;

};class Two_D : public Shape{

// put members specific to 2D shapes here};class Three_D : public Shape{

// put members specific to 3D shapes here};

Inheritance (continued)class Square : public Two_D{

public:float getArea ( ) ;

protected:float edge_length;

} ;class Cube : public Three_D{

public:float getVolume ( ) ;

protected:float edge_length;

} ;

Inheritanceint main ( )

{

Square mySquare;

Cube myCube;

mySquare.getColor ( ); // Square inherits getColor()

mySquare.getArea ( );

myCube.getColor ( ); // Cube inherits getColor()

myCube.getVolume ( );

}


• C++ supports writing more than one function with the same name but different argument lists. This could include:– different data types– different number of arguments

• The advantage is that the same apparent function can be called to perform similar but different tasks. The following will show an example of this.

Function Overloadingvoid swap (int *a, int *b) ;

void swap (float *c, float *d) ;

void swap (char *p, char *q) ;

int main ( )

{

int a = 4, b = 6 ;

float c = 16.7, d = -7.89 ;

char p = 'M' , q = 'n' ;

swap (&a, &b) ;

swap (&c, &d) ;

swap (&p, &q) ;

}


void swap (int *a, int *b)

{ int temp; temp = *a; *a = *b; *b = temp; }

void swap (float *c, float *d)

{ float temp; temp = *c; *c = *d; *d = temp; }

void swap (char *p, char *q)

{ char temp; temp = *p; *p = *q; *q = temp; }

Operator Overloading • C++ already has a number of types (e.g., int, float, char,

etc.) that each have a number of built in operators. For example, a float can be added to another float and stored in yet another float with use of the + and = operators:

floatC = floatA + floatB;

• In this statement, floatB is passed to floatA by way of the + operator. The + operator from floatA then generates another float that is passed to floatC via the = operator. That new float is then stored in floatC by some method outlined in the = function.


• Operator overloading means that the operators:

– Have multiple definitions that are distinguished by the types of their parameters, and

– When the operator is used, the C++ compiler uses the types of the operands to determine which definition should be used.

Operator Overloading (continued)

• A programmer has the ability to re-define or change how the operators (+, -, *, /, =, <<, >>, etc.) work on their own classes.

• Overloading operators usually consists of defining a class member function called operator+ (where + is any operator). Note that operator is a reserved word in C++. If anything usually follows that operator, it is passed to the function. That function acts exactly like any other member function; it has the same scope as other member functions and can return a value just like any other member function.


Steps for defining an overloaded operator:

1. Name the operator being overloaded. 2. Specify the (new) types of parameters (operands) the

operator is to receive. 3. Specify the type of value returned by the operator. 4. Specify what action the operator is to perform.

Friendship

• A friend function of a class is defined outside the class’s scope (I.e. not member functions), yet has the right to access the non-public members of the class.

• Single functions or entire classes may be declared as friends of a class.

• These are commonly used in operator overloading. Perhaps the most common use of friend functions is overloading << and >> for I/O.

Friends

• Basically, when you declare something as a friend, you give it access to your private data members.

• This is useful for a lot of things – for very interrelated classes, it more efficient (faster) than using tons of get/set member function calls, and they increase encapsulation by allowing more freedom is design options.

Friends

• A class doesn't control the scope of friend functions so friend function declarations are usually written at the beginning of a .h file. Public and private don't apply to them.

Friends

• Friendship is not inherited, transitive, or reciprocal.– Derived classes don’t receive the privileges of friendship (more on

this when we get to inheritance in a few classes)

– The privileges of friendship aren’t transitive. If class A declares class B as a friend, and class B declares class C as a friend, class C doesn’t necessarily have any special access rights to class A.

– If class A declares class B as a friend (so class B can see class A’s private members), class A is not automatically a friend of class B (so class A cannot necessarily see the private data members of class B).

FriendsExample

82

Polymorphism Compile-Time Binding vs.

Run-Time Binding

• A function’s name is associated with an entry point, the starting address of the code that implements the function

• Compile-time binding lets the compiler determines what code is to be executed when a function name is invoked

• Run-time binding is the binding of a function’s name to an entry point when the program is running

83

Compile-Time Binding#include <iostream>


void sayHi();

int main() {

sayHi();

return 0;

}

void sayHi() {

cout <<"Hello, cruel world!"<< endl;

}

84

Requirements for C++ Polymorphism

• There must be an inheritance hierarchy

• The classes in the hierarchy must have a virtual method with the same signature

• There must be either a pointer or a reference to a base class. The pointer or reference is used to invoke a virtual method

85

PolymorphismExample

Engineering

C cpluplus 2