Storage Containers

1
Chapter 1 Introduction to Object Technology
Storage Containers -General -Vectors (3
slides) -Lists -Maps ADTs (2 slides) Classes -D
eclaration -Private/Public Sections (3
slides) time24 function addTime()
Scope Resolution Operator Rectangle Class (4
slides) API -Constructor -Operations -randomNumbe
r Class (2 slides) Generating Random
Numbers String Functions and Operations (6
slides) Summary Slides (9 slides)
2
Storage Containers ( General )
Example
3
(No Transcript)
4
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 lt
v.size() i) cout ltlt vi ltlt " "
5
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.

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

7
(No Transcript)
8
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.

9
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
10
A search tree holding airbill numbers

• The tree holds 8 elements. Any search requires at
  most 3 movements along a path from the root.

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

12
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

13
Classes( Declaration )
14
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.

15
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

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

17
Runtime execution of the time24 function
addTime()
18
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 classNamefunctionName(argument
list) ltC statementsgt
19
(No Transcript)
20
(No Transcript)
21
(No Transcript)
22
(No Transcript)
23
API( Constructor )
24
API ( Operations )
25
API ( randomNumber Class)
26
API ( randomNumber Class)
27
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 lt 5 i) item
rndA.random(40) // 0 lt item lt 40 x
rndB.frandom() // 0.0 lt x lt
1.0 cout ltlt item ltlt " " ltlt x
28
String Functions and Operations
29
String Functions and Operations
30
String Functions and Operations
31
String Functions and Operations
32
String Functions and Operations
33
String Functions and Operations
34
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.
35
Summary Slide 2

• - Arrays have some limitations
• fixed size.
• No automatic growth to meet the needs of an
  application. (Solution -gt Use Vector Containers)
• insertion and deletion inside the array requires
  the costly movement of data either to the right
  or to the left. (Solution -gt Use List Containers)
• - Efficient access to an element requires
  knowledge of its position in the list.

36
Summary Slide 3
- Abstract Data Types (ADTs) are a model used
to understand the design of a data
structure. - ADTs 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.
37
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.

38
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.
39
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.
40
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.

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