CMPS 221 - Lab 5

Lab 5 - Formating output with printf and cout

Part 1: Formating with printf

The printf() function is the C-style method of printing output to the screen. Pure C programs will use printf() for output instead of cout. To use the printf() function, you have to include stdio.h and als make a function call. The function call can take multiple arguments. The first argument is always a format string. The format string can be either just a plain string similar to what we've sent to cout (in which case it is the only argument to printf) or a string with formating tokens embedded in it. The formating tokens dictate how to display certain datatypes. It takes the form:

%[-][0][col][.prec]type

The - character is optional and will left justify the text (right justify is the default if - is omited).
The 0 character is optional and will pad the unused space with 0's. If 0 is omitted, spaces will be used for pad characters.
"col" is an integer for the column width. It is optional. If left off, the column will be wide enough to hold the variable.
".prec" is an integer preceeded by a decimal point for the number of digits of precision to use for doubles and floats. It is optional. If left off, the default precision will be used.
The type is a single character that represents the datatype of the variable. It is d for an integer, f for a double (or float) and c for a character. There are other types available. See man printf for a list.

Examples:

Print an integer named num
```
printf("%d", num);
```
Print a double named dnum
```
printf("%f", dnum);
```
Print a double named dnum with 2 decimal places of precision
```
printf("%.2f", dnum);
```
Print an integer named num in a 10 character wide column
```
printf("%10d", num);
```
Print a double named dnum in a 10 character wide column with 3 decimal places of precision
```
printf("%10.3f", dnum);
```
Print an integer named num in a 10 character wide column that is left justified
```
printf("%-10d", num);
```
Print an integer named num in a 10 character wide column with 0 padding and right justification
```
printf("%010d", num);
```

Take the following program and input it into a file on Helios. You can copy and paste on the lab machines by highlighting the text with your mouse, switching over to your Helios terminal, starting vi (or pico) and going into insert mode and then clicking the scroll wheel to paste. Compile and run the program once you have pasted it over.

#include <iostream>
#include <stdio.h>
using namespace std;

int main()
{
  int num1, num2;
  double dnum1, dnum2;

  printf("Enter two integers: ");
  cin >> num1 >> num2;
  printf("Enter two doubles: ");
  cin >> dnum1 >> dnum2;

  printf("%d %d %f %f.\n", num1, num2, dnum1, dnum2);
  printf("%10d %10d %10f %10f.\n", num1, num2, dnum1, dnum2);
  printf("%010d %-10d %10.2f %10.4f.\n", num1, num2, dnum1, dnum2);

  return 0;
}

Part 2: Formating with cout

The cout object can also be used to format output. The method is not as straight-forward as with printf. To format cout output, you must include the iomanip library. This will give you access to several functions, as detailed below:

setw(<intExpr>) - Set the width of the column. It has to be within a cout statement. Example:
```
cout << setw(10) << num;
```
precision(<intExpr>) - Set the precision for the output. Should be combined with setting fixed and showpoint (see below) for best looking output. Example:
```
cout.precision(4);
```
setf(<flag>) - Set a certain flag on the iostream. Common flags are:
- ios::fixed - Use fixed point (decimal) notation instead of scientific notation. Example: cout.setf(ios::fixed);
- ios::showpoint - Show trailing 0's in the precision for float/double. Example: cout.setf(ios::showpoint);
- ios::right - Use right justification. Example: cout.setf(ios::right);
- ios::left - Use left justification. This will not work if you have previously set right justification and have not called unsetf (see below). Example: cout.setf(ios::left)
unsetf(<flag>) - Clear a flag on the iostream. It uses similar flags to setf. Example: cout.unsetf(ios::right);
You can also set the precision within the cout statement. Example:
```
cout << setprecision(2) << fixed << showpoint << dnum;
```
left - Do left justification until right justification is set. Example:
```
cout << left << num;
```
right - Turn off left justification and go back to right justification. Example:
```
cout << right << num;
```

Look at the code in lab5_example.cpp. This code creates the following output using cout manipulators:

integer output
right justify: |         5|
 left justify: |5         |

double output (2 precision)
right justify: |      5.50|
 left justify: |5.50      |

A small table without borders:
Name      Integer   Double
Alice              5      6.20
Bob                8     13.34
Carol             12     19.00

Copy the file over to your current directory using the following command (note: there is a dot at the end of the command, this represents the current working directory is the destination of the copy command):

cp /home/fac/melissa/public_html/cs221-f09/lab5_example.cpp .

Compile and run the code. You should see output similar to above.

Part 3: Lab assignment

Recreate the output of lab5_example.cpp using printf() in a file called lab5.cpp. Email your completed lab5.cpp to my Helios account.