Lesson 03: Basic I/O Function

#include <stdio.h>
int getchar(void);

The getchar() function proved convenient when you wanted to read data a single character at a time, and it returns the next character from stdin. The character is read as an unsigned char that is converted to an integer. 

Example:

char ch;
ch = getchar(); // Read a single character into the variable ch
printf("You entered the character '%c'\n", ch);

#include <stdio.h>
int putchar(int ch);

The putchar() function writes the character contained in the least significant byte of ch to stdout. It is functionally equivalent to putc(ch, stdout). Because character arguments are elevated to the integer at the time of the call, you can use character values as arguments to putchar().

The putchar() function returns the character written if successful or EOF if an error occurs.

Example:

char ch = 'A';
putchar(ch); // Display the character ch to the console

#include <stdio.h>
char *gets(char *str);

The gets() function reads characters from stdin and places them into the character array pointed to by str. Characters are read until a newline or an EOF is received. The newline character is not made part of the string; instead, it is translated into a null to terminate the string.

If successful, gets() returns str; a null pointer is returned upon failure. If a read error occurs, the contents of the array pointed by str are indeterminate.  Because a null pointer will be returned either when an error has occurred or when the end of the file is reached, you should use feof() or ferror() to determine what has actually happened.

There is no way to limit the number of characters that gets() will read, which means that the array pointed to by str could be overrun. Thus, this function is inherently dangerous. Its use should be limited to sample programs or utilities for your own use. It should not be used for production code.

Example:

char str[100];
gets(str); // Read a string from the console into the character array str
printf("You entered the string: '%s'\n", str);

#include <stdio.h>
int puts(const char *str);

The puts() function writes the string pointed to by str to the standard output device. The null terminator is translated to a newline.

The puts() function returns a non-negative value if successful and an EOF upon failure.

Example:

char str[] = "Hello, world!";
puts(str); // Display the string str to the console

#include <stdio.h>
int main( )
{
    int c;

    printf( "Enter a value: ");
    c = getchar( );

    printf( "\nYou entered: ");
    putchar( c );

return 0;
}

When the above code is compiled and executed, it waits for users to input some text and press enter, the program processes and reads on a single character and displays it as follows:

Enter a value: This is an example

You entered: T

#include <stdio.h>
int main( ) {

   char str[100];

   printf( "Enter a value: ");
   gets( str );

   printf( "\nYou entered: ");
   puts( str );

   return 0;
}

When the above code is compiled and executed, it waits for you to input some text. When you enter a text and press enter, then the program proceeds and reads the complete line till the end, and displays it as follows:

Enter a value: This is an example

You entered: This is an example

#include <stdio.h>
int printf(const char *format, ...);

The printf() function writes to stdout the arguments that comprise the argument list as specified by the string pointed to by format.

The string pointed to by format consists of two types of items.

• The first type is made up of characters that will be printed on the screen.
• The second type contains format specifiers that define how arguments are displayed.

A format specifier begins with a percent sign (%) followed by the format code. There must be the same number of arguments as there are format specifiers, and the format specifiers and the arguments are matched in order. For example, the following printf() call displays "Hi c 10 there!":

printf("Hi %c %d %s", 'c', 10, "there!");

Figure 4.1 shows how the elements of the printf() statement work together to generate the final result.

Figure 4.1: printf() Structure

The output is undefined if there are insufficient arguments to match the format specifiers. The remaining arguments are discarded if there are more arguments than format specifiers.

The printf() function returns the number of characters printed. A negative return value indicates that an error has taken place.

The general format of a printf() format specifiers is as follows:

%[flags][width][.prec][type]code

Optional fields are enclosed in brackets and must appear in the order shown.

#include <stdio.h>
int main (void)
{
    char            c = 'X';
    char            s[] = "abcdefghijklmnopqrstuvwxyz";
    int             i = 425;
    short int       j = 17;
    unsigned int    u = 0xf179U;
    long int        l = 75000L;
    long long int   L = 0x1234567812345678LL;
    float           f = 12.978F;
    double          d = -97.4583;
    char            *cp = &c;
    int             *ip = &i;
    int             c1, c2;

    printf ("Integers:\n");
    printf ("%d <%5d> <%05d> <%-5d> <%+5d>\n", i, i, i, i);
    printf ("%i %o %x %u\n", i, i, i, i);
    printf ("%x %X %#x %#X\n", i, i, i, i);
    printf ("%+i % i %07i %.7i\n", i, i, i, i);
    printf ("%i %o %x %u\n", j, j, j, j);
    printf ("%i %o %x %u\n", u, u, u, u);
    printf ("%ld %lo %lx %lu\n", l, l, l, l);
    printf ("%lli %llo %llx %llu\n", L, L, L, L);
	
    printf ("\nFloats and Doubles:\n");
    printf ("%f %e %g\n", f, f, f);
    printf ("%.2f %.2e\n", f, f);
    printf ("%.0f %.0e\n", f, f);
    printf ("%7.2f %7.2e\n", f, f);
    printf ("%f %e %g\n", d, d, d);
    printf ("%.*f\n", 3, d);
    printf ("%*.*f\n", 8, 2, d);
    
	printf ("\nCharacters:\n");
    printf ("%c\n", c);
    printf ("%3c%3c\n", c, c);
    printf ("%x\n", c);
    
	printf ("\nStrings:\n");
    printf ("%s\n", s);
    printf ("%.5s\n", s);
    printf ("%30s\n", s);
    printf ("%20.5s\n", s);
    printf ("%-20.5s\n", s);
    
	printf ("\nPointers:\n");
    printf ("%p %p\n\n", ip, cp);
    
	printf ("This%n is fun.%n\n", &c1, &c2);
    printf ("c1 = %i, c2 = %i\n", c1, c2);
    return 0;
}

// The results















Integers:
425 <  425> <00425> <425  > < +425>
425 651 1a9 425
1a9 1A9 0x1a9 0X1A9
+425  425 0000425 0000425
17 21 11 17
61817 170571 f179 61817
75000 222370 124f8 75000
1311768465173141112 110642547402215053170 1234567812345678 1311768465173141112

Floats and Doubles:
12.978000 1.297800e+01 12.978
12.98 1.30e+01
13 1e+01
  12.98 1.30e+01
-97.458300 -9.745830e+01 -97.4583
-97.458
  -97.46

Characters:
X
  X  X
58

Strings:
abcdefghijklmnopqrstuvwxyz
abcde
    abcdefghijklmnopqrstuvwxyz
               abcde
abcde

Pointers:
0x7ffc8ae934e4 0x7ffc8ae934e1

This is fun.
c1 = 9, c2 = 17

#include <stdio.h>
int scanf(const char *format, ...);

The scanf() function is a general-purpose input routine that reads the stream stdin and stores the information in the variables pointed to in its argument list. It can read all the built-in data types and automatically converts them into the proper internal format.

The control string pointed to by format consists of three classifications of characters:

• Format specifiers
  The input format specifiers begin with a % sign and tell scanf() what type of data is to be read next.
• Whitespace characters
  A whitespace character in the format string causes scanf() to skip over zero or more whitespace characters in the input stream. A whitespace character is either a blank space, a horizontal tab character ('\t'), a vertical tab ('\v'), a carriage return ('\r'), a newline ('\n'), or a form-feed character ('\f'). In essence, one whitespace character in the control string will cause scanf() to read, but not store, any number (including zero) of whitespace characters up to the first non-whitespace character. 
• Nonwhitespace characters
  A non-whitespace character in the format string causes scanf() to read and discard a matching character. For example, "%d,%d" causes scanf() first to read an integer, then read and discard a comma, and finally read another integer. If the specified character is not found, scanf() will terminate.

All the variables that receive values through scanf() must be passed by their addresses. This means that all arguments must be pointers to the variables.

The scanf() function returns a number equal to the number of fields that were successfully assigned values. This number will not include read but not assigned fields because the * modifier was used to suppress the assignment. EOF is returned if an error occurs before the first field is assigned.

The general format of a scanf() format specifier is as follows:

%[modifier]code

Optional fields are enclosed in brackets and must appear in the order shown.

The C++ compiler also determines the data type of variable to be output and selects the appropriate stream insertion operator to display the value. The << operator is overloaded to output data items of built-in types integer, float, double, strings, and pointer values. The insertion operator << may be used more than once in a single statement, as shown below, and endl is used to add a new-line at the end of the line.

cout << "This " << "is a " << "single C++ statement." << endl;

Chaining insertions is especially useful for mixing literals and variables in a single statement:

int age = 25, zipcode = 90032;
cout << "I am " << age << " years old and my zipcode is " << zipcode << endl;

The output of the previous statement would be:

I am 25 years old and my zipcode is 90032

cin and Strings

The extraction operator can be used on cin to get strings of characters in the same way as with fundamental data types:

string  myString;
cin >> myString;

However, cin extraction always considers spaces (whitespaces, tabs, newline...) as terminating the value being extracted, and thus extracting a string means always extract a single word, not a phrase or an entire sentence.

To get an entire line from cin, there exists a function called getline, that takes the stream (cin) as the first argument and the string variable as the second. For example:

// cin with strings
#include <iostream>
#include <string>
using namespace std;

int main ()
{
    string mystr;
    cout << "What is your name? ";
    getline (cin, mystr);
    cout << "Hello " << mystr << ".\n";
    cout << "What is your favorite team? ";
    getline (cin, mystr);
    cout << "I like " << mystr << " too!\n";
    return 0;
}

The results:

What is your name? Ryan Lin
Hello Ryan Lin.
What is your favorite team? The LA Lakers
I like The LA Lakers too!

In addition to setting or clearing the format flags directly, you can alter the format parameters of a stream through the use of special functions called manipulators, which can be included in an I/O expression. The standard manipulators are shown in the following table:

To use a manipulator that takes a parameter, you must include <iomanip>.

For example:

#include <iomanip>
#include <iostream>
using namespace std;

int main()
{
    double A = 100;
    double B = 2001.5251;
    double C = 201455.2646;

    // We can use setbase(16) here instead of hex

    // formatting
    cout << hex << left << showbase << nouppercase;

    // actual printed part
    cout << (long long)A << endl;

    // We can use dec here instead of setbase(10)

    // formatting
    cout << setbase(10) << right << setw(15)
         << setfill('_') << showpos
         << fixed << setprecision(2);

    // actual printed part
    cout << B << endl;

    // formatting
    cout << scientific << uppercase
         << noshowpos << setprecision(9);

    // actual printed part
    cout << C << endl;

    return 0;
}

The results:

0x64
_______+2001.53
2.014552646E+05

#include <iostream>
#include <iomanip>
using namespace std;
int main() {
    const float tenth = 0.1;
    const float one   = 1.0;
    const float big   = 1234567890.0;

    cout << "A. "                    << tenth << ", " << one << ", " << big << endl;
    cout << "B. " << fixed           << tenth << ", " << one << ", " << big << endl;
    cout << "C. " << scientific      << tenth << ", " << one << ", " << big << endl;
    cout << "D. " << fixed << setprecision(3) << tenth << ", " << one << ", " << big << endl;
    cout << "E. " << setprecision(20) << tenth << endl;
    cout << "F. " << setw(8) << setfill('*') << 34 << 45 << endl;
    cout << "G. " << setw(8) << 34 << setw(8) << 45 << endl;

    return 0;
}

The result:

A. 0.1, 1, 1.23457e+09
B. 0.100000, 1.000000, 1234567936.000000
C. 1.000000e-01, 1.000000e+00, 1.234568e+09
D. 0.100, 1.000, 1234567936.000
E. 0.10000000149011611938
F. ******3445
G. ******34******45

One of the most interesting format flags in the modern iostream library is boolalpha. This flag can be set either directly or by using the manipulators boolalpha() or noboolalpha(). What makes boolalpha so interesting is that setting it allows you to input and output Boolean values using the keywords true and false. Normally, you must enter 1 for true and zero for false. For example, consider the following program:

// Demonstrate boolalpha format flag
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

int main()
{
    bool    b;

    cout << "Before setting boolalpha flag: ";
    b = true;
    cout << b << " ";
    b = false;
    cout << b << endl;

    cout << "After setting boolalpha flag: ";
    b = true;
    cout << boolalpha << b << " ";
    b = false;
    cout << b << endl;

    cout << "Enter a Boolean value: ";
    cin >> boolalpha >> b;
    cout << "You entered " << b;

    system("pause");    // for C++Builder
    return 0;
}

Here is a sample run:

Before setting boolalpha flag: 1 0
After setting boolalpha flag: true false
Enter a Boolean value: false
You entered false

Once the boolalpha flag has been set, Boolean values are input and output using the word true and false. As the program shows, you must set the boolalpha flag for cin and cout separately. Like all format flags, setting boolalpha for one stream does not imply that it is also set for another.