lecture 10 - purdue university€¦ · lecture 10 xiaoguang wang stat 598w feb 25th, 2014 (stat...

Lecture 10

Xiaoguang Wang

STAT 598W

Feb 25th, 2014

(STAT 598W) Lecture 10 1 / 49

Outline

1 Some details

2 Operator Overloading

3 Inheritance

4 Exercises


Outline

1 Some details


3 Inheritance

4 Exercises


Class Scope

Every class has a different scope.

We can access members by using the dot or arrow operator:

class Obj;

class *ptr=&Obj;

ptr->member;

obj.member;

We can define function-members:

type class::name(arguments) const{

...code...

}


Access Specifiers

class class_name{

access_specifier_1:

member 1;

access_specifier_2:

member 2;

...

}

Access Specifier: public, protected, private


Access Specifiers

The specifiers modify the access rights that the members following themacquire:

private: private members of a class are accessible only from withinother members of the same class or from their friends.

protected: protected members are accessible from members of theirsame class and from their friends, but also from members of theirderived classes.

public: public members are accessible from anywhere where theobject is visible.


Friend Functions

In principle, private and protected members of a class cannot beaccessed from outside the same class in which they are declared.

This rule does not affect friends.

Friends: functions or classes declared with the friend keyword.

A friend function of a class has access to the private and protectedmembers of this class.

We can declare an external function as friend of a class by declaring aprototype of this external function within the class, and preceding itwith the keyword friend.


Friend Functions: example

// friend functions

#include <iostream>

using namespace std;

class CRectangle {

int width, height;

public:

void set_values (int, int);

int area () {return (width * height);}

friend CRectangle duplicate (CRectangle);

};

void CRectangle::set_values (int a, int b) {

width = a;

height = b;}


Friend Functions: Example (Continued)

CRectangle duplicate (CRectangle rectparam)

{

CRectangle rectres;

rectres.width = rectparam.width*2;

rectres.height = rectparam.height*2;

return (rectres);

}

int main () {

CRectangle rect, rectb;

rect.set_values (2,3);

rectb = duplicate (rect);

cout << rectb.area();

return 0;

}


Friend Functions

Remarks:

The duplicate function is NOT a member of class CRectangle! Itsimply has access to its private and protected members without beinga member.

The friend functions can serve, for example, to conduct operationsbetween two different classes.

Generally, the use of friend functions is out of an object-orientedprogramming methodology, so whenever possible it is better to usemembers of the same class to perform operations with them.


Friend Classes: Example

// friend class

#include <iostream>


class CSquare;

class CRectangle {

int width, height;

public:

int area ()

{return (width * height);}

void convert (CSquare a);

};


Friend Classes: Example (Continued)

class CSquare {

private:

int side;

public:

void set_side (int a)

{side=a;}

friend class CRectangle;

};

void CRectangle::convert (CSquare a) {

width = a.side;

height = a.side;

}


Friend Classes: Example (Continued)

int main () {

CSquare sqr;

CRectangle rect;

sqr.set_side(4);

rect.convert(sqr);

cout << rect.area();

return 0;

}


Friend Classes

Remarks:

Declaration of class CSquare at the beginning of the program isnecessary.

CRectangle is considered as a friend class by CSquare, butCRectangle does not consider CSquare to be a friend.

Friendships is not transitive: The friend of a friend is not consideredto be a friend unless explicitly specified.


Friend Class members

A friend can be a non-member function, a member function of apreviously defined class or an entire class. We can declare for example:

friend void CRectangle::convert(const CSquare& a);

inside the CSquare class definition or declaration.


Outline

1 Some details


3 Inheritance

4 Exercises


Overloaded operator

Functions with special names:+,-,*,%,^,&,~,!,=,==,++,<,>,<=,>=,&&,+=,-=,*=,[],(),->,etc.

Example:

double operator+(double& ,double& );

The overloaded functions can be defined inside or outside of a class.

Example1& Example1::operator+=(const Example1&);

Example1 operator+(const Example1&,const Example1&);

Usually if a overloaded operator is defined outside a class it is a friendmember of such class.


Overloaded operator

The overloaded operators are used in the usual way:

cout << item1+item2 <<endl;

Example1 a+=b;

or they can be used as functions:

cout << operator+(item1,item2) <<endl;

Example1 a.operator+=(b);


Arithmetic and Relational Operators

Usually the arithmetic and relational operators are defined asnon-member functions.

Arithmetic operators. Arguments: Constant and Reference-typeclasses. Output: new class type.

Relational operators: Arguments: Constant and Reference-typeclasses. Output: Boolean.


Arithmetic and Relational Operators

bool Example1::operator==(const Example1& ex1, _

const Example1& ex2){

return ex1.member1=ex2.member1 && ex1.member2==ex2.member2;

}

bool Example1::operator!=(const Example1& ex1, _

const Example1& ex2){

return !(ex1==ex2);

}


Assignment Operator

The assignment operators can be overloaded.

They should be defined as member functions, and they should returna reference to *this.

Example:

Example1& Example1::operator=(const Example1& ex1){

member1=ex1.member1;

member2=ex1.member2;

return *this;

}


Subscript Operator

The subscript operator should be defined as a member function.

Example:

double& Foo::operator[](const int ix){

if(ix==0){

return member1;

}else{

return member2;

}

}


Outline

1 Some details


3 Inheritance

4 Exercises


Inheritance

Inheritance allows to create classes which are derived from other classes,so that they automatically include some of its ”parent’s” members, plus itsown.


Format and syntax

Format:

class derived_class_name: public base_class_name

{ /*...*/ };

derived class name: name of the derived class;

base class name: name of the class on which the derived class isbased;

public access specifier: may be replaced by any one of the otheraccess specifiers protected and private. It limits the most accessiblelevel for the members inherited from the base class.


Derived Class: Example

#include <iostream>


class CPolygon {

protected:

int width, height;

public:

void set_values (int a, int b)

{ width=a; height=b;}

};

class CRectangle: public CPolygon {

public:

int area ()

{ return (width * height); }

};


Derived Class: Example (Continued)

class CTriangle: public CPolygon {

public:

int area ()

{ return (width * height / 2); }

};

int main () {

CRectangle rect;

CTriangle trgl;

rect.set_values (4,5);

trgl.set_values (4,5);

cout << rect.area() << endl;

cout << trgl.area() << endl;

return 0;

}



protected vs. private: When a class inherits from another one, themembers of the derived class can access the protected membersinherited from the base class, but not its private members.

In our example, the members inherited by CRectangle and CTrianglehave the same access permissions as they had in their base classCPolygon:

CPolygon::width // protected access

CRectangle::width // protected access

CPolygon::set_values() // public access

CRectangle::set_values() // public access



class CRectangle: public CPolygon { ... }

This public keyword after the colon (:) denotes the most accessiblelevel the members inherited from the class that follows it (in this caseCPolygon) will have.

If we specify a more restrictive access level like protected, all publicmembers of the base class are inherited as protected in the derivedclass.


Inheritance

In principle, a derived class inherits every member of a base class except:

its constructor and its destructor

its operator=() members

its friends


Multiple Inheritance

In C++ it is perfectly possible that a class inherits members frommore than one class.

Example:

class CRectangle: public CPolygon, public COutput;

class CTriangle: public CPolygon, public COutput;


Example

Based on cplusplus.com examples:

We want to create a class that describes a “small” polygons (trianglesand rectangles). They share 2 properties: base and height.

class Polygon {

public:

Polygon();

Polygon(double a,double b,string s):

width(a), height(b), type(s) {};

virtual double perimeter() const;

virtual ~Polygon();

protected:

double width, height;

private:

string type;

};


Virtual functions

The virtual functions can be used by the derived classes without anyrestriction.

Virtual members produce dynamic binding: the compiler delays therun-time until the selection of a proper function to execute.

If a function is virtual then the compiler selects the function’sdefinition until the class is properly defined.

Any virtual function can be re-defined in the derived class. If it is notre-defined, the base definition is used.


More details

A class should be defined before it can be used as a base class.

Any derived class can be used as a base class.

The derived classes are declared in the usual way: name_class name;


Dynamic binding

If we define a pointer (or reference) to base class, we can use it topoint (or to reference) to their derived classes. Example:

void print_dim(const Polygon& pp);

Polygon p1;

print_dim(p1);

Polygon *point1=&p1;

Triangle t1;

print_dim(t1);

point1=&t1;

The compiler always “thinks” that the pointer refers to a base-classobject.


Dynamic binding

The pointers/references to base-class types have two different forms:

Static type: type treated by the compiler.Dynamic type: run-time type, or type treated by the object file.

In this case:

Static type: pointer/reference to base-class.Dynamic type: pointer/reference to derived-class.

The same applies to the virtual functions or members. (the sameobject can refer to different class definitions.)

It is fundamental that we pass the arguments as pointers/referencesin our virtual functions. In this way the virtual objects are determinedat run-time.


Dynamic binding

The virtual mechanism can be overriden using the scope operator:

double result1=t1->Polygon::perimeter();

this code will be resolved at compile-time.


Polymorphism

Ability to create a variable, function, or an object that has more thanone form. (Wikipedia)

We have used polymorphism in C++ several times:

Operator overloading.Constructor overloading (function overloading in general).Dynamic binding in virtual members.Base-class reference and pointer types.

The polymorphism aims for simplicity in the programming language.


Constructors

The constructors of a base class can be defined in the usual way. Butthey can be made protected or private.

If we use the default derived-class constructor, example:Triangle();, it performs two tasks:

It invokes the base default constructor Polygon() and it initializes allits members.It initializes the derived-class members based on their current types.

Also we can initialize partially the derived class.

Or we can initialize all the class members by using the base-classconstructor within the derived-class constructor.


Example

Triangle(double a, const double&b, const double& value):

Polygon(a,b,’tri’), value1(value) {}


Copy constructor

The default copy constructor of a derived class is based on thecorresponding constructor of the base class.

We can create copy constructors as well. This definitions override thedefault contructors. Example:

class Base{.....};

class Derived: public Base{

public:

Derived(const Derived& d):

Base(d), ...... {}

}


Assignment operator

Derived & Derived::operator=(const Derived& rhs){

if(this!=&rhs){

Base::operator=(rhs);

...

...

}

return *this;

}


Destructors

The destructors have a different behavior. They cannot be inherited:the destructor only cleans up its class members.

If we delete a pointer to a class, we have to possible responses:

If the class is a base: members of the class are clean up.If the class is derived: behavior is undefined. We fix this by declaring avirtual destructor.

Example:

Base *pointer1=new Base;

delete pointer1; //base-class destructor

Derived *pointer2=new Derived;

delete pointer2; //derived-class destructor


Calling Order of constrcutors and destructors

Consider the code below:

#include<iostream>


class base{

public:

base(){

cout<<"A"<<endl

}

~ base(){

cout<<"B"<<endl

}

}


Calling order of constructors and destructors

class derived : public base{

public:

derived(){

cout<<"C"<<endl

}

~derived(){

cout<<"D"<<endl

}

}

int main(){

derived d1;

return 0;

}


Outline

1 Some details


3 Inheritance

4 Exercises


Zero-Coupon Yield Models

Martellini et al (2003)

There are many ways to construct models on the zero-coupon yieldcurve r(t). Most of them are solutions of differential equations.

The simplest of such models is the Nelson-Siegel model:

r(t) = β0 + (β1 + β2)

[1 − e−

tλ

tλ

]+ β2

[e−

tλ

]where:

β0: long-term interest rate.β1: long-to-short-term spread.β2: curvature parameter.λ: scale parameter (decay rate of short and medium-term components)


Zero-Coupon Yield Models

In order to have more interesting shapes in the zero-curve,Svensson(1994) defines:

r(t) = β0 + β1

[1 − e

− tλ1

tλ1

]+ β2

[1 − e

− tλ1

tλ1

− e− t

λ1

]

+ β3

[1 − e

− tλ2

tλ2

− e− t

λ2

]


Exercise

Implement the Nelson-Siegel and Svensson models in your termstructure class. Take their parameters as vectors, and define them asdata-members in your class.

Test your code with the following parameters:

Nelson-Siegel: β0 = 0.07, β1 = −0.02, β2 = 0.01, λ = 3.33.Svensson:β0 = 0.07, β1 = −0.02, β2 = 0.01, β3 = −0.01, λ1 = 3.33, λ2 = 0.3.


lecture 10 - purdue university€¦ · lecture 10 xiaoguang wang stat 598w feb 25th, 2014 (stat...

Documents