$ man 3 printf
$ man 3 scanf

Getting Organized

The Task

Submitting Your Work

Editors

Compiling

The Programs

1. Write an ansi C program called hello.c that prints out Hello World! on a line.
2. Write an ansi C program called output.c. It should contain the following declarations:

   char c = 'a';
   short s = 55;
   int n = 5;
   long int nn = 22L; /* Can also use = 22l, but the l (ell) looks like a 1 (one) */
   long long int nnn = 33LL /* can also use = 33ll */
   float x = 7.5f;
   double y = 99.1234567;
   long double z = 99.5L;
   char someString[] = "This is some string.";
   		

   BUT DO NOT copy and paste. Type it in.
   
   It should use printf() to produce exactly the following output:

   c as an integer: 97
   c as a character: a
   s is 55
   n is 5
   nn is 22
   nnn is 33
   x is 7.500
   y is   99.12
   z is 99.500000
   someString is This is some string.
   "someString" is "This is some string."
   		

   The last item output, like all the others, should end with a newline character.
   Recall that the printf() function is invoked as printf(format string, additional arguments). In the printf() statements, use the variable names for the additional arguments, not the value of the variable. For example, use printf(" ... ", n), not printf(" ... ", 55).

   Get used to specifying what you expect the output of your program to be BEFORE you write the program. For this program, you want the output to be like this

   • out1
   
   Download this file. Compile your program to have the name output and run it, saving the outut to a file called myOut1. Then use diff to compare your output with the expected output as follows:

   $ output > myOut1
   $ diff myOut1 out1
   $
   

   If the two files are byte-for-byte the same, diff will return silently. If not, fix it.



3. Write an ansi C program called input.c. It should contain the following declarations:

   int a, b, c;
   int scanfReturnValue; 
   		

   Write code to read in values for a, b and c from standard input and then print out the values read. First print out the value returned by scanf in each case. The statement to read in the values and assign them to a, b and c would look like this:

   scanfReturnValue = scanf("%d %d %d", &a, &b, &c);
   printf("scanf returned %d\n", scanfReturnValue);
   printf("a = %d, b = %d, c = %d\n", a, b, c);
   		

   Look at the scanf() statement. The "%d" says you're expecting to read in an int (in decimal/base 10) and the "&" before the a, b and c indicates the address where a, b, c are stored and scanf reads the input values entered and stores them at these addresses. (Remember that C, like java, is pass by value.) Running your program might produce results like this:

   $ 
   $ input
       45
           33
     22
   scanf returned 3
   a = 45, b = 33, c = 22
   $ 
   $ 
   		

   The first 3 lines are echoed program input; the last 2 are program output.
   
   Again, specify expected output, this time with a given input. (This should actually have been done before the program was written.) Download these files
   • in2
   • out2
   
   Run and test your program as follows:

   $ input < in2 > myOut2
   $ diff myOut2 out2
   $
   

   diff should return silently. Try putting some numbers into a file and then redirecting standard input to come from the file, as in:

   $ input < fileName
   		

   What happens if there are ...
   more than 3 numbers in the file?
   fewer than 3?
   none?
   2 integers and then a double like 5 7 15.75?
   some text like 5 7 hello?
   or 5 7 99hello?


4. In the last exercise, you saw how to use scanf() to read in an integer. Of course, you'll want to use it to read in all kinds of values. In this exercise, you'll redo the first exercise, but instead of the variable values being given explicitly with numeric or string literals, they'll be assigned using scanf(). Before, you had

   char c = 'a';
   short s = 55;
   int n = 5;
   long int nn = 22L;
   long long int nnn = 33LL;
   float x = 7.5f;
   double y = 99.1234567;
   long double z = 99.5L;
   char someString[] = "This is some string.";
   

   Now, instead, you'll start with

   char c;
   short s;
   int n;
   long int nn;
   long long int nnn;
   float x;
   double y;
   long double z;
   char someString[128];
   

   We've just removed the r.h.s. of the original declarations/initializations. Except for char someString. This array of char was previously declared with

   char someString[] = "This is some string.";
   

   The r.h.s. tells the compiler to set aside 21 bytes for the char array someString - that's 20 for the characters in the string and one for the null char '\0' that marks the end of the string. Now, we instead declare someString as an array of size 128 (or whatever) so it will have room to hold the string being read in.
   
   And: we'll input a value of This-is-some-string., since scanf reads tokens (except for %c) and would just grab the "This" instead of the entire "This is some string."

   Here are the 2 input files and the expected output (the same for both).

   • in3a
   • in3b
   • out3
   As before, use diff to compare your output with the expected output.

   in3a looks like this, except for the dashed lines:

   -----------------
          97
       55
           5
     22  33
   7.5
   99.1234567
   
   99.5
   This-is-some-string.
   -----------------
   

   in3b is identical to in3a except for the first line

   -----------------
   a
       55
           5
     22  33
   7.5
   99.1234567
   
   99.5
   This-is-some-string.
   -----------------
   

   Some comments on the input files, compared to the original declarations and to each other.

   • The is no l of ll or L or f, etc. at the end of any numbers.
   • The numbers are separated by arbitrary whitespace. scanf as used here is "token oriented" and will just skip whitespace till it finds the next token.
   • Because scanf (as used here) is token oriented, we need to put dashes into "This is some string." to make it "This-is-some-string." or scanf will just read the "This"
   • There are no quotation marks around the "This-is-some-string."
   • In in3a, the first entry, 97, will be read in and assigned to the variable c. Since 97 is an int and not a letter, you need to use

     scanf("%hhd", &c);
     

   • In the input in3b, the only thing changed is that the 97 has been replaced by the letter a. And it is the very first character in the file. Read this using "character oriented input". This will just read the next byte from standard input, whether it's whitespace or not. For this, you would use

     scanf("%c", &c);
     

     The first c is the conversion character, the second is the variable name.
   Also: when reading in the value for someString note that an array name (someString) functions as a pointer to the beginning of the array, so we use

   scanf("%s", someString);
   

   and not

   scanf("%s", &someString);
   

   Write a program called inputOutputa.c. It should be just like the program output.c, except that

   • in the declarations, the variables are not initialized,
   • instead of char someString[], use char someString[128]
   • after all declarations and before any of the printf statements (which don't change in any way), use 9 separate scanf statements to read in values for the declared variables.
   Test your program as follows:

   $ inputOutputa < in3a > myOut3a
   $ diff myOut3a out3
   $
   

   Now copy inputOutput3a.c to inputOutput3b.c. Change only the first scanf statement, so that it uses character oriented input instead of token oriented input. Then test it with

   $ inputOutputb < in3b > myOut3b
   $ diff myOut3b out3
   $
   

   As always, we want diff to return silently.