OOP ClassOOP Class

Lawrence D’AntonioLawrence D’Antonio

Lecture 4Lecture 4

An Overview of C++, Part 2An Overview of C++, Part 2

What is a class?What is a class?

A class is a set of objects sharing common A class is a set of objects sharing common features.features.

A class defines an object’s attributes and A class defines an object’s attributes and behavior. Methods are provided to act on behavior. Methods are provided to act on an object and to pass messages between an object and to pass messages between objects.objects.

A class is the basic unit of abstraction.A class is the basic unit of abstraction. A class is the basic unit of modularity.A class is the basic unit of modularity. A class can be concrete or abstract.A class can be concrete or abstract.

Class Design as Type Design

Scott Meyers, Item #19 How should objects of your new type be

created and destroyed? How should object initialization differ from

object assignment? What does it mean for objects of your new

type to be passed by value?

Class Design as Type Design 2

What are the restrictions on legal values for your new type?

Does your new type fit into an inheritance graph?

What kind of type conversions are allowed for your new type?

What operators and functions make sense for the new type?

Class Design as Type Design 3

What standard functions should be disallowed?

Who should have access to members of your new type?

What is the “undeclared interface” of your new type?

How general is your new type? Is a new type really what you need?

What is an object?What is an object?

An object is an instance of a class.An object is an instance of a class. An object has state, behavior, identity.An object has state, behavior, identity.

What is an object?

Coad-Yourdon

An abstraction of something in a problem domain, reflecting the capabilities of the system to keep information about it, interact with it, or both; an encapsulation of attribute values and their exclusive services.

What is an object?

OMG

An object is a thing. It is created as the instance of an object type. Each object has a unique identity that is distinct from and independent of any of its characteristics. Each object offers one or more operations.

What is an object?

Firesmith

An object is defined as a software abstraction that models all relevant aspects of a single tangible or conceptual entity or thing from the application domain or solution space. An object is one of the primary entities in an object-oriented application, typically corresponds to a software module, and consists of a set of related attribute types, messages, exceptions, operations, and optional component objects.

What is an object?

Booch

From the perspective of human cognition, an object is any of the following:

A tangible and/or visible thing. Something that may be apprehended

intellectually. Something toward which thought or action is

directed.

What is an object?

Booch continued.

An object has state, behavior, and identity; the structure and behavior of similar objects are defined in their common class; the terms instance and object are interchangeable.

What is an object?

Shlaer-Mellor

An object is an abstraction of a set of real-world things such that:

All the things in the set have the same characteristic.

All instances are subject to and conform to the same set of rules and policies.

What is an object?

Jacobson

An object is characterized by a number of operations and a state which remembers the effect of these operations.

What is encapsulation?What is encapsulation?

Internal details of objects are concealed Internal details of objects are concealed from the objects users (information hiding).from the objects users (information hiding).

Both data and implementation may be Both data and implementation may be hidden. The object is a black box.hidden. The object is a black box.

Access to members is controlled through Access to members is controlled through the class definition.the class definition.

The accessible part of a class is called its The accessible part of a class is called its interface.interface.

Data encapsulation exampleclass Clock { private:

int hours; // 1-12 private int minutes; // 0-59

public:Clock(int h, int m) {

if (h < 1 || h > 12) { throw(”Hours must be between 1 and

12″); } if (m < 0 || m > 59) {

throw(”Minutes must be between 0 and 59″);

} h = hours; m = minutes;

}//...

};

Class Invariants

The above is an example of “Programming by Contract.”

The class guarantees that

These are called class invariants

1 hours 12, 0 minutes 59

Data Members

Data members can be declared as: const – a declaration that an object is read

only. The object may be stored in a CPU register.

volatile – a declaration that an object’s value may be changed asynchronously. The object may not be stored in a CPU register.

Data Members 2

static – A data member shared by all objects of a class. There is only one copy of a static member, it is not part of the object memory layout.

mutable – A data member that is allowed to be modified, even if it a member of a const object.

Is the following code legal?

struct X {

static int a = 2;

};

main()

{

X my_x;

X::a = 4;

my_x::a = 5;

}

Not legal!

Cannot initialize static data member a within class.

static variables are similar to extern variables.

Is the following code legal?

struct X {

static int a;

};

main()

{

X my_x;

X::a = 4;

my_x::a = 5;

}

Not legal!

This is a linker error.

X::a was used but never defined.

Is the following code legal?

struct X {

static int a;

};

int X::a;

main()

{

X my_x;

X::a = 4;

my_x::a = 5;

}

Legal.

X::a was defined before being used.

Note: it is okay that X::a was not initialized.

Is the following code legal?

struct X {static int a;static const int b = 3;

};

int X::a = 2;

main(){

X my_x;X::a = 4;my_x::a = X::b;

}

Legal.

static const members can be declared and defined at the same time.

Is the following code legal?

void func(volatile std::list<int> li)

{

int n = li.front();

}

Not legal!

Only volatile member functions can be called on a volatile object.

list::front() not a volatile function

What is a method?What is a method?

A method is a member function that acts A method is a member function that acts upon an object. A method is generally upon an object. A method is generally called for one object (exception: static called for one object (exception: static members).members).

Commonly found methods are Commonly found methods are constructors, destructors, assignment, constructors, destructors, assignment, mutators, accessors.mutators, accessors.

Static Members#include <iostream> using namespace std;

class X { public:

int a; void f(int b) { cout << “X::f()\n”;}

};

int main() { int X::*ptiptr = &X::a; //pointer to data member

void (X::* ptfptr) (int) = &X::f; //pointer to member function

X xobject; xobject.*ptiptr = 10; (xobject.*ptfptr) (20); }

What is message passing?What is message passing?

Messages are transfers of data or Messages are transfers of data or requests for another object to take an requests for another object to take an action.action.

Message passing example

Adapter pattern

What is polymorphism?What is polymorphism?

Different types of objects respond to the Different types of objects respond to the same message and use the appropriate same message and use the appropriate method.method.

Polymorphism

Universal

Ad-hoc

Parametric

Subtype

Overloading

Coercion

Polymorphic Objects

A function (or operator) is polymorphic if it has an argument that can accept different types.

A variable is polymorphic if it can have different types in different contexts.

A type is polymorphic if its operations can apply to arguments of different types.

Overloading

The same name is used to denote different functions.

These functions are distinguished by different signatures.

Some languages (such as C++) allow the programmer to define their own overloaded functions and operators.

Overloading Example

int square(int x) { return x*x; }

long square(long x) { return x*x; }

float square(float x) { return x*x; }

double square(double x) { return x*x; }

Alternative Method

template<typename T>

T square(T x) { return x*x; }

This works on all data types for which operator * is defined.

int x = square(4); //Calls square(int)

double y = square(4.2); //Calls square(double)

float z = square(3); //Calls square(int)

Implementation

How is overloading done? Through name mangling. The compiler modifies

the names of each overloaded function. Examplevoid foo(int,int);void foo(double,double);

In Assembler, these would be renamed:foo_Fii:

foo_Fdd:

Is this code legal?#include <stdlib.h>

struct C1 {enum E {red, blue};}; struct C2 {enum E {red, blue};};

extern "C" int printf(const char *, ...);

void f(C1::E x) {printf("f(C1::E)\n");} void f(C2::E x) {printf("f(C2::E)\n");}

int main() { f(C1::red); f(C2::red); return EXIT_SUCCESS;

}

Yes, this is legal.

The nested enums C1::E and C2::E are different types. So the overloaded functions have different signatures.

Is this legal?

class X {

public:

int f();

double f();

};

No, you can’t overload only on return type.

Is this legal?

struct A {

static int f();

int f();

};

No, it’s not legal. You can’t overload by static.

Is this legal?

typedef int I;

void f(float, int);

void f(float, I);

Not legal. A typedef of an int is still an int.

Is this legal?

f(char*);

f(char[10]);

Not legal. The arguments are considered the same type (pointer to char).

Is this legal?

g(char(*)[20]);

g(char(*)[40]);

Yes, it’s legal. You can distinguish multidimensional arrays by their second (or higher) dimensions.

Is this legal?

int f(int);

int f(const int);

Not legal. You can’t overload by constness of argument.

Is this legal?

void f(int &) { std::cout << “int &\n”; }void f(const int &) { std::cout << “const int &\n”; }

main() {f(3);return 0;

}

Legal. const is used within a type specification.

Q: Which function is called?A: f(const int &)

Is this legal?

void f(int) { std::cout << “int \n”; }

void f(int &) { std::cout << “int &\n”; }

main() {

f(3);

return 0;

}

Legal. The signatures are different.

Q: Which function is called?

A: f(int)

Is this legal?

void f(double int) { std::cout << “double \n”; }void f(const int &) { std::cout << “const int &\n”; }

main() {f(3);return 0;

}

Legal. The signatures are different.

Q: Which function is called?A: f(const int &)

Is this legal?

void f(int);

void f(int i = 10);

Not legal. Can’t overload by default arguments.

Is this legal?

void g(int (float));

void g(int (*)(float));

Not legal. Both functions take the same argument (pointer to function of the same type).

Coercion

A coercion is an implicit type conversion. This allows the programmer to omit a type cast.

There are three types of coercions: Compiler defined (such as promotions,

derived base) Constructor User defined

Compiler defined coercions

Simple example

double x;

x = 2; //2 promoted to double

Function call coercions

void foo(double x) { //... }

//foo() can be called with any type that can be

//converted to double

foo((short) 4);

foo(‘a’);

foo(3L);

foo(2.3F);

Is this legal?#include <iostream>

void f(char a, int b){ std::cout << a << b << '\n'; }

void f(int a, char b){ std::cout << a << b << '\n'; }

main(){ f('a','b'); return 0;}

Not legal, it’s ambiguous.

Coercion vs. Overloading example

3 + 4;

3 + 4.0;

3.0 + 4;

3.0 + 4.0;

How does this work?

Explanations of example

Four overloaded versions of operator + Two overloaded versions of operator +,

one for integers, the other for doubles. The middle two calls in the example would use coercion.

One version of operator +, for doubles. The first three calls in the example would use coercion.

Derived to Base Conversion

C++ will implicitly convert a pointer or reference to a derived class to a pointer or reference to the base class. This is because the derived class has a copy of the base class inside it.

A pointer to the base class cannot be converted to a pointer to the derived class.

Is this legal?class A {};

class B: public A {};

class C: protected A {};

class D: private A {};

main() { A *pa = new B; pa = new C; pa = new D; return 0;}

pa = new B; //Legal, B is an A

pa = new C; //Illegal, C is not an A

pa = new D; //Illegal, D is not an A

In the last two cases, the base class is inaccessible.

Is this legal?

class A {};

class C: protected A {public: void foo() { A *pa = this; }}; class D: private A {public: void foo() { A *pa = this; }}; main() { C c; c.foo();

D d; d.foo(); return 0;}

Yes, it’s legal. Protected and private inheritance exemplify a has-a relationship, rather than an is-a relationship. Member functions are allowed to convert pointer to derived into pointer to base.

Pointer to Member Conversions

What is the relationship between a pointer to member of a base class and a derived class?

Is this legal?struct A { int a;};

struct B: public A { int a;};

main(){ A a; B b; int A::*pa = &B::a; int B::*pb = &A::a;

return 0;}

Complicated.

int A::*pa = &B::a;

is illegal. Can’t convert pointer to derived member to a pointer to base member.

int B::*pb = &A::a;

Is legal. Can convert pointer to base member to a pointer to derived member.

Conversion Constructors

Constructors that take a single argument can be thought of as a type conversion.

struct X { X(int); };

So that any code that expects an object of class X can be passed an int that will then be converted to an X.

Is this legal?

struct X { X(int){} };

void f(const X &) {}void g(int) {}void g(X) {}

main() {f(3);g(4);g(X(5));

return 0;}

f(3); //Legal, you can create a temp //object X(3), which is passed to //f()

g(4); //Legal, calls g(int)

g(X(5)); //Legal, calls g(X)

Is this legal?struct X { X(int){} };

void f(X &) {}void g(int) {}void g(X) {}

main() {int a = 2;

f(3);f(a);g(4);g(X(5));

return 0;}

f(3); //Not legal, can’t use temp X object to initialize an X &

f(a); //Not legal, can’t use temp X object to initialize an X &

g(4); //Legal, as before

g(X(5)); //Legal, as before

Is this legal?

struct X { X(int){} };

struct Y { Y(X) {} };

void f(Y) {}

main() {

f(3);

return 0;

}

Not legal.

Basically, only one level conversions are allowed. Not allowed to convert int to X to Y.

Is this legal?struct X { X(int){} };

void f(X) {}void g(int) {}void g(X) {}

main() {int a = 2;

f(3);f(a);g(4);g(X(5));

return 0;}

f(3); //Legal, temp X is passed by value

f(a); //Legal, temp X is passed by value

g(4); //Legal, as before

g(X(5)); //Legal, as before

Parametric Polymorphism

Parametric polymorphism parametrizes Parametric polymorphism parametrizes the object type (e.g., a list class, where the the object type (e.g., a list class, where the type of object stored is parametrized).type of object stored is parametrized).

Template Functions

template<class T>

T max(T a, T b) {

return a > b ? a : b;

}

Is this legal?

int a,b = 6;

const int c = 3;

double x,y = 3.2;

a = max(b,4);

a = max(b,c);

x = max(y,3.3);

x = max(b,y);

a = max(b,4); //Legal, max<int,int>a = max(b,c); //Legal, max<int,int>x = max(y,3.3); //Legal, max<double,double>x = max(b,y); //Illegal, no max<int,double>

A template function is called only when there is an exact match for type parameters (only trivial conversions, such as const int to int are allowed).

Better max?template<class S, class T>T max(S a, T b) { return a > b ? a : b;}

main() { int a, b = 3; double x, y = 3.2;

a = max(b,5); x = max(y,5.4); x = max(b,y); x = max(y,b); return 0;}

a = max(b,5); //Legal, returns 5

x = max(y,5.4); //Legal, returns 5.4

x = max(b,y); //Legal, 3.2

x = max(y,b); //Legal, but //returns 3.0!

Best max?template<class R, class S, class T>R max(S a, T b) { return a > b ? a : b;}

main() { int a, b = 3; double x, y = 3.2;

a = max(b,5); x = max(y,5.4); x = max(b,y); x = max(y,b); return 0;}

Doesn’t compile. The function max() is supposed to have 3 template parameters. But each call only uses 2 parameters.

Try this maxtemplate<class R, class S, class T>R max(S a, T b) { return a > b ? a : b;}

main() { int a, b = 3; double x, y = 3.2;

a = max<int>(b,5); x = max<double>(y,5.4); x = max<double>(b,y); x = max<double>(y,b);

return 0;}

Subtype polymorphism

Subtype (or inclusion) polymorphism Subtype (or inclusion) polymorphism allows objects of a given type to be allows objects of a given type to be substituted for by objects of a subtype.substituted for by objects of a subtype.

What is inheritance?What is inheritance?

One class (derived/child) relies on the definition of another class (base/parent).

Single vs. multiple inheritance A method of sharing code or sharing

interface among classes. Language may define a class tree (with

single root): Java, Smalltalk Language may define a class forest: C++

What is typing?What is typing?

Static typing: Data type determined at compile-time. Type must be declared.

Dynamic typing: Data type may be determined at run-time. Type need not be declared.

Strong typing: Variables are bound to a specific type.

Weak typing: A variable’s type may change.

Varieties of typing

Static and strong typing: Java, Pascal, OCaml, Haskell

Static and weak typing: C/C++ Dynamic and strong typing: Python Dynamic and weak typing: PHP

Dynamic typing example# Python example

class Cat: def speak(self): print "meow!"

class Dog: def speak(self): print "woof!"

class Bob: def speak(self): print "hello world!"

def command(pet): pet.speak()

pets = [ Cat(), Dog(), Bob() ]

for pet in pets: command(pet)

Weak typing example

var x := 5;

var y := "37";

Print(x + y);

In Visual Basic this prints: 42

In JavaScript this prints: 537

What is exception handling?

The mechanism used to report and recover from abnormal states.

When an error is detected, execution is passed to a handler.