Download - Programming Techniques Course
© Copyright Eliyahu Brutman
Programming Techniques Course
Version 1.0
© Copyright Eliyahu Brutman
Chapter 3A –Data Abstraction
Version 1.0
© Copyright Eliyahu Brutman
Classes and Objects - 3
Table of contents
Expressing Our World via OO Expending our programming language to support those
new needs User-defined type Class declaration, definition, implementation Object creation Encapsulation and interfaces Access control
© Copyright Eliyahu Brutman
Classes and Objects - 4
What Do We Need From OO?
Express our world via
Objects
Responsibilities
Operations / capabilities
Inter-Relationship
Cardinality / Multiplicity
Hierarchies
Generic approach via interfaces
Objects invoking one another via message passing Achieve de-coupled, self-maintained instances
Via implementation hiding
With well defined interfaces
© Copyright Eliyahu Brutman
Classes and Objects - 5
What Do We Expect from an OO Language?
User-Defined types
Define new types, to support our new “language” Same behavior as had been with built-in types
int a=1, b=2, c;
c= a+b; Expand to user-defined types
String s1 = “C++ “;
String s2 = “Class”;
String s3;
S3 = s1 + s2; Hide implementation
What do we mean by “hide”?
© Copyright Eliyahu Brutman
Classes and Objects - 6
Declaration Of a Class
class String {
char* m_str;
public:
char* GetString();
void SetString(char* newStr);
};
String.hDeclaration of a class
The implementation is not important for us, as users of the class It is important for us to understand which services we get from
the class, and its precise usage
We can use thoseservices
© Copyright Eliyahu Brutman
Classes and Objects - 7
Object Creation - Instantiation
void main() {
String s1, s2;
s1.SetString(“hello”);
s2.SetString(“bye”);
printf(“s1 is: %s, s2 is: %s\n”, s1.GetString(), s2.GetString());
}
main.cppUsing the String class
Creating 2 objects Setting them with values, via SetString() method
What is the internal representation of s1 and s2 ?
Do we care, as users of the class? Accessing their values, via GetString() method, returning
their value, and printing them in an old manner
© Copyright Eliyahu Brutman
Classes and Objects - 8
Definition Of A Class
class String {
char* m_str;
public:
char* GetString();
void SetString(char* newStr);
};
char* String::GetString() {
return m_str;
}
void String::SetString(char* newStr) {
int len=strlen(newStr);
m_str = new char[len+1];
strcpy(m_str, newStr);
}
String.hDeclaration of a class
String.cppDefinition of a class
© Copyright Eliyahu Brutman
Classes and Objects - 9
Object Creation - Instantiation
Lets add another method
int String::CompareString(String* strToCompare) {if (strcmp(strToCompare->m_str, m_str)==0)
return 1;else
return 0;}
void main() {
String s1, s2;
s1.SetString(“hello”); s2.SetString(“bye”);
printf(“s1 is: %s, s2 is: %s\n They are ”, s1.GetString(), s2.GetString());
if (s1.CompareString(&s2)==1) printf(“equivalent\n”);
else printf(“non-equivalent\n”);
}
© Copyright Eliyahu Brutman
Classes and Objects - 10
Object Creation – Cont’d
class String {
char* str;
int len;
public:
char* GetString();
void SetString(char* newStr);
};
Assume that most comparisons in our applications are FALSE.
Suggest a more efficient solution to the above implementation
© Copyright Eliyahu Brutman
Classes and Objects - 11
Object Creation – Cont’d
char* String::GetString() {return m_str;
}void String::SetString(char* newStr) {
m_len=strlen(newStr);m_str = new char[m_len+1];strcpy(m_str, newStr);
}int String::CompareString(String* strToCompare) {
if (len != strToCompare->m_len)return 0;
else if (strcmp(strToCompare->str, str)==0)return 1;
elsereturn 0;
}
© Copyright Eliyahu Brutman
Classes and Objects - 12
Encapsulation
Do we need to change main? Why not? ENCAPSULATION !!! Implementation Hiding !!!
We touched internal presentation only !!
We have not touched the exposed interface !!
We have kept the rule of IMPLEMENTATION HIDING !! Major OO Concept for better SW Engineering !!
© Copyright Eliyahu Brutman
Classes and Objects - 13
C++: Limiting data visibility
Visibility of class members limited in class declarationprivate – accessible only within the class protected – accessible only within the class and classes that inherit from itpublic – accessible anywhere
private is the default access level
class C{int i; //private by default
private:int j;
protected:int k;
public:int l;
}
This is just the basics, more to come…
© Copyright Eliyahu Brutman
Classes and Objects - 14
Encapsulation and Access Control
Expose minimum to clients Do not expose internal representation
This is enforced by the private keyword
Client cannot access private members
Default access is private (that is why we did not have to write the keyword private before the data members)
Expose interface to clients
Enforced by the public keyword There is more to accessibility
We will talk about it later
© Copyright Eliyahu Brutman
Classes and Objects - 15
Data Abstraction - summary
Define a type and operations on itLike built-in types: int, float, …
Conceal data and implementationUse access modifiers private, protected, public
Why?Easier to design and implementLocalizes future modifications
© Copyright Eliyahu Brutman
Classes and Objects - 16
Issues
Will it work?
1: char* String::getString(){return chars;} 2: void String::setString(char* value){ 3: length = strlen(value); 4: chars = new char[length+1]; 5: strcpy(value, chars); 6: } 7: int String::equals(String *other){ 8: if (length != other->length) 9: return 0;10: if (strcmp(chars, other->chars) == 0)11: return 1;12: return 0;13: }
© Copyright Eliyahu Brutman
Classes and Objects - 17
Issues
Nullity checks
Before using a pointer, ask if it is null
Always check the parameters
1: char* String::getString(){return chars;} 2: void String::setString(char* value){
if (value == NULL) return; 3: length = strlen(value); 4: chars = new char[length+1]; 5: strcpy(value, chars); 6: } 7: int String::equals(String *other){
if (other == null) return 0; 8: if (length != other->length) 9: return 0;
if (length == 0) return 1;//if length != 0, then chars != NULL
10: if (strcmp(chars, other->chars) == 0)11: return 1;12: return 0;13: }
© Copyright Eliyahu Brutman
Chapter 3A –Object ConstructionAnd Overloading
Version 1.0
© Copyright Eliyahu Brutman
Classes and Objects - 19
Table of contents
Lifetime Of Variables Object construction Constructor Destructor Overloading a Constructor Parameter matching
© Copyright Eliyahu Brutman
Classes and Objects - 20
Lifetime Of Variables
Lifetime of an object Lets recall lifetime in “C”
Automatic
On the stack
Allocated when
entering scope
What is a scope?
Static
Global
Static within module
Static within scope
Dynamic
Allocated on heap
Global
Code
Heap
Stack
© Copyright Eliyahu Brutman
Classes and Objects - 21
Initialization
Similar mechanism is used for objects Important to distinguish between
Physical memory allocation
Logical variable initialization When physical memory is set aside for an object, it is not
initialized
Having “garbage” data, from previous memory occupation We need to initialize this memory to a stable state, with “good”
values, for proper execution
© Copyright Eliyahu Brutman
Classes and Objects - 22
Object Creation
Object creation
When an object is created, an initialization method is invoked, to bring the object to its invariant state
This method is called a Constructor
It is a special method, invoked automatically, when an object is born (not physically allocated memory)
It has the same name as the name of the class, that is how a compiler distinguishes it from other methods.
© Copyright Eliyahu Brutman
Classes and Objects - 23
Definition Of A Class
class String {
char* m_str;
int m_len;
public:
String();
char* GetString();
void SetString(char* newStr);
};
String:: String() {
m_len = 0; m_str = NULL;
}
char* String::GetString() {
return m_str;
}
void String::SetString(char* newStr) {
…
}
String.hDeclaration of a class
String.cppDefinition of a class
© Copyright Eliyahu Brutman
Classes and Objects - 24
Destruction
Object destruction
When an object is destroyed
Going out of scope (for automatic variables)
Deallocated globally
Deallocated dynamically (delete operator)
This method is called a Destructor
It is a special method, invoked automatically, when the life cycle of an object ends
It has the same name as the name of the class with a preceding ~
© Copyright Eliyahu Brutman
Classes and Objects - 25
Definition Of A Class
class String {char* m_str;int m_len;
public:String();~String();char* GetString();void SetString(char* newStr);
};
String::String() {
m_len = 0; m_str = NULL;
}
String::~String() {
m_len = 0;
free(m_str);
m_str = NULL;
}
…
String.hDeclaration of a class
String.cppDefinition of a class
© Copyright Eliyahu Brutman
Classes and Objects - 26
Defaults
If I do not declare a constructor, the compiler will generate one for me
If I do not declare a destructor, the compiler will generate one for me
If I do not declare a copying semantics, the compiler will generate one for me
Assignment
Copy construction
We will talk about it more later
© Copyright Eliyahu Brutman
Classes and Objects - 27
Defining Additional Ctors
The Empty Ctor (no parameters) is called the default Ctor It is called when we define an object in the following manner
String s;
If we define the object with initialization data, a different Ctor is invoked, for instance
String s=“hello”; In this case a Ctor with the parameter char* is invoked
© Copyright Eliyahu Brutman
Classes and Objects - 28
Function overloading
Function overloading:Several functionsSame name Different parameters
In C: prohibited In C++: allowed
Also for constructorsAt each call site, compiler finds the target function by matching the parameters
© Copyright Eliyahu Brutman
Classes and Objects - 29
Definition Of A Class
class String {char* m_str;int m_len;
public:String();String(char*);~String();char* GetString();void SetString(char* newStr);
};
String::String() {
m_len = 0; m_str = NULL;
}
String::String(char* str) {
m_len = strlen(str);
m_str = new char[m_len+1];
strcpy(m_str, str);
}
String::~String() {
m_len = 0;
free(m_str);
m_str = NULL;
}
…
String.hDeclaration of a class
String.cppDefinition of a class
We have here 2 functions with the same name !!How is it possible ?
© Copyright Eliyahu Brutman
Classes and Objects - 30
Overloading
Overloading is declaring the same function name more than once
In “C” this would result in compilation error C++ permits this
If the function have different parameters
It performs “name mangling” (decoration) to produce different symbols for each function
Upon method call, resolving should be taken to decide, which function should be actually called
The caller “sends a message”
The actual method is invoked after the compiler performed the suitable matching
© Copyright Eliyahu Brutman
Classes and Objects - 31
How is it done?
Name mangling
Compiler encodes parameter types in the method name
Compiler void h(int) void h(int,char)
void h(void)
GNU gcc 3.x, IA64 compilers
_Z1hi _Z1hic _Z1hv
GNU gcc 2.9.x h_Fi h_Fic h_Fv
Microsoft Visual C++ v6, v7
?h@@YAXH@Z ?h@@YAXHD@Z ?h@@YAXXZ
© Copyright Eliyahu Brutman
Classes and Objects - 32
Parameter Matching
In C++, parameter matching is performed, in the following order
Exact matching is examined
Built in type matching
User defined matching
If suitable Ctor exists
Casting is defined In our example … Parameter passing
By value
By pointer
By reference (we will talk more about it later…)
© Copyright Eliyahu Brutman
Classes and Objects - 33
Using constructors: String
int main(){String str; String str2(“Hi”); String str3 = “Hello”;foo (str3); //foo declared as foo(String)
}
Calls String() Calls String(“Hi”)
Calls String(“Hello”)
Calls copy-constructorString(const String& other)
© Copyright Eliyahu Brutman
Classes and Objects - 34
Copy-constructors
Single parameter – reference to the copied objectclass X{ public X(const X& x); }
Called by the compilerWhen an object is initialized using another object of the same class X x; X x1(x);
When an object is passed by value void foo(X xparam);foo(x);
If no copy-constructor defined, compiler adds oneBitwise copy of the copied objectNot always fits
© Copyright Eliyahu Brutman
Classes and Objects - 35
String copy-constructor
char* String::getString(){return chars;}String::String(const String& other){
length = other.length; chars = new char[length+1];strcpy(other.chars, chars);
}
String.cpp