introduction to c++. overview enhanced c. oop & classes. inheritance

56
Introduction to C++ Introduction to C++

Post on 21-Dec-2015

228 views

Category:

Documents


0 download

TRANSCRIPT

Page 1: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Introduction to C++Introduction to C++

Page 2: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

OverviewOverview

• Enhanced C.• OOP & classes.• Inheritance.

Page 3: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Enhanced CEnhanced C

• Includes C and more.• Compilation using g++.• Has a standard library for

added functionality.

Page 4: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Overloaded function namesOverloaded function names

• Using the same name for operations on different types is called overloading.

int max(int, int);double max(double, double);long max(long, long);

Page 5: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Overloaded function namesOverloaded function names

• Finding the right version to call from a set of overloaded functions is done by looking for a best match between the type of the argument expression and the parameters of the functions:

1. Exact match2. Match using promotions:

bool,char,short to int; float to double.

3. Match using standard conversions:int to double, double to int

Page 6: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Overloaded function namesOverloaded function names

void print(char);

void print(int);

void h(char c, int i, short s, double d)

{

print(c); // exact match: invoke print(char)

print(i); // exact match: invoke print(int)

print(s); // promotion: invoke print(int)

print(d); // conversion: double to int

}

Page 7: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Default argumentsDefault arguments

• A general function often needs more arguments than are necessary to handle simple cases.

• For example, giving the user an option of what base to print in seems reasonable, but in most programs integers will be printed as decimal integer values.

Page 8: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Default argumentsDefault arguments

void print(int value, int base=10);void f(){print(31); // produce output 31print(31, 16); // 1fprint(31, 2); // 11111print(); // errorprint(31,5,6); // error

}

• Default values may be provided for trailing arguments only.

Page 9: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

OutputOutput

• The iostream library defines output for every built-in type. Values output to cout are converted to a sequence of characters.

void f(int i){cout << “the value of i is ";cout << i;cout << ‘\n’;

}

Page 10: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

OutputOutput

• The result of an output expression can itself be used for further output.

void f(int i){cout << “the value of i is “ << i << endl;

}

• Equivalent to previous function.

Page 11: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

InputInput

void f(){int i;cin >> i; // read an integer into i

}

Page 12: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

new and deletenew and delete

struct S {// ..

};

S* f() { S* p = new S;return p;

}void g(S* p) { delete p; }

int *q = new int[20];delete [] q;

• The new operator creates an object, and it exists until destroyed by the delete operator.

Page 13: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Inline functionInline function

• A direction for the compiler to generate code for a call inline.

C macro

#define max(a,b) (((a) > (b) ? (a) : (b))

C++ inline function

inline int max(int a, int b) {return a>b ? a : b ;}

Page 14: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

ReferenceReference

• A reference is an alternative name for an object. The notation X& means reference to X. A reference must be initialized.

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

}

Page 15: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Argument passingArgument passing

void f(int val, int& ref){val++;ref++;

}

• When f() is called, val++ increments a local copy of the 1st argument, whereas ref++ increments the 2nd argument.

Page 16: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Argument passingArgument passing

void g(){int i = 1;int j = 1;f(i, j); // increments j but not i

}

• The 1st argument, i, is passed by value, the 2nd argument, j, is passed by reference.

Page 17: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Argument passingArgument passing

• It can be more efficient to pass a large object by reference than to pass it by value.

• Declaring an argument const does not enable the called function to change the object value.

void f(const Large& arg){// the value of arg cannot be changed

}

Page 18: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Example codeExample code#include <iostream>using namespace std;

const double m_to_k = 1.609; // miles to kilometersinline int convert(int mi) { return (mi * m_to_k); }

int main(){

int miles;do {

cout << "Input distance in miles: ";cin >> miles;cout << "\nDistance is " << convert(miles) << "

km." << endl; }

while (miles > 0); return 0;}

Page 19: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Object Oriented ProgrammingObject Oriented Programming

• Encapsulation of a set of data types and their operations: the class construct.

• Data hiding.• Data type hierarchy & code reuse

via inheritance: deriving a new class from an existing one.

• Design is crucial!

Page 20: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

ClassesClasses

• A class is a user-defined type, which allows encapsulation.

• The construct

class X { ... };

is a class definition.• Contains data and function members.• Access control mechanisms (private

vs. public – see below).

Page 21: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Class example 1Class example 1

class Point {private:

int x, y, visible; // private part // can be used only by member functions

public: // public part, interfacevoid setpoint(int xx, int yy) { x=xx; y=yy; visible = 1; }int getx() { return x; }int gety() { return y; }void draw() {

gotoxy(x,y);putchar('*');visible = 1;

}void hide() {

gotoxy(x,y);putchar(' ');visible = 0;

}// member functions defined within the class definition,

}; // rather than simply declared there are inline.

Page 22: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Class example 1Class example 1

Point p1, p2;p1.init(10,20);p1.show();p2.init(15,15);p2.show();p1.hide();

Page 23: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Member functionsMember functions

• A member function declaration specifies:

1. The function can access the private part of the class declaration.

2. The function is in the scope of the class.

3. The function must be invoked on an object.

• In a member function, member names can be used without explicit reference to an object.

Page 24: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Class example 2Class example 2class Array {private:

int *parray;int size;

public:void init();int get(int indx);void print();void set(int indx, int value);

};// :: is the scope resolution operatorvoid Array::init(){ parray = 0; size = 0; }int Array::get(int i) { return parray[i]; }void Array::print(){

for (int i = 0; i < size; i++)cout << endl << “array[“ << i << “]=“ << parray[i];

}

Page 25: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Class example 2Class example 2void Array::set(int indx, int value){

if (indx > size) { int *p = new int[indx+1]; for (int i = 0; i < size; i++)

p[i] = parray[i]; delete [] parray; size = indx; parray = p;

} parray[indx] = value;}

Array a1;a1.init();a1.set(3,50);a1.set(1,100);a1.set(2,70);a1.print();

Page 26: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

ConstructorsConstructors

• Using functions such as init() to initialize class objects is error prone and complicates the code.

• Constructors are member functions with the explicit purpose of constructing values of a given type, recognized by having the same name as the class itself.

Page 27: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

DestructorsDestructors

• A constructor initializes an object, creating the environment in which the member functions operate. This may involve acquiring a resource such as a file, lock, and usually memory, that must be released after use.

• Destructor is a function that is guaranteed to be invoked when an object is destroyed, cleans up and releases resources.

Page 28: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Constructors and destructorsConstructors and destructors

class Array {Array(); // default constructorArray(int); // constructor~Array(); // destructor

};

Array::Array() {parray = 0;size = 0;

}Array::Array(int len) {

parray = new int[len];size = len;

}Array::~Array() {

delete [] parray;}

Page 29: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

ConstructorsConstructors

Array a;Array b(10);

Page 30: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Constructors and destructorsConstructors and destructors

class String {char *str; //private data

public:String() { str = new char[1]; str[0] = 0; }String(const char *s);~String();int length();

}String::String(const char *s) {

str = new char[strlen(s)+1];strcpy(str, s); // destination, source

}String::~String() { delete str; }

Page 31: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Copy constructorCopy constructor• If x is an object of class X, “X y=x;” (or,

equivalently “X y(x);”) by default means member-wise copy of x into y. This can cause undesired effects when used on objects of a class with pointer members.

• The programmer can define a suitable meaning for copy operations by a copy constructor (and similarly for the assignment op.)

Table::Table(const Table& t) {p = new Name[size = t.size];for (int i = 0; i < size; i++) p[i] = t.p[i];

}String::String(const String &s) {

str = new char[s.length()+1];strcpy(str, s);

}

Page 32: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Self-reference, thisSelf-reference, this

• Each (non-static) member function knows what object it was invoked for and can explicitly refer to it.

• Implicitly declared as: X *const this;• Used to return the object or to manipulate

a self-referential data structure.

Date& Date::set_date(int dd, int mm, int yy){

d = dd;m = mm;y = yy;return *this; // enables cascading

}

d.set_date( 20, 1, 2000 ).print();

Page 33: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

FriendsFriends

• A friend function declaration specifies: the function can access the private part of the class declaration.

• Useful for object output (see below).

Page 34: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Friends exampleFriends exampleclass Vector {

int v[4];public:

Vector() { v[0] = v[1] = v[2] = v[3] = 0; }int& elem(int i) { return v[i]; }

};class Matrix {

Vector v[4];public:

int& elem(int i, int j) { return v[i].elem(j); }};// multiply cannot be a member of both Matrix and VectorVector multiply(const Matrix & m, const Vector & v) {

Vector r;for (int i = 0; i < 4; i++)

for(int j = 0; j < 4; j++)r.elem(i) += m.elem(i,j) * v.elem(j);

return r;};

Page 35: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Friends exampleFriends exampleclass Matrix;class Vector {

int v[4];public:

Vector(){ v[0] = v[1] = v[2] = v[3] = 0; }int& elem(int i) { return v[i]; }friend Vector multiply(const Matrix &, const Vector &);

};class Matrix {

Vector v[4];public:

int& elem(int i, int j) { return v[i].elem(j); }friend Vector multiply(const Matrix &, const Vector &);

};// multiply can be a friend of both Matrix and VectorVector multiply(const Matrix & m, const Vector & v) {

Vector r;for (int i = 0; i < 4; i++)

for(int j = 0; j < 4; j++)r.v[i] += m.v[i].v[j] * v.v[j];

return r;};

Page 36: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Operator overloadingOperator overloading

• Conventional shorthandx+y*z is clearer thanmultiply y by z and add the result to x

• C++ supports a set of operators for its built-in types, and allows to provide operators for user defined types.

Page 37: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Operator overloadingOperator overloading

class complex {double re, im;

Public://member initialization listcomplex(double r, double i) : re(r), im(i) { }complex operator+(complex);complex operator*(complex);

};void f(){

complex a = complex(1, 3.1);complex b = complex(1.2,2);complex c = a + b; // shorthandcomplex d = a.operator+(b); // explicit callcomplex e = b + c * d; // usual precedence

}

Page 38: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Operator overloading exampleOperator overloading example

class Point {int x, y;

public:Point() {};Point(int xx, int yy) { x = xx; y = yy; }Point operator+(Point& p);Point operator++();void show() { gotoxy(x, y); putchar('*'); }

};Point Point::operator+(Point& p) {

Point tmp;tmp.x = x + p.x;tmp.y = y + p.y;return tmp;

}Point& Point::operator++(){

x++; y++;return *this;

}

Page 39: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Operator overloading exampleOperator overloading example

int main(){

Point p1(10,20), p2(2,10), p3;p3 = p1 + p2;p3.show();(p1+p2).show();

}

Page 40: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Derived classesDerived classes

employee:nameage…

nameage…

grouplevel

manager:

Page 41: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

struct employee { // base char* name; short age; short department; int salary; employee* next; //...};struct manager { employee emp; // manager's employee record employee* group; // people managed short level;};• Cannot put manager onto a list of

employees without writing special code

Page 42: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Derived classesDerived classes

// a manager is an employee// derivedstruct manager : public employee { employee* group; // people managed short level;};

employee

manager

Page 43: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Derived classesDerived classes

void f(){ manager m1, m2; employee e1, e2; employee* elist; // heterogonous list elist = &m1; // put manager m1 on elist m1.next = &e1; // put employee e1 on elist e1.next = &m2 // put manager m2 on elist m2.next = &e2; // put employee e2 on elist e2.next = 0;}

Page 44: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Derived classesDerived classesclass employee {

string name;public:

employee* next; // public to allow list manipulationvoid print() const;string getname() { return name; }

};class manager : public employee {

int level;public: void print() const; //function overriding};void manager::print() const{

cout << “name is” << getname() << endl;cout << “name is” << name << endl; // error

employee::print(); // print employee informationcout << level; // print manager information

}

Page 45: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Access controlAccess control

• A member of a class can be private, protected, or public.

1. If it’s private, its name can be used only by member functions and friends of the class in which it is declared.

2. If it’s protected, its name can be used only by member functions and friends of the class in which its declared and by member function and friends of classes derived from this class.

3. If it’s public, its name can be used by any function.

Page 46: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Access controlAccess control

class Base1 {private:

int i;protected:

int j;public:

int k;};

main () { Base1 b; int x; x = b.i; // error x = b.j; // error x = b.k; // ok}

Page 47: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Access controlAccess control

There are three kinds of functions accessing a class:1. Functions implementing the class (its friends and

members)2. Function implementing a derived class (the derived

class’ friends and members)3. Other functions.

private:

protected:

public:

general users

derived class’ member functions and friends

own member functions and friends

Page 48: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Access control: derived classesAccess control: derived classes

Under public inheritance:1. Public member remains public in derived

class.2. Protected member remains protected in

derived class.3. Private member is hidden in derived

class.

Page 49: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

ConstructorsConstructors

• Some derived classes need constructors. If the base class has a constructor then it must be called.

class employee {string name;int department;

public:employee(const string& n, int d);

};class manager : public employee {

int level;public:

manager(const string& n, int d, int lvl);};

Page 50: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

ConstructorsConstructors• Arguments for base class’ constructor are specified

in the definition of a derived class’ constructor.• A derived class constructor can specify initializers

of its own members and immediate bases only, it cannot directly initialize members of a base.

• Ctors are called bottom-up and dtors top-down.

employee::employee(const string& s, int d): name(n), department(d) // initialize members

{}manager::manager(const string& s, int d, int lvl)

: employee(n, d), // initialize base class level(lvl) // initialize members

,name(n) // error{}

Page 51: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Class hierarchiesClass hierarchies• C++ can express a directed acyclic graph of

classes.class employee { /*...*/ };class manager : public employee { /*...*/ };class director : public manager { /*...*/ };class temporary { /*...*/ };class secretary : public employee { /*...*/ };class tsec : public temporary, public secretary { /*...*/ };class consultant : public temporary, public manager {/*...*/ };

temporary employee

tsec

consultant

secretary manager

director

Page 52: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Polymorphism & Polymorphism & virtual functionsvirtual functions

• Functions in a base class that can be redefined in a derived class and have a polymorphic behavior: the version used depends on the object’s type, which is decided in run time.

class employee { …virtual void print() const;

};class manager : public employee { … virtual void print() const;};

employee *my_employee;my_employee->print();

Page 53: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Abstract classAbstract class

• Some classes represent abstract concepts for which object cannot exist. For example, a shape makes sense only as the base of some class derived from it.

class shape {public:

virtual void rotate(int){

error("shape::rotate"); // not elegant}

virtual void draw() { error("shape::draw"); }};

shape s ; // legal but silly: ``shapeless shape''

Page 54: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Abstract classAbstract class

• A class with one or more pure virtual functions is an abstract class

• No objects of an abstract class can be created.

class shape {public: virtual void rotate(int) = 0; // pure virtual virtual void draw() = 0; //...};

shape s; // error: variable of abstract class shape

Page 55: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

Abstract classAbstract class

• An abstract class can be used only as an interface and a base for other classes.

class point { /* ... */ };

class circle : public shape {public:

void rotate(int) { } // overrides shape::rotatevoid draw(); // overrides shape::drawcircle(point p, int r);

private:int radius;

};

Page 56: Introduction to C++. Overview Enhanced C. OOP & classes. Inheritance

ReferencesReferences

• The C++ programming language, Bjarne Stroustrup, Addison Wesley, 3rd Ed., 1997.