1. – Introduction to Object Technology1
Main Index
Contents
Chapter 1
– Introduction to Object Technology
Storage Containers
-General
-Vectors (3 slides)
-Lists
-Maps
ADT’s (2 slides)
Classes
-Declaration
-Private/Public Sections (3 slides)
time24 function addTime()
Scope Resolution Operator
Rectangle Class (4 slides)
API
-Constructor
-Operations
-randomNumber Class (2 slides)
Generating Random Numbers
String Functions and Operations (6 slides)
Summary Slides (9 slides)

2. Storage Containers ( General )
Airlines and telecommunication companies use a grid of nodes and interconnecting edges to represent cities and routers in a network.
Containers such as vectors, lists or maps are storage structures that provide ways to access data and insert/delete items.
Example

3. Storage Containers ( Vectors)
A vector has all of the nice indexing features of an array along with the ability to dynamically grow to meet demand.
// output elements of v
for (i = 0; i < v.size(); i++)
cout << v[i] << " "
Output:

4. Storage Containers ( Vectors)
A vector is a "super-array“, meaning all familiar array algorithms work.
You also have the freedom to to grow or shrink it.

5. Storage Containers ( Vectors)
Vectors allow for direct access to their elements through an index, but are not efficient storage structures for:
insertion of items at arbitrary positions in a list.
deletion of items at arbitrary positions in a list.

6. Storage Containers ( Lists )
list container
each element has a reference that identifies the next item in the list.
Adding a new item involves breaking a link in the chain and creating two new links to connect the item.

7. Storage Containers ( Maps )
maps use a tree structure to store data.
A is a container that stores elements as nodes emanating from a root.
TREE

8. ADT Operation Description11
Main Index
Contents
Abstract Data Types
ADT Operation Description
operationName: Action statement that specifies the input parameters, the type of operation on the elements of the data structure, and the output parameter
Preconditions: Necessary conditions that must apply to the input parameters and the current state of the object to allow successful execution of the operation.
Postconditions: Changes in the data of the structure caused by the operation.

9. Abstract Data Types ( time24 Class )12
Main Index
Contents
Abstract Data Types ( time24 Class )
duration(t): Time t is an input parameter. Measure the length of time from the current time to time t and return the result as a time24 value.
Precondition: Time t must not be earlier than the current time

10. Classes ( Declaration )

11. Classes ( Private/Public Sections)
The public and private sections in a class declaration allow program statements outside the class different access to the class members.

12. Classes ( Private/Public Sections)
Public members of a class are the interface of the object to the program.
Any statement in a program block that declares an object can access a public member of the object

13. Classes ( Private/Public Sections)
The private section typically contains the data values of the object and utility functions that support class implementation.
Only member functions of the class may access elements in the private section.

14. Runtime execution of the time24 function addTime()17
Main Index
Contents
Runtime execution of the time24 function addTime()

15. Scope resolution Operator
The symbol "::" signals the compiler that the function is a member of the class.
The statements in the function body may access all of the public and private members of the class.
The “::” operator allows you to code a member function like any other free function.
returnType className::functionName(argument list) {
<C++ statements> }

16. // maintains measurement properties of a // rectangle19
Main Index
Contents
CLASS rectangle
Declaration
“d_rect.h”
// maintains measurement properties of a // rectangle
class rectangle {
public:
// constructor. initializes length and // width
rectangle(double len = 0.0, double wid = 0.0): length(len), width(wid) {}

17. // return the area (length * width) double area() const 20
Main Index
Contents
CLASS rectangle
Declaration
“d_rect.h”
// return the area (length * width)
double area() const
{ return length * width; }
// return the perimeter (2 * (length + // width))
double perimeter() const
{ return 2 * (length + width); }

18. // change the dimensions of the // rectangle to len and wid 21
Main Index
Contents
CLASS rectangle
Declaration
“d_rect.h”
// change the dimensions of the // rectangle to len and wid
void setSides(double len, double wid) {
length = len;
width = wid; }
  // return the length of the rectangle
double getLength() const
{ return length; }

19. // return the width of the rectangle double getWidth() const 22
Main Index
Contents
CLASS rectangle
Declaration
“d_rect.h”
// return the width of the rectangle
double getWidth() const
{ return width; }
private:
double length, width; };

20. className(<arguments>); Initializes the attributes of the object
API ( Constructor )
CLASS className
Constructors
“<file>.h”
className(<arguments>);
Initializes the attributes of the object
Postconditions: Initial status of the object

21. returnType functionName(argument list);
API ( Operations )
CLASS className
Operations
“<file>.h”
returnType functionName(argument list);
Description of the action of the function and any return value
Preconditions: Necessary state of the object before executing the operation. Any exceptions that are thrown when an error is detected.
Postconditions: State of the data items in the object after executing the operation ….

22. API ( randomNumber Class)
CLASS randomNumber
Constructors
“d_random.h”
randomNumber(int seed = 0);
Sets the seed for the random number generator
Postconditions: With the default value 0, the system clock initializes the seed; otherwise the user provides the seed for the generator

23. API ( randomNumber Class)
CLASS randomNumber
Operations
“d_random.h”
double frandom();
Return a real number x, 0.0 <= x < 1.0
int random();
Return a 32-bit random integer m, 0 <= m <
int random(int n);
Return a random integer m, 0 <= m < n

24. Generating Random Numbers27
Main Index
Contents
Generating Random Numbers
The loop generates 5 integer random numbers in the range 0 to 40 and 5 real random numbers in the range 0 to 1.
int item, i;
double x;
for (i = 0; i < 5; i++) {
item = rndA.random(40); // 0 <= item < 40
x = rndB.frandom(); // 0.0 <= x < 1.0
cout << item << " " << x; }

25. String Functions and Operations
int find_first_of(char c, int start = 0):
Look for the first occurrence of c in the string beginning at index start. Return the index of the match if it occurs; otherwise return -1.
By default, start is 0 and the function searches the entire string.

26. String Functions and Operations
int find_last_of(char c):
Look for the last occurrence of c in the string. Return the index of the match if it occurs; otherwise return -1.
Since the search seeks a match in the tail of the string, no starting index is provided.

27. String Functions and Operations
string substr(int start = 0, int count = -1):
Copy count characters from the string beginning at index start and return the characters as a substring. If the tail of the string has fewer than count characters or count is -1, the copy stops at end-of-string.
By default, start is 0 and the function copies characters from the beginning of the string. Also by default, the function copies the tail of the string.

28. String Functions and Operations
int find(const string& s, int start = 0):
The search takes string s and index start and looks for a match of s as a substring. Return the index of the match if it occurs; otherwise return -1.
By default, start is 0 and the function searches the entire string.

29. String Functions and Operations
void insert(int start, const string& s):
Place the substring s into the string beginning at index start.
The insertion expands the size of the original string.

30. String Functions and Operations
void erase(int start = 0, int count = -1):
Delete count characters from the string beginning at index start. If fewer than count characters exist or count is -1, delete up to end-of-string.
By default, start is 0 and the function removes characters from the beginning of the string.
Also by default, the function removes the tail of the string.
Note that no arguments at all truncates the string to the empty string with length 0

31. 34
Main Index
Contents
Summary Slide 1
§- A data structure is a systematic way of organizing and accessing data.
§- Programmer-defined data structures bundle data with operations that manipulate the data.
§- The structures, called containers have operations to access, insert, and remove items from the collection.

32. §- Arrays have some limitations:35
Main Index
Contents
Summary Slide 2
§- Arrays have some limitations:
fixed size.
No automatic growth to meet the needs of an application. (Solution -> Use Vector Containers)
insertion and deletion inside the array requires the costly movement of data either to the right or to the left. (Solution -> Use List Containers)
§- Efficient access to an element requires knowledge of its position in the list.

33. 36
Main Index
Contents
Summary Slide 3
§- Abstract Data Types (ADT’s) are a model used to understand the design of a data structure.
§- ADT’s specify the type of data stored and the operations that support the data.
§- Viewing a data structure as an ADT allows a programmer to focus on an idealized model of the data and its operations.

34. §- An ADT provides simple and clear description of:37
Main Index
Contents
Summary Slide 3a
§- An ADT provides simple and clear description of:
the input to an operation.
the action of the operation.
its return type.
§- Preconditions: Part of the description of an operation. A listing of the conditions that must apply in order for the operation to execute successfully.
§- Postconditions: Indicate changes to the object's data caused by the operation. Necessary because operations often alter the value of data.

35. 38
Main Index
Contents
Summary Slide 4
§- The private section of a class contains the data and operations that the public member functions use in their implementation.
§- The splitting of a class into public and private parts is known as information hiding.
§- A class encapsulates information by bundling the data items and operations within an object.

36. §- The constructor is a special function with no return type.39
Main Index
Contents
Summary Slide 5
§- The implementation of C++ class member functions is different from the implementation of free functions.
- Each function name must include the class scope operator :: that designates class membership.
§- The constructor is a special function with no return type.
- The constructor initializes the data members of the class by using its initialization list.

37. 40
Main Index
Contents
Summary Slide 6
§- A member function can be implemented inside the class declaration by using inline code.
The semicolon (;) in the function prototype is replaced by the function body.
The compiler inserts the statements in the function body in place of the function, avoiding the function call and return mechanism.
§- The process provides efficiency at the expense of increased code size.

38. §- Application Programming Interface:41
Main Index
Contents
Summary Slide 7
§- Application Programming Interface:
- Allows other programmers to use the public interface of the class without having to view the technical details of the class declaration or implementation.

39. §- C++ provides two approaches to string handling.42
Main Index
Contents
Summary Slide 8
§- C++ provides two approaches to string handling.
Older Method:
C-style string - a character array that designates the end of the string by using the NULL character. §- Used by the C programming language and older C++ programs.
2) Modern Method:
string class - provides a large public interface containing many useful operations.
§- Example: I/O operations.