CISC105: Reading Notes
Tan and D'Orazio, Chapter 2

by Phill Conrad, Asst. Professor,
CIS Dept, University of Delaware

See reading notes for Chapter 1 for discussion of the purpose of these reading notes.

What to emphasize in Chapter 2

Chapter 2 contains very basic and useful information about getting started with C programming. It is pretty well written and easy to follow, and you should read it through in its entirety.

You may want to have a computer terminal handy as you read, so that you can try out the programs that are given in the text as you read about them. You are more likely to succeed if you "play around" with the programs, experimenting with them as you learn about the C language.

The Chapter is divided into the following sections

• five "lessons" (lesson 2.1, 2.2, 2.3, 2.4 and 2.5)
• two "application programs" (2.1 and 2.2)
• a collection of "application exercises"

The five "lessons" will teach you about five basic concepts in the C programming language. The two "application programs" are examples that try to pull everything you've learned so far together. The "application exercises" are chances for you to try out what you've learned.

Chapter 2, Tan and D'Orazio (1999)

Lesson 2.1: Basic Structure

A few observations about this lesson:

1. The first program you write doesn't have any comments in it. You'll learn about comments in Lesson 2.2. This is probably that last time you should ever write a program with no comments.
   
2. One of the things you need to get out of this section is that
   #include <stdio.h>
   is a pre-processor directive. Be sure you read about pre-processor directives and understand what the #include directive does. Figure 2.1 should help.
3. The program in your text reads as follows:
   

     #include 
     void main(void)
     {
         printf("This is C!");
     }
   

   However, as it turns out, this might result in some "warnings" on some compilers. If so, you might want to try this instead:
   

   #include 
   int main(void)
   {
       printf("This is C!");
   	return 0;
   }	
   

   
   The main difference here is that this program has int in front of main instead of void. This causes us to have include one extra line of code: the return 0; that appears near the end of the program. The purpose of this line is to return a value of 0 to the operating system when the program is complete to let the operating system know that the program was successful. It is not always strictly necessary to do this, however it is a good habit to develop. I may say more about this in lecture.
4. Another thing you should pick up from this section is that main is the name of a function. Every program must have exactly one function called main. Execution always starts in the main function.
5. You should also pick up from your reading in this section what a string literal or string constant is, as well as the fact that printf is the name of a function. You should also pick up that { and } are called braces, and that they are used to enclose a block of code.
6. You should know what tokens are, and what white-space characters are. You should also be able to explain why it is important for a program to look a certain way, even though the compiler may not care how things are spaced out.
7. Reviewing figure 2.3 is a very good idea!

Exercises (p. 44)

Exercises 1b and 1e are a bit tricky.

1b asks whether it is true that "by default, any C statement is location sensitive". However, "location sensitive" is not clearly defined (or, if it is, I missed it.). I think the idea that the exercise is getting at is that you can insert an arbitrary number of spaces, tabs and blank lines in between tokens, thus "changing the location" of the various parts of a C statement. In that sense, C is not "location sensitive".

1e asks whether main (){} is a complete and correct C program. This is a bit of a trick question in my opinion. It turns out that some compilers will accept this program, so one could argue that the statement is true. However, this program does no useful work. So in that sense, it is, to say the least, a very silly program.

Be careful as you answer 1d. It is a fair question, but you need to read the carefully before answering; there is a trick there.

Apart from that, the remainder of the exercises on pages 44 through 46 are reasonable and you should try them before continuing.

Lesson 2.2: Writing Comments

This lesson is a good overview of the rules regarding comments. Here are a few remarks about this lesson.

First, some of you may have been exposed to another style of comment where you use two slashes // to indicate the start of a comment. This is valid in C++ and Java, but you should not use that style of comment in this course, since it is not part of standard C. (In CISC181, you'll be able to use that kind of comment to your heart's content.)

Seciond, on page 48-49, there is a discussion of nested comments. Nested comments can arise when we use the comment mechanism to "comment out" a line of code to temporarily remove it from a program. However, is a better way of temporarily removing a line of code from a program, as shown below.

Your book suggests that you can remove a line of code by putting comment brackets around it as follows:

  /* printf("How do we write comments in C?");*/
  

#if 0
   printf("How do we write comments in C?");
#endif   

Welcome toLondon!