Advanced Input and Output

1
Advanced Input and Output
Lecture 9

• COSC1567
• C Programming

2
Objectives

• How cout and cin possess the same traits as other
  C objects
• How to use istream member functions, particularly
  get(), ignore(), and getline()
• How to use ostream member functions, particularly
  setf(), unsetf(), width(), and precision()
• How to create your own manipulator functions

3
Objectives

• How to use built-in manipulators
• How to create a manipulator that takes an
  argument
• About computer files and the data hierarchy
• How to perform file output
• How to read a file from within a program
• How to write class objects to files
• How to read a data file into class objects

4
Understanding CIN and COUT as Class Objects

• You can think of cout and cin as real-world
  objects
• Like other C objects you have created, cout and
  cin are members of a class
• Their class is derived from another class (which
  is derived from yet another class), so they use
  inheritance
• The cout and cin objects can take advantage of
  overloaded operators such as ltlt and gtgt which are
  used for shifting bits in other contexts

5
Understanding CIN and COUT as Class Objects

• When you include iostream.h in a program, you are
  including a file that contains the definition for
  a derived class named iostream
• In C, a stream is a sequence of characters used
  to perform input and output operations
• The name iostream is short for Input and Output
  stream

6
Using istream Member Functions

• In C, the easiest way to read in a character is
  to use cin with the extraction operator, for
  example, cingtgtsomeVariable
• The extraction operator is actually an overloaded
  function named operatorgtgt()

7
Using the get() Function

• Another member function of the istream class is
  get()
• The get() function takes a character argument and
  returns a reference to the object (the istream
  class) that invoked the get() function
• Therefore more than one get() function can be
  included in a statement
• Its prototype has the following form
• istream get(char c)

8
Using the get() Function

• Most compilers overload get() so that, in
  addition to taking a character reference as an
  argument, it also can take no argument
• The following version of the get() function
  returns the character being read in as an integer
• Its prototype is
• int get( )
• The third argument is the character that
  terminates the entry, often called the delimiter
  character
• The default value to stop data entry, as you can
  see from the prototype, is the Enter key, which
  coded as \n

9
Using the get() Function

• The second argument of the get() functionthe
  number of characters to be storedis very
  important
• Without the second argument, a user could destroy
  memory by entering a string of characters that
  was longer than the area prepared to receive it
• The output in Figure 10-3 and 10-4 illustrate one
  benefit of using the get() function instead of
  the extraction operator (gtgt) for keyboard data
  entry

Ex9-1.cpp
10
Using the get() Function

• One unfortunate side effect of the get() function
  is that it leaves unused characters in the input
  stream
• A subsequent call to get() retrieves the next
  (unused) character, whether or not that retrieval
  was intended
• As shown in Figure 10-6, the program doesnt stop
  to obtain your grade, because the second call to
  get() already has been satisfied with the newline
  character

11
The UserNameAndGrade Program
Ex9-2.cpp
12
Using the get() Function

• The program output shown in Figure 10-6 includes
  your first name and a newline (instead of a
  grade) for the letter grade
• To allow the user to enter a grade, you could add
  a third cin.get() statement to the program, as
  shown in Figure 10-7

13
Using the get() Function

• Programmers say this call to the get() function
  absorbs or consumes the extra character

14
Using the get() Function
Ex9-2.cpp

• If you run the program in Figure 10-7 and enter a
  name that is too long, the output looks like
  Figure 10-9

15
Using the ignore() Function

• It is impossible to guess how many cin.get()
  statements are needed to consume all the
  potential additional letters of a name if you use
  the UserNameAndGrade2 programimagine the
  challenge of a name such as Barbara Penelope
• A superior alternative is to use the ignore()
  function to ignore or skip any additional
  characters left in the input stream
• The prototype of the ignore() function is
• istream ignore(int length 1, char c \n)

16
The UserNameAndGrade Program Using ignore()
Ex9-2.cpp
17
Using the ignore() Function
18
Using the getline() Function

• As an alternative to using an extra call to get()
  to absorb the Enter key after character data
  entry, or using the ignore() function to absorb
  any number of characters, you can include another
  istream member, getline()
• Its prototype is
• istream getline(char str,int len, char c\n)
• The getline() function reads a line of text at
  the address represented by str
• It reads text until it reaches either the length
  used as the second argument or the character used
  as the third argument

19
Using the getline() Function

• The program in Figure 10-13, and the output in
  Figure 10-14, show how the getline() function
  correctly accepts characters up to and including
  the default newline delimiter

20
Using the getline() Function

• When you use a delimiter other than \n with
  getline(), the getline() consumes the delimiter
  but leaves he subsequent Enter key in the input
  stream, so you still must account for it
• The program in Figure 10-15 and its output in
  Figure 10-16 illustrate the use of get() to
  consume the Enter key by getline()

21
Using the getline() Function
Ex9-3.cpp
22
Other istream Member Functions

• Most compilers support other istream member
  functions with names such as eof(), bad(), and
  good()
• The istream class is not mysterious
• It is just a class, and cin is just an object
  that already has been instantiated for you

23
Using ostream Member Functions

• The concepts you have learned while studying the
  cin object apply to the cout object as well
• The ostream class supports member functions and
  overloaded operators just like the istream class
  or any other class, for that matter

24
Using Format Flags with setf() and unsetf()

• Many of the states of the cout object are
  contained in a single long integer field, in
  which each bit represents some condition of the
  object
• The arguments that determine the state of the
  cout object are called format flags or state
  flags
• All format flags begin with ios
• One member function of the ios class, the setf()
  function, takes arguments that set the bits of
  cout that is, the arguments turn the bits in the
  flag on or off
• Another member function, unsetf(), can be used to
  deselect the bit cout.unsetf(iosshowpos)
• Using the setf() function, you also can combine
  format flags using the bitwise OR operator ()

25
Using Format Flags with setf() and unsetf()

• Some commonly used format flags are
• iosleftleft-justifies output within the field
  size, which may be set by the width() function
  (described in a following section)
• iosrightright-justifies output within the
  field size
• iosdecformats numbers in decimal (base 10)
• ioshexformats numbers in hexadecimal (base 16)
• iosoctformats numbers in octal (base 8)
• iosshowposinserts a before positive numbers
• iosshowpointdisplays the decimal point and six
  decimal positions for all floating-point numbers

26
Using the width() Function

• You can change the output field width with the
  iostream member width() function
• This function defines the size of the output
  field in which the passed argument will be
  displayed
• The width() function applies only to the first
  subsequent field to be output

27
Using the width() Function
Ex9-4.cpp
28
Using the precision() Function

• You can use the precision() function to control
  the number of significant digits you see in the
  output
• If you want to control the number of positions
  shown to the right of the decimal point (instead
  of simply the number of significant positions
  visible), you must combine cout.setf(iosfixed)
  and cout.precision()

29
Using the precision() Function
Ex9-5.cpp

• Declare an array of doubles, assign values with
  different numbers of significant digits, and then
  display all the values using the same precision

30
Creating Manipulator Functions

• If you need to display a variable named
  amountMoney in currency format with a dollar
  sign, in base 10, in a field size of eight, you
  might write the code shown in Figure 10-20
• When you create a manipulator function, the
  desired results become much clearer
• A manipulator function is used to manipulate, or
  change, the state of the cout object

31
Creating Manipulator Functions
Ex9-6.cpp

• You could write a manipulator to format output as
  currency
• The function contains statements that display the
  dollar sign, set some ios flags, and set the
  width
• In the function shown in Figure 10-21, a
  reference to ostream is passed into the function
  as an argument

32
Using Built-In Manipulators

• Some manipulators are so useful that they are
  already coded and placed in libraries included
  with your C compiler
• You already have used the endl manipulator to
  output a newline character and flush the output
  stream

33
Using the setprecision() Manipulator

• You use the setprecision() manipulator to specify
  the number of decimals that will print
• The setprecision() manipulator works like the
  precision() functionit specifies the number of
  significant digits to display
• It is considered a manipulator instead of a
  member function because you chain a call to
  setprecision() along with other output and the
  insertion operator, rather than using an object
  and a dot operator, as you do with
  cout.precision()

34
The DemoPrecision2 Program
35
Using the setprecision() Manipulator
Ex9-7.cpp

• Any C manipulator, such as setprecision(), that
  takes an argument requires the inclusion of the
  iomanip file in your program
• The program in Figure 10-22 produces the output
  in Figure 10-23

36
Using the setw() Manipulator

• The setw() manipulator allows you to set the
  width of a field for output
• Use of the setw() manipulator requires inclusion
  of the iomanip.h file, because setw() requires an
  argument that represents the width of the output
  field
• The setw() manipulator works like the width()
  member function you can use with the cout
  objects the advantage of using setw() is its
  chaining capability in a cout statement

37
Using the setiosflags() and resetiosflags()
Manipulators
Ex9-8.cpp

• Two additional manipulators, setiosflags() and
  resetiosflags(), each perform several
  manipulations, depending on the flags (such as
  iosdec or iosshowpoint) they receive as
  arguments
• The setiosflags() manipulator turns on bit codes
  for the attributes named as arguments the
  resetiosflags() manipulator turns off those bit
  codes

38
Understanding Computer Files

• When you store data items in a computer system,
  you use a permanent storage device, such as a
  disk or a reel of magnetic tape
• The term permanent is used to contrast this type
  of data storage with the temporary data storage
  that exists in computer memory
• Data items typically exist in memory for only a
  short time
• It is common practice to store data in a data
  hierarchy, which represents the relationships
  between the sizes of data units that business
  professionals most often use

39
The fstream Family Tree
40
Using the getline() Function

• If a file contains data that ends with a newline
  character, then its a bit awkward to have a
  program that uses the get() function to read data
  from a file because you must discard the newline
  character
• As an alternative, you can use the getline()
  member function to read input data
• The getline() function takes the form
  fileObject.getline(destination, sizeLimit),
  where destination is a declared character string,
  and sizeLimit is the maximum number of characters
  you want to store

41
Using the getline() Function
Ex9-9.cpp

• Write a program that uses getline() to read the
  name file created in the WriteNameToFile.cpp
  program

42
Using the getline() Function
Ex9-10.cpp
43
Writing Objects to Files

• It is simple and intuitive to use the ofstream
  classs overloaded operator to write characters
  and strings to files
• It makes sense, however, that in object-oriented
  programs you should also be able to write objects
  to disk files
• The write() function allows you to do just that
  the prototype is
• ostream write(char c, int length)
• The write() function accepts two arguments a
  pointer to a character and an integer

44
The Customer Class
45
Writing Customer Records to a File
Ex9-11.cpp
46
Writing Objects to Files

• You can create an array of customer objects,
  perform the data entry required for the
  Customers, and write the output to a disk (see
  the format on page 394 of the textbook)
• The program in Figure 10-40 executes a for loop
  numCusts times (five times), performing data
  entry and writing to the file each time

47
Writing an Array of Customer Records to a File
48
Reading Objects from Files
Ex9-12.cpp

• It is more convenient to read a data file
  directly into an array of class objects
• You can accomplish this goal with the read()
  function
• The read() function prototype is quite similar to
  the prototype for the write() function
• The prototype for read() is
• istream read(char c, int length)
• The read() function requires a pointer to a
  character, so you must perform a cast when you
  read an object

49
Reading Customer Records from a File
50
Reading Objects from Files

• The read() function also requires the size of
  the object being read
• Instead of reading one record at a time into the
  Customer array, you can perform one read for the
  entire array

51
Reading an Array of Records
52
Summary

• The C objects cout and cin possess the same
  traits as other C objectsthey are members of a
  class, use inheritance, have access to overloaded
  operators, and have all other object traits
• To input data, you can use the extraction
  operator (gtgt) after the cin object
• To output data you can use the insertion operator
  with the cout object
• A manipulator function is used to manipulate, or
  change, the state of the cout object

53
More examples

• Ex9-13.cpp
• Ex9-14.cpp
• Ex9-15.cpp

54
Summary

• Built-in manipulators include endl, newline,
  setprecision(), setw(), setiosflags(), and
  resetiosflags()
• Creating a manipulator that takes an argument
  involves writing two functions
• The address of the stream and the argument itself
  must be passed to the manipulator function
• Usually, you store data on a disk (or other
  permanent storage device) in a data hierarchy in
  which fields are parts of data records that make
  up data files

55
Summary

• To perform file output, you must instantiate your
  own member of the ofstream class
• To read a file from within a program, you can
  create an object that is an instantiation of the
  ifstream class
• The write() function allows you to write class
  objects to files
• The write() function accepts two arguments a
  character pointer to the address of the argument
  being written to the file, and the size of the
  object being written
• You can use the read() function to read a data
  file into class objects