Main Index

1. Chapter 1 – Introduction to Object Technology 1 Main Index Contents • 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. Containers such as vectors, lists or maps are storage structures that provide ways to access data and insert/delete items. Airlines and telecommunication companies use a grid of nodes and interconnecting edges to represent cities and routers in a network. Storage Containers ( General ) Example

3. Output: 7 4 9 3 1 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] << " "

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. 11 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. 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. 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 // rectangle class rectangle { public: // constructor. initializes length and // width rectangle(double len = 0.0, double wid = 0.0): length(len), width(wid) {} CLASS rectangle Declaration “d_rect.h” 19 Main Index Contents

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

18. // 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; } CLASS rectangle Declaration “d_rect.h” 21 Main Index Contents

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

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

21. 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 …. API ( Operations )

22. CLASS randomNumber “d_random.h” Constructors 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 API ( randomNumber Class)

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

24. 27 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. 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. String Functions and Operations

26. 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. String Functions and Operations

27. 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. String Functions and Operations

28. 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. String Functions and Operations

29. 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. String Functions and Operations

30. 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 String Functions and Operations

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. 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. 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. 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. 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. 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.