Programming with C Notes | B.Sc. (Information Technology) Semester 1 | Mumbai University | munotes

5. Effectiveness. Every step must be basic enough that a person could carry it out exactly, with a pencil, in a finite time.

"Set X to the exact decimal value of one third" is not such a step. It is perfectly definite, and you know exactly what is meant, but the digits never end, so nobody can finish performing it. "Set X to 0.3333, correct to four decimal places" is a step. The test is not whether the instruction can be described; it is whether it can be performed.

A useful way to remember the five: an algorithm must stop, must be unambiguous, must know what it is given, must say what it found, and must be made of steps a human could actually perform.

Writing one out: simple interest

This is the first program on your practical list, so it is the first algorithm here.

To calculate simple interest taking principal, rate of interest and number of years as input from user.

The formula is the easy part. Simple interest is SI = (P R T) / 100, where P is the principal, R is the annual rate as a percentage, and T is the time in years.

The algorithm is written as numbered steps, with a Start and a Stop, and nothing else:

Step 1: Start
Step 2: Read P, R, T from the user
Step 3: Set SI = (P * R * T) / 100
Step 4: Display SI
Step 5: Stop

Read it against the five properties. It stops at step 5, so it is finite. Every step means one thing. Step 2 names its inputs. Step 4 produces the output. Every step could be done by hand. It is an algorithm.

Notice what is not in it: no mention of C, no printf, no data types, no semicolons. An algorithm is language independent, and that is the point of writing one. The same five steps become a C program, a Python program or a set of instructions to a clerk with a calculator.

Tracing it

An algorithm is checked by tracing: choosing values, walking the steps in order, and writing down what every quantity holds after each one. A trace table is how you prove to yourself, and to an examiner, that the thing works before a compiler is involved.

Take P as Rs 12,000, R as 8.5 per cent and T as 3 years.

The arithmetic: 12000 times 8.5 is 1,02,000, times 3 is 3,06,000, divided by 100 is Rs 3,060. A trace table with one row per step, and one column per quantity, is a habit worth forming now. In the loop chapters it stops being a formality and becomes the only reliable way to find a bug.

A second one, where a decision appears: the greatest of three numbers

Write a program to find greatest of three numbers using conditional operator.

Her practical names the C construct she wants, and the chapter on the conditional operator writes that program. The algorithm below names no construct at all, because an algorithm never does, and it is the same algorithm whichever one you finally reach for.

Simple interest had no decision in it. Most problems do. The moment a step depends on a comparison, the algorithm branches.

Step 1: Start
Step 2: Read A, B, C
Step 3: If A > B and A > C, then set MAX = A
Step 4: Otherwise, if B > C, then set MAX = B
Step 5: Otherwise, set MAX = C
Step 6: Display MAX
Step 7: Stop

Steps 3, 4 and 5 are one decision with three outcomes, not three separate decisions. Exactly one of them runs, and step 5 can afford to carry no condition at all precisely because steps 3 and 4 have already failed by the time it is reached.

Write them instead as three independent tests and that stops being true. Every one of them would then have to carry a condition of its own, including the last, or MAX would be overwritten with C on every run whatever steps 3 and 4 decided. All three would also be evaluated even after the answer was known.

Trace it with A as 14, B as 27 and C as 9. Step 3 asks whether 14 is greater than both 27 and 9; it is not, so MAX is not set to A. Step 4 asks whether 27 is greater than 9; it is, so MAX becomes 27. Step 5 is skipped because step 4 ran. Step 6 displays 27, which is correct.

Now trace it with all three equal, say 5, 5 and 5. Step 3 fails, because 5 is not greater than 5. Step 4 fails for the same reason. Step 5 runs and MAX becomes C, which is 5. Correct, but only just: the algorithm reaches the right answer through its last resort. Testing the equal case, the all-negative case and the two-equal case is what separates an algorithm that works from one that has only been tried once.

A third one, where the rule itself is the difficulty: the leap year

Write a program to check if the year entered is leap year or not.

Here the coding is trivial and the rule is the whole problem. Most students remember "divisible by 4" and stop. The full rule, as fixed by the Gregorian calendar, has three parts:

• a year divisible by 4 is a leap year,
• except that a year divisible by 100 is not,
• except that a year divisible by 400 is.

So 2024 is a leap year, 1900 was not, and 2000 was. Any algorithm that gets 1900 and 2000 both right has the rule; one that gets either wrong does not.

Step 1: Start
Step 2: Read Y
Step 3: If Y is divisible by 400, then set R = "Leap year"
Step 4: Otherwise, if Y is divisible by 100, then set R = "Not a leap year"
Step 5: Otherwise, if Y is divisible by 4, then set R = "Leap year"
Step 6: Otherwise, set R = "Not a leap year"
Step 7: Display R
Step 8: Stop

This has the same shape as the greatest of three: one decision with four outcomes, exactly one of which runs, and then a single Display that every path reaches. An algorithm with one way out is easier to check and easier to draw than one that finishes in four different places.

The order of the tests is the algorithm. Test 400 first, then 100, then 4, and each test can be simple because the ones before it have already removed the exceptions. Reverse the order and every test needs conditions bolted onto it.

Check it on the years that settle whether a rule is right:

From algorithm to program

Once the algorithm is right, writing the C is mechanical, and the rest of this book is how. The order never changes:

1. Understand the problem, and write down what is given and what is wanted.
2. Write the algorithm, in steps, in ordinary words.
3. Trace it by hand on values you have chosen to be awkward.
4. Only then, translate it into C.
5. Compile it, run it, and check it against the trace you already did.

Step 3 is the one that gets skipped, and skipping it is why a program that compiles cleanly still prints the wrong number. The compiler checks your grammar. Nothing but a trace checks your thinking.

What an examiner can ask on this, and how to answer it

"Define an algorithm and state its characteristics." Give the one-line definition, then the five properties with a word of explanation each. A bare list of five nouns is a weak answer; each property with the failure it prevents is a full one.

"Write an algorithm to ..." Number the steps, open with Start and close with Stop, name your inputs in a Read step, and finish with a Display step. Keep the steps in ordinary words: an algorithm written in C statements is no longer language independent, which is the one thing it exists to demonstrate.

"What is the difference between an algorithm and a program?" An algorithm is a finite sequence of unambiguous steps solving a problem, written in ordinary language, independent of any programming language and not executable by a machine. A program is that algorithm expressed in a particular programming language, following that language's grammar, and executable once translated. One is the solution; the other is the solution written down for a computer.

A trace question. You may be given a short algorithm and asked what it displays for stated inputs. Build the trace table. Do not read the algorithm and guess.

WHILE n > 0 DO
    SET digit = n MOD 10
    SET n = n DIV 10
ENDWHILE

FOR i = 1 TO 10 DO
    PRINT i
ENDFOR

Modules. A named piece of work called from elsewhere.

CALL swap(x, y)

Two conventions carry most of the weight. Keywords go in capitals so the structure can be seen without reading the words. The body of every IF and every loop is indented, and the matching ENDIF or ENDWHILE sits at the same indentation as the keyword that opened it.

The same problem, in steps and in pseudocode

Chapter 1 wrote the simple interest algorithm as five numbered steps. Here it is as pseudocode:

BEGIN
    READ P, R, T
    SET SI = (P * R * T) / 100
    PRINT SI
END

For a problem this small the two notations are equally clear, and the numbered steps are shorter. The difference appears the moment there is a decision, because pseudocode shows you where the branch closes and numbered steps only tell you.

Flowcharts

The symbols

A flowchart is drawn with a fixed set of shapes, and the shape carries the meaning. Using a rectangle where a diamond belongs is a mistake even when the words inside it are right.

Two shapes do the work in nearly every chart a first-year student draws: the rectangle for doing something, and the diamond for asking something.

The rules

1. Every flowchart begins with exactly one START terminal and ends with a STOP terminal.
2. Arrows carry the flow, and every arrow has a head. A line without an arrowhead does not say which way the work goes.
3. A decision diamond has one arrow in and exactly two arrows out, and both are labelled, normally Yes and No.
4. Every other symbol has one arrow in and one arrow out.
5. The chart flows top to bottom and left to right, unless a loop takes it back up.
6. Where two paths finish, they join before the chart carries on, so that the flow after them is drawn once and not twice.

Rule 3 is the one that is broken most often. A diamond with three arrows out is not a decision, it is two decisions that have been drawn on top of each other.

How these are drawn here

The charts below are drawn in text so they read on a phone and in a printout. The shapes stand in for the real ones like this, and in your journal and your answer book you draw the shapes from the table above, not these:

Flowchart 1: simple interest

Her practical, part (a):

To calculate simple interest taking principal, rate of interest and number of years as input from user.

        (  START  )
             |
             v
     / READ P, R, T /
             |
             v
   [ SI = (P * R * T) / 100 ]
             |
             v
      / DISPLAY SI /
             |
             v
        (  STOP  )

There is no decision in it, so the chart is a straight line. Read it against the rules: one START, one STOP, every symbol has one arrow in and one out, and the two parallelograms are input and output rather than processes.

Flowchart 2: the greatest of three numbers

Her practical, part (b):

Write a program to find greatest of three numbers using conditional operator.

Now there are decisions, and the chart earns its keep.

              (  START  )
                   |
                   v
           / READ A, B, C /
                   |
                   v
        < A > B AND A > C ? >--- Yes -->[ MAX = A ]
                   |                          |
                   No                         |
                   |                          |
                   v                          |
           < B > C ? >--- Yes -->[ MAX = B ]  |
                   |                    |     |
                   No                   |     |
                   |                    |     |
                   v                    |     |
             [ MAX = C ]                |     |
                   |                    |     |
                   +<-------------------+<----+
                   |
                   v
           / DISPLAY MAX /
                   |
                   v
              (  STOP  )

The three paths set MAX and then join, and the join is the part beginners leave out. DISPLAY MAX is drawn once, not three times, because whichever branch ran, the work after it is the same.

Follow A as 14, B as 27, C as 9 with your finger. The first diamond asks whether 14 is greater than both 27 and 9, and the answer is No, so you go down. The second asks whether 27 is greater than 9, and the answer is Yes, so you go right into MAX = B. Then you come back to the join, display 27, and stop.

Flowchart 3: the leap year

Her practical, part (c):

Write a program to check if the year entered is leap year or not.

           (  START  )
                |
                v
           / READ Y /
                |
                v
  < Y divisible by 400 ? >-- Yes -->[ R = "Leap year" ]
                |                            |
                No                           |
                |                            |
                v                            |
  < Y divisible by 100 ? >-- Yes -->[ R = "Not a leap year" ]
                |                            |
                No                           |
                |                            |
                v                            |
  < Y divisible by 4 ? >---- Yes -->[ R = "Leap year" ]
                |                            |
                No                           |
                |                            |
                v                            |
     [ R = "Not a leap year" ]               |
                |                            |
                +<---------------------------+
                |
                v
            / DISPLAY R /
                |
                v
           (  STOP  )

Three diamonds in a chain, each with its two labelled exits, and one join at the end. Every process box holds an action, R = "Leap year", and not a bare piece of text. A box containing only the words Leap year would not say what the flowchart is supposed to do with them. Chapter 1 showed why the order has to be 400, then 100, then 4; the chart shows the same fact as a shape, because each No arrow leads into a test that no longer has to worry about the case above it.

The mistakes that cost marks

• A decision with one exit, or three. Two exits, both labelled.
• Unlabelled arrows out of a diamond. The reader cannot tell which branch is which, and neither can you a week later.
• No arrowheads. A flowchart without arrowheads is a picture of some boxes.
• A rectangle used for input. READ and PRINT are parallelograms. This is the commonest shape error.
• Branches that never join. Two copies of the same ending drawn under two branches is a sign the join was forgotten.
• C code inside the boxes. printf("%d", si); in a process box defeats the purpose. Write DISPLAY SI.
• Pseudocode with no closing keyword. An IF without an ENDIF leaves the extent of the branch to the reader's guess.

What can be asked on this, and how to answer it

"Draw the flowchart symbols and state their use." Draw each shape, name it, and give one example of what goes inside it. A named shape with no example is half an answer.

"Write algorithm & draw flowchart for the same." This is her own wording, and both halves are wanted. They must also agree with each other. Write the algorithm first, then draw the chart from it, then check that every step appears in the chart and every box appears in the algorithm.

"What is pseudocode? How does it differ from an algorithm and from a program?" Pseudocode is a structured, language-free way of writing an algorithm, using keywords and indentation but no particular language's grammar. An algorithm may be written in plain English or as pseudocode, so pseudocode is one form an algorithm can take. A program is the algorithm in a real language, which a compiler can translate and a machine can run.

A trace question on a flowchart. You may be given a chart and asked what it prints. Put your finger at START and walk it, writing down each quantity as it changes, exactly as chapter 1 traced a table.

The current published standard is the fifth edition, ISO/IEC 9899:2024, which in the standard's own words "cancels and replaces the fourth edition (ISO/IEC 9899:2018), which has been technically revised."

The names in the last column are what everybody actually says. They are the year, not the edition number, and the fourth edition is called C17 although it was published as 9899:2018, because 2017 was the year its content was fixed.

Which C this book teaches, and why it matters to you

This book teaches C17, the fourth edition, and every program in it is compiled with warnings turned on:

cc -std=c17 -Wall -Wextra program.c -o program

Your prescribed first text is Kernighan and Ritchie, and you should read it, but you should know what it is. The book predates the first standard. Its second edition was rewritten for ANSI C, which is the first edition of the standard, and even that is now four revisions old. Almost everything in it is still exactly right. A few things are not, and they are the things that will confuse you if nobody warns you:

• Old-style function definitions, where the parameter types are listed on separate lines after the parameter names, are gone. The fifth edition removed them outright. Write the modern form, which chapter 32 gives.
• main() with an empty parameter list is not the same as main(void) in older C. Write main(void) when the program takes no arguments.
• Declaring your variables at the top of a function was required by the first edition and has not been since the second. Declare a variable where you first need it.
• // comments were not in the first edition. They are in every edition since.

You can ask your own compiler which standard it is using, because the standard requires it to say:

#include <stdio.h>

int main(void)
{
    printf("__STDC_VERSION__ is %ld\n", __STDC_VERSION__);
    return 0;
}

Compiled with -std=c17, this prints:

__STDC_VERSION__ is 201710

Notice that the printed number has no L on the end, although the table above writes 201710L. Both are right. The macro is defined as the constant 201710L, where the L tells the compiler to treat it as a long, and the value of that constant is the number 201710. The suffix is part of how the constant is written in the source, not part of the number. Constants and their suffixes are chapter 10.

Compile the same file with -std=c99 and it prints 199901 instead. The program has not changed; the rules the compiler is applying to it have.

Why C is still taught first

It would be fair to ask why a language designed for a 1970s minicomputer is the first one on your degree. Three reasons, and none of them are sentimental.

It is small. The whole language fits in a book. There is very little to memorise, and what there is, you have met by the end of this semester.

It hides nothing. A variable is a place in memory, an array is a run of them, and a pointer is the address of one. Languages that came later hide all of that, which is a kindness until something goes wrong. If you learn C first, the later languages feel like conveniences rather than magic.

Nearly everything is built on it. Operating systems, databases, language runtimes and embedded firmware are largely written in C or in languages that borrowed its syntax wholesale. The for loop and the curly brace you are about to learn are the same ones you will meet in C++, Java, C#, JavaScript, PHP and Go.

What can be asked on this, and how to answer it

"Write a short note on the history of C." Give the family line in order, with dates and people: BCPL by Martin Richards in the mid-1960s, B by Ken Thompson in 1969 to 1970, and C by Dennis Ritchie at Bell Labs between 1969 and 1973, developed alongside Unix. Then the standardisation: K&R in 1978, ANSI X3J11 in the mid-1980s, and the ISO revisions since. Say what C added to B, which is the type structure, because that is the part that answers "why a new language at all".

"Why was C developed?" To write an operating system in. It had to be low-level enough to control the machine and portable enough to move Unix to another one, and both of those requirements are visible in the language today.

"What is the difference between C and its predecessors?" B and BCPL were typeless, treating every value as one machine word. C introduced data types, which let the language describe characters, integers of several sizes and floating-point numbers, and let the compiler check what you are doing with them.

return 0; ends main and hands the integer 0 back. By long convention 0 means the program succeeded and anything else means it failed.

The six sections MU's answer wants

Written out in full, a C program can have six sections in this order. The smallest program above has only two of them, which is the point: four of the six are optional and two are not.

Only main is compulsory as a matter of language. The link section is listed as required in practice because a program that prints anything needs stdio.h, and a program that needs nothing from the library needs no header at all.

A program with all six sections in it

This is the same simple interest calculation the lab asks for in its very first practical, written so that each of the six sections is present and labelled.

/*
 * simple-interest.c
 * Simple interest on a deposit, with the calculation in its own function.
 * Documentation section: this comment, and nothing else.
 */

#include <stdio.h>             /* link section */

#define PERCENT 100.0          /* definition section */

double interest(double principal, double rate, double years);
int calls = 0;                 /* global declaration section */

int main(void)                 /* the main function */
{
    double si = interest(15000.0, 8.5, 2.0);

    printf("Simple interest: %.2f\n", si);
    printf("Function calls : %d\n", calls);
    return 0;
}

double interest(double principal, double rate, double years)
{                              /* subprogram section */
    calls = calls + 1;
    return principal * rate * years / PERCENT;
}

Simple interest: 2550.00
Function calls : 1

Four things in that file are worth naming now and learning later.

• / ... / is a comment. The compiler deletes it. It is for the person reading the file, and a comment may run over as many lines as you like.
• #define PERCENT 100.0 makes the preprocessor replace the word PERCENT with 100.0 everywhere below it. It is not a variable. Chapter 22.
• double interest(double principal, double rate, double years); with a semicolon and no body is a function declaration, also called a prototype. It promises the compiler that such a function exists further down, so that main can call it before the compiler has read it. Chapter 32.
• int calls = 0; outside any function is a global variable, reachable from every function in the file. Chapter 21 says why you should nearly always prefer one that is not.

Move the definition of interest above main and the declaration becomes unnecessary, because the compiler will have read the real thing by the time it reaches the call. Both arrangements are correct. The declaration is the one that keeps working when the program grows into more than one file.

The rules that are not negotiable

1. There is exactly one main. No main and the linker fails with an undefined reference. Two and it fails with a duplicate symbol.
2. C is case sensitive. main, Main and MAIN are three different names, and only the first is the starting point.
3. Every statement ends with a semicolon. A function definition header and a preprocessor directive do not, and those are the two places beginners put one.
4. Braces come in pairs, and each { needs its }.
5. A name must be declared before it is used. The compiler reads the file once, downwards.
6. A preprocessor directive occupies its own line and begins with #.

What the structure does NOT mean

A newline does not end a statement. C ignores where you press Return. The whole of the first program can be written on one line and it compiles to exactly the same thing. Indentation and line breaks are for the reader, and they are worth a great deal, but the compiler is not reading them.

main is not called by your program. It is called for you when the program starts, by code the linker puts in. This is why nothing in the file appears to call it.

#include <stdio.h> does not make the program bigger by including a library. The header is a text file of declarations. It tells the compiler what printf looks like; the machine code for printf is joined on later by the linker, which is chapter 5.

return 0; is not what prints the output. It is the value handed back to whatever started the program. Leaving it out of main is legal in C99 and later, where reaching the closing brace of main returns 0 anyway, but write it: it says plainly what you meant, and in every function other than main leaving it out is a real bug.

The six sections are not six blocks of a form. They are the places things may go, in order. A real file usually has three of them.

Quick revision

• A C program is preprocessor directives plus function definitions.
• Exactly one function must be called main. Execution starts there.
• int main(void) returns an int and takes no arguments; 0 means success.
• #include is a directive to the preprocessor, not a C statement, and takes no semicolon.
• A header such as stdio.h supplies declarations, not machine code.
• Six sections, in order: documentation, link, definition, global declaration, main, subprogram. Only main is compulsory.
• Statements end with a semicolon. Braces delimit a block. C is case sensitive.
• A name must be declared before it is used, which is why prototypes exist.

Test yourself

1. Write the smallest C program that compiles, runs and prints nothing.

int main(void)
{
    return 0;
}

It prints nothing at all, so the output block beside it is empty:

It needs no header, because it uses nothing from the library. It compiles clean under -Wall -Wextra and exits with status 0.

2. Name the six sections of a C program in order, and say which are compulsory.

Documentation, link, definition, global declaration, main, subprogram. Only main is compulsory; in practice the link section is present in any program that does input or output.

3. Why must printf be declared before it is used, and where does that declaration come from?

Because the compiler reads the file once and must know the function's return type and parameter types to compile the call correctly. The declaration comes from stdio.h, pasted in by the preprocessor.

4. What is wrong with this?

#include <stdio.h>;

void main(void)
{
    printf("hello\n")
}

Three errors. The directive has a semicolon it must not have. main is declared void, and the standard requires int. The printf statement has no semicolon.

5. Does a comment cost anything at run time?

No. The preprocessor removes comments before the compiler sees the file, so they are not in the finished program at all.

What can be asked on this, and how to answer it

"Explain the structure of a C program." Give the six sections in order with one line each, then draw or write out a short program with the sections labelled, exactly as this chapter does. Say which are compulsory. An answer that lists the six and shows no program is half an answer, and this is the commonest form of the question on this paper.

"What is the purpose of main()?" It is the function where execution begins, and the one function every C program must have. Its return value is reported to the operating system, and 0 conventionally means success.

"What is the use of #include <stdio.h>?" It tells the preprocessor to insert the standard input and output header, which declares the library functions for input and output, printf and scanf among them, so the compiler can check your calls to them.

"Distinguish between a declaration and a definition of a function." A declaration gives the name, the return type and the parameter types and ends in a semicolon; it promises the function exists. A definition gives all of that and the body in braces; it is the function. A file may declare a function many times and must define it once.

"Is void main() correct?" Not in standard C. The standard gives main a return type of int. Some older compilers accept void main(), which is exactly why students write it, and it should not be written.

Three things happened, and each one tells you what the preprocessor is.

• SIDE became 7. Both times. That is all #define does: replace a name with a piece of text.
• SIDE SIDE became 7 7, and not 49. The preprocessor does not do arithmetic. It moved text around and stopped. The multiplication is the compiler's job, and in fact the compiler does it before the program ever runs, because both operands are constants.
• #include and #define are gone, along with the blank line structure, replaced by line markers like # 5 "area.c" that let the compiler report errors against your file rather than against the 554-line stream.

If a comment had been in the file, it would be gone too. The preprocessor removes comments, which is why a comment costs nothing at run time.

Stage 2: the compiler

cc -std=c17 -S area.c -o area.s

-S means stop after compiling, and leave the result as assembly language: text, one instruction per line, for one specific processor. The nine-line program becomes 35 lines of it, beginning like this:

$ sed -n '1,11p' area.s
	.arch armv8-a
	.file	"area.c"
	.text
	.section	.rodata
	.align	3
.LC0:
	.string	"Area of a square of side %d is %d\n"
	.text
	.global	main
	.type	main, %function
main:

You are not expected to read assembly on this paper. Three things in it are worth seeing once.

.arch armv8-a names the processor family. This listing was produced on arm64, and the same program compiled in a lab with an Intel processor produces a different listing that does the same thing. Assembly is not portable; C is. That is the whole argument for a compiled high-level language.

.string "Area of a square of side %d is %d\n" is your text, stored as data. The format string was not turned into instructions, because it is not an instruction. It is a run of characters the program will hand to printf.

main: is a label, and it marks the place where your function's instructions begin. The linker will later look for exactly that name.

Stage 3: the assembler

cc -std=c17 -c area.c -o area.o

-c means compile and assemble, but do not link. The result is an object file, and it is the first thing in this chain you cannot read as text: it holds machine code. What you can read is its table of names, with nm:

$ nm area.o
0000000000000000 T main
                 U printf

Two lines, and they are the whole idea of linking.

• T main means this file defines a function called main, in its text (code) section, at offset 0. T is for text.
• U printf means this file uses a function called printf and does not define it. U is for undefined. There is a hole in the machine code where a call to printf should go, and this file cannot fill it.

The object file is 1,648 bytes on the machine that produced these numbers. Your own will differ, and the number does not matter. What matters is that it is small, because it holds your nine lines and nothing else.

Stage 4: the linker

cc -std=c17 area.o -o area

Now the hole gets filled. The linker takes your object file, finds printf in the standard C library, copies in the machine code for it and for everything printf itself needs, adds the small piece of start-up code that calls main for you, and writes one executable file.

$ stat -c %s area
70312
$ ./area
Area of a square of side 7 is 49

1,648 bytes of object file became a 70,312 byte program. Your nine lines are a tiny fraction of what you are running, and the rest is library and start-up code you did not write and did not have to.

All four in one command

cc -std=c17 -Wall -Wextra area.c -o area

This is what you will actually type. It runs the preprocessor, the compiler, the assembler and the linker in order, keeps none of the intermediate files, and stops at the first stage that fails. -o area names the output; without it the program is called a.out, which is a habit from the earliest Unix and has stuck for fifty years.

Then run it. The ./ is not decoration: it means "in this directory", and without it the shell looks for area in the standard places and does not find it.

./area

Which stage caught your mistake

This is the useful half of the chapter. An error message tells you which tool is complaining, and therefore what kind of thing is wrong. All five below are real messages from gcc 13.3.

The preprocessor cannot find a header. Misspell stdio.h and the chain stops before any C is looked at:

$ cc -std=c17 e1.c -o e1
e1.c:1:10: fatal error: stdioo.h: No such file or directory
    1 | #include <stdioo.h>
      |          ^~~~~~~~~~

The compiler finds a broken statement. Leave out a semicolon and the compiler complains, and notice where: it names line 5, although the missing semicolon is on line 4. The compiler discovered the problem when it read the next thing that could not follow.

$ cc -std=c17 e2.c -o e2
e2.c: In function 'main':
e2.c:5:5: error: expected ',' or ';' before 'return'
    5 |     return a;
      |     ^~~~~~

The linker cannot find a definition. Declare a function, call it, and never write it. Nothing is wrong with your C, so the compiler is satisfied, and the linker is the one that objects:

$ cc -std=c17 e3.c -o e3
/usr/bin/ld: in function `main':
e3.c:(.text+0xc): undefined reference to `twice'
collect2: error: ld returned 1 exit status

The linker cannot find main. Compile a file with functions but no main, and the start-up code is the thing left with a hole:

$ cc -std=c17 e4.c -o e4
(.text+0x1c): undefined reference to `main'
collect2: error: ld returned 1 exit status

A warning is not an error, and matters more. Delete #include <stdio.h> and the program still links and still runs, and gcc tells you that you are calling a function it knows nothing about:

$ cc -std=c17 -Wall -Wextra nohdr.c -o nohdr
nohdr.c:6:5: warning: implicit declaration of function 'printf' [-Wimplicit-function-declaration]
nohdr.c:1:1: note: include '<stdio.h>' or provide a declaration of 'printf'

That is the class of mistake -Wall -Wextra exists to surface. Compile with them always. A program that runs today with a warning is a program that breaks on somebody else's compiler.

What this does NOT mean

The compiler does not produce a runnable program. It produces an object file with holes in it. Only the linker produces something you can run. Saying "the compiler turns C into an executable" is the single commonest error on this topic.

A header is not a library. stdio.h is text: declarations telling the compiler what printf looks like. The machine code for printf lives in a compiled library and is joined on by the linker. This is why a missing header gives a compiler warning while a missing library gives a linker error.

The preprocessor is not part of the C language. It has its own grammar, does not understand types, expressions or scope, and would happily replace a name inside something you never meant. Chapter 22 shows what that costs.

An interpreter is not doing this. In an interpreted language there is no separate translation step and no executable. C compiles ahead of time, which is why a C program starts instantly and why you must compile again after every edit.

cc and gcc are not necessarily different programs. On the machine these transcripts came from, cc is gcc 13.3 reached through another name. On a Mac, cc is usually clang. cc is the portable name, which is why this book uses it.

Quick revision

• Four stages in order: preprocessor, compiler, assembler, linker.
• Preprocessor: text only. Pastes #include, substitutes #define, strips comments. No arithmetic, no type checking. Stop after it with -E.
• Compiler: checks the C and emits assembly for one processor. Stop after it with -S.
• Assembler: assembly text into machine code, giving an object file. Stop after it with -c.
• Linker: joins object files and libraries, resolves every undefined name, adds start-up code, writes the executable.
• nm on an object file shows T name for defined and U name for used but undefined.
• undefined reference is always the linker. expected ';' is always the compiler.
• cc -std=c17 -Wall -Wextra file.c -o file then ./file.

Test yourself

1. Put these in order and say what each produces: linker, assembler, preprocessor, compiler.

Preprocessor, giving expanded C text. Compiler, giving assembly. Assembler, giving an object file. Linker, giving an executable.

2. You get undefined reference to 'average'. Which stage failed, and what are the two likely causes?

The linker. Either you declared or called average and never defined it, or its definition is in another file or library that you did not include in the link command.

3. A program prints the wrong answer. Which stage will find the bug?

None. Every stage succeeded; the program you described is the program you wrote. This is what tracing by hand and testing are for.

4. What does -E do, and why is the output so much longer than the input?

It stops after preprocessing. The output is longer because #include <stdio.h> pastes the whole header in, which is several hundred lines of declarations.

5. After #define N 5, does N * N reach the compiler as 25?

No. It reaches the compiler as 5 * 5. The preprocessor substitutes text and does no arithmetic. The compiler then works out 25 while compiling, because both operands are constants.

6. Why does ./area need the ./?

Because the shell searches only a fixed list of directories for a command name, and the current directory is not normally on that list. ./area says explicitly which file to run.

What can be asked on this, and how to answer it

"Explain the compilation and execution of a C program." Name the four stages in order, say what each takes in and gives out, and name the file at each boundary: .c, then expanded text, then .s, then .o, then the executable. Finish with the run step. A diagram of five boxes and four arrows earns the marks quickly; label the arrows with the tool and the boxes with the file.

"What is the role of the linker?" To resolve names. It joins your object files with the library code for every function you used but did not write, adds the start-up code that calls main, and produces a single executable. Give undefined reference as the error it reports when it cannot.

"Distinguish between the compiler and the interpreter." A compiler translates the whole program once, ahead of time, into machine code, which then runs on its own and runs fast; errors in the whole file are reported before anything runs. An interpreter translates and executes statement by statement every time the program runs, needs the interpreter present to run at all, and reports an error only when execution reaches it.

"What is the purpose of the preprocessor?" To process the file as text before compilation: insert headers, substitute defined names, select code conditionally, and remove comments. Say plainly that it does not understand C, because that is the part examiners are testing.

"A header file and a library file, distinguish." A header is source text holding declarations, read by the compiler so it can check your calls. A library is compiled machine code holding definitions, read by the linker so your calls have something to reach. stdio.h against the C standard library is the example to give.

Both programs have it here, and it is worth seeing how easily one could lose it. Write the formula as principal rate_percent years / 100 with an integer 100 and the answer is still right, because one operand is already a double. Write it as principal (rate_percent years / 100) and it is still right. Write it as (int) principal rate_percent years / PERCENT and it is right only while the principal happens to be a whole number. Integrity is not preserved by good intentions; it is preserved by knowing the rules, which is why chapter 14 on conversions exists.

Integrity also covers what happens on bad input. A program that divides by a number the user typed has no integrity until it checks whether that number is zero.

2. Clarity

Clarity is how easily a reader who did not write it can tell what the program does.

Program A calls its arrays a, b and c. Nothing in the file says which is the rate and which is the number of years, so the expression a[i] b[i] c[i] / 100.0 cannot be checked by reading: you have to go back to the initialisers and count. Program B calls them principal, rate_percent and years, and the same expression becomes a formula you can compare against the one in your textbook.

Clarity in C comes from four cheap things, all visible above:

1. Names that say what the thing is. rate_percent rather than b, and rate_percent rather than rate, because the unit was the thing a reader would have had to guess.
2. A comment saying why, not what. / Simple interest = P R T / 100 / is worth writing. i++; / add one to i / is not.
3. Consistent indentation. Everything inside a block moves right by the same amount. The compiler does not care, and every reader does.
4. One idea to a line. Program B's printf is split across lines so each argument can be seen.

3. Simplicity

Simplicity is doing the job without more machinery than the job needs.

This is the one that cuts both ways, and Program B is longer than Program A. Length is not complexity. Program B has one idea per construct: a function that computes one interest figure, a loop that walks the deposits, a header row. Program A has fewer lines and puts the formula inside the printf call, where it is mixed up with the formatting.

Simplicity is also what stops you writing a[i] b[i] c[i] / 100.0 inside a printf in the first place. A reader now has to hold the formatting and the arithmetic in mind at once, and the two have nothing to do with each other.

4. Efficiency

Efficiency is the time and the memory the program uses.

Here the two programs are effectively identical, and that is the honest answer: at three deposits, nothing you do to this program can be measured. Efficiency matters when the size of the input grows, and the thing that decides it is almost always the algorithm rather than the code. A sort that compares every element with every other takes a hundred times as long on a hundred times as much data, whatever style it is written in.

Do not write an unclear program in the belief that it is a fast one. Program B calls a function three times, which Program A avoids, and on any modern compiler at any optimisation level that call disappears. Choosing bad names to save typing buys nothing at all.

5. Modularity

Modularity is dividing the program into pieces that each do one job and can be understood, tested and changed on their own.

Program A has one piece. Program B has two, and simple_interest is the useful one: it takes three numbers and returns one, it does not print anything, it does not read anything, and it can be tested by calling it with numbers whose answer you already know. That is what a module is for. When the next practical asks for compound interest, Program B gets a second function beside the first and main barely changes.

Modularity is also what makes a program more than one person can work on, and what MU's lab is preparing you for when practicals 4, 7 and 8 all say "using a function".

6. Generality

Generality is how much the program can do without being rewritten.

Neither program is very general: both have the deposits typed into them. Program B is closer, because the count is DEPOSITS in one place rather than the literal 3 in four places, so adding a fourth deposit is two edits rather than five. The genuinely general version reads its input, and that is the version the lab asks for in Practical 1.

Generality has a limit. A program that tries to handle every case nobody asked about becomes large and unclear, which costs you two characteristics to buy one. Make it general where the requirement is likely to change, which for these programs means the data, not the formula.

The ordering, and why it is not negotiable

The single sentence to remember, because it answers the exam question and it is true: make it right, then make it clear, then make it fast, and only if it is actually too slow.

What this does NOT mean

Fewer lines is not simpler. Program A is shorter and harder to read. Compressing two statements onto one line with a comma operator or a nested assignment makes a file shorter and a program more difficult.

Comments do not create clarity. A badly named variable with a comment explaining it is worse than a well named one with no comment, because the comment can go stale and the name cannot. Rename first, comment second.

Efficiency is not about operators. Writing i++ instead of i = i + 1 does not make a program faster; they compile to the same instructions. Efficiency is decided by how much work the algorithm does, which is chapter 35's territory and the reason recursion has to be understood before it is used.

Modularity is not just "use functions". A function of eighty lines that does four unrelated things is not a module. A module has one job, a name that says what that job is, and inputs and outputs you can describe in a sentence.

Portability is a separate property, and it is the one this book's -std=c17 -Wall -Wextra is for. A program that relies on int being four bytes is not portable even if it is clear, simple and correct on your machine. Chapter 9 gives the sizes the standard actually guarantees.

Quick revision

• Six characteristics: integrity, clarity, simplicity, efficiency, modularity, generality.
• Integrity first: a wrong answer produced quickly is still wrong.
• Clarity comes from names, indentation, comments that say why, and one idea per line.
• Simplicity is machinery, not line count. A longer program can be simpler.
• Efficiency is decided by the algorithm, not by the choice of operator.
• Modularity means one job per function, testable on its own.
• Generality means the data is input rather than typed in, and constants are named in one place.
• Make it right, then clear, then fast, and only if it is genuinely too slow.

Test yourself

1. Name the six desirable characteristics of a program.

Integrity, clarity, simplicity, efficiency, modularity, generality.

2. A program gives the right answer and nobody, including its author, can follow it. Which characteristic does it lack, and does it matter?

Clarity. It matters, because every future change to it is a guess, and a guess is how a program loses its integrity.

3. Which two characteristics is #define DEPOSITS 3 serving?

Clarity, because DEPOSITS says what the 3 counts, and generality, because the count is now in one place and can be changed there.

4. Your program takes two seconds on the data you were given and will never be given more. Should you make it faster?

No. Two seconds is fast enough, and any change you make for speed costs clarity and risks integrity. Efficiency is a requirement, not a virtue in itself.

5. Give one change to Program A that improves clarity and costs nothing else.

Rename a, b and c to principal, rate_percent and years. No line is added and the arithmetic becomes checkable by reading.

What can be asked on this, and how to answer it

"What are the desirable characteristics of a program? Explain." Name all six and give one sentence each, and give an example for at least three. Put integrity first and say why it is first. This is bookwork and the marks are in the explanations, not the list.

"What is meant by program clarity? How is it achieved?" Clarity is how easily a reader who did not write the program can tell what it does. Achieved by meaningful names, consistent indentation, comments that give the reason rather than restate the code, small functions with one job each, and avoiding expressions that do several things at once.

"Distinguish between simplicity and efficiency." Simplicity is about the program as a text: no more machinery than the job needs, so that a reader can follow it. Efficiency is about the program as it runs: time taken and memory used. They usually agree, and where they conflict, correctness and clarity come first and efficiency is improved only when the program is measurably too slow.

"Why is modularity important?" Because a program divided into functions that each do one job can be understood, tested and changed one piece at a time, can be worked on by more than one person, and lets a piece be reused instead of rewritten.

The space, and the controls. The space character, plus control characters for horizontal tab, vertical tab and form feed. In the execution set the standard also requires controls for alert, backspace, carriage return and new line.

Escape sequences

Some characters cannot be written directly in a program. A newline cannot go inside a string literal, because the string would run off the end of the line. A double quotation mark cannot go inside a string delimited by double quotation marks. And an alert or a tab has no printable shape to type.

So C writes them with a backslash. The backslash is an escape character: it means "the next character or two is not itself, it is a name".

This program prints the name of each escape sequence and the numeric value it has on the machine that ran it.

#include <stdio.h>

int main(void)
{
    printf("%-16s %-4s %3d\n", "alert",           "\\a",  (int) '\a');
    printf("%-16s %-4s %3d\n", "backspace",       "\\b",  (int) '\b');
    printf("%-16s %-4s %3d\n", "form feed",       "\\f",  (int) '\f');
    printf("%-16s %-4s %3d\n", "new line",        "\\n",  (int) '\n');
    printf("%-16s %-4s %3d\n", "carriage return", "\\r",  (int) '\r');
    printf("%-16s %-4s %3d\n", "horizontal tab",  "\\t",  (int) '\t');
    printf("%-16s %-4s %3d\n", "vertical tab",    "\\v",  (int) '\v');
    printf("%-16s %-4s %3d\n", "backslash",       "\\\\", (int) '\\');
    printf("%-16s %-4s %3d\n", "single quote",    "\\'",  (int) '\'');
    printf("%-16s %-4s %3d\n", "double quote",    "\\\"",  (int) '\"');
    printf("%-16s %-4s %3d\n", "question mark",   "\\?",  (int) '\?');
    printf("%-16s %-4s %3d\n", "null character",  "\\0",  (int) '\0');
    return 0;
}

alert            \a     7
backspace        \b     8
form feed        \f    12
new line         \n    10
carriage return  \r    13
horizontal tab   \t     9
vertical tab     \v    11
backslash        \\    92
single quote     \'    39
double quote     \"    34
question mark    \?    63
null character   \0     0

Read that program carefully, because it contains the joke this whole topic turns on. To print a backslash followed by a, the format string has to contain \\a: the first backslash escapes the second, and the a is then just an a. To get the alert character, the character constant is '\a'. Both appear on the same line, which is the clearest way to see the difference between the two backslashes in your source.

The numbers in the right-hand column are the values in this machine's execution character set, which is ASCII. The standard does not promise those particular numbers, and you should not memorise them. What you should know is that '\0' is zero, always, because the standard requires a null character whose bits are all zero.

The table to learn

Two more forms let you write any character by its value.

• Octal. \ followed by one, two or three octal digits. '\101' is the character whose value is 101 in base eight, which is 65, which is A.
• Hexadecimal. \x followed by hexadecimal digits. '\x41' is 65, which is A again.

Both were run to check that claim:

#include <stdio.h>

int main(void)
{
    printf("octal 101 is %d, the character %c\n", (int) '\101', '\101');
    printf("hex 41    is %d, the character %c\n", (int) '\x41', '\x41');
    return 0;
}

octal 101 is 65, the character A
hex 41    is 65, the character A

\0 is not a special case of anything. It is the octal escape with a single octal digit zero, which is why it means the value zero.

\n against \r, which is worth two marks

\n moves to the beginning of the next line. \r moves to the beginning of the current line and stays there, so whatever you print next overwrites what was already on it.

printf("old text\rnew");

On a terminal that prints newtext, because new has overwritten the first three characters of old text and the rest of the old line is still there. This is how a progress counter that seems to update in place is done.

Windows text files end each line with a carriage return followed by a newline, and Unix files with a newline alone. This is why a file written on one and read on the other sometimes shows stray characters. In C you do not usually have to care: \n in a text stream is translated for you by the library.

What this does NOT mean

An escape sequence is one character, not two. '\n' is a single character constant with a single value. sizeof('\n') is not two. The two symbols in the source are how you write it, not what it is.

\ is not a line-continuation character in ordinary text. It does continue a source line when it is the last character before the newline, and that is a separate rule, used for long macros. Inside a string it introduces an escape sequence.

A string is not a character. "a" and 'a' are different things: the first is an array of two characters, a and the terminating zero, and the second is a single character. Chapter 12 is this in full, and it is the most common single confusion in the first semester.

The at sign and the dollar sign are not "special characters of C". They are not in C's basic character set at all. A question asking you to list the special characters wants the 29 graphic characters, and those two are not among them.

Not every character in the set is usable everywhere. The set says what you may write the program with. Where each one is allowed is settled by the grammar: a digit may not start an identifier, and a brace may not appear in the middle of an expression.

Quick revision

• The basic character set: 26 uppercase letters, 26 lowercase letters, 10 digits, 29 graphic characters, the space, and controls for horizontal tab, vertical tab and form feed.
• C is case sensitive: 52 letters, not 26.
• The digits are guaranteed to have consecutive values; the letters are not.
• The at sign and the dollar sign are not in the set.
• An escape sequence is a backslash plus one or more characters, and denotes one character.
• Learn \n \t \b \r \f \a \\ \' \" \0.
• \0 is the null character, value zero, and it terminates every string.
• \nnn is octal, \xhh is hexadecimal.
• \n goes to the next line; \r goes to the start of this one.

Test yourself

1. How many characters are in C's basic character set, by group?

26 uppercase letters, 26 lowercase letters, 10 digits, 29 graphic characters, the space character, and control characters for horizontal tab, vertical tab and form feed.

2. What does this print?

printf("a\\b\n");

a\b and then a newline. The \\ is one backslash, so no backspace is involved.

3. Write a printf that prints a double quotation mark, a tab, and a backslash, in that order.

printf("\"\t\\\n");

4. Is '\n' one character or two?

One. It is written with two symbols in the source and is a single character with a single value.

5. Why can you write c - '0' to convert a digit character into its numeric value, but not rely on c - 'a' for letters?

Because the standard guarantees the ten digit characters have consecutive values, and makes no such guarantee about the letters.

6. A program copied out of a word processor will not compile, and the error points at a line that looks right. What is the likely cause?

The word processor replaced straight quotation marks with curly ones, or a hyphen with a dash. Those characters are not in C's basic character set. Retype the line in a plain text editor.

What can be asked on this, and how to answer it

"What is the C character set?" Give the four groups with their counts, name the space and the control characters, and say that the set is fixed by the standard so that a program written in it compiles on any conforming implementation. Mention case sensitivity, because it is worth a mark on its own.

"What is an escape sequence? Give any five with their meanings." Define it as a backslash followed by one or more characters, standing for a single character that cannot conveniently be typed, then give five from the table with what each does. \n, \t, \0, \\ and \" are the safest five.

"Explain the difference between \n and \r." \n moves to the start of the next line. \r moves to the start of the current line without advancing, so subsequent output overwrites it.

"What is the significance of \0?" It is the null character, whose value is zero, and it marks the end of a character string in C. Every string literal has one added automatically, and the library's string functions find the end of a string by looking for it.

"Write a program to print a tab-separated table." Use \t between the fields and \n at the end of each row, and say in one line why \t is preferable to counting spaces: the columns stay aligned when the data widths change.

The 44 keywords of C17

These are the standard's own eleven rows of four, in the standard's own order.

auto       extern     short      while
break      float      signed     _Alignas
case       for        sizeof     _Alignof
char       goto       static     _Atomic
const      if         struct     _Bool
continue   inline     switch     _Complex
default    int        typedef    _Generic
do         long       union      _Imaginary
double     register   unsigned   _Noreturn
else       restrict   void       _Static_assert
enum       return     volatile   _Thread_local

Eleven rows of four is 44, and that is the number for C17 and for C11.

The 32 of C89, which is the number most textbooks print, is that list with the last column and inline and restrict removed:

auto     break    case     char     const    continue default  do
double   else     enum     extern   float    for      goto     if
int      long     register return   short    signed   sizeof   static
struct   switch   typedef  union    unsigned void     volatile while

• C99 added 5: inline, restrict, _Bool, _Complex, _Imaginary. That makes 37.
• C11 added 7: _Alignas, _Alignof, _Atomic, _Generic, _Noreturn, _Static_assert, _Thread_local. That makes 44.
• C17 added none. It is a correction of C11, which is why the two have the same list.

If the question says "how many keywords does C have", answer 44 for C17 and say in the same breath that the figure is 32 for the original ANSI C of 1989 and that C99 and C11 added the rest. That answer cannot be marked wrong, and it shows you know why two numbers are in circulation.

Of the 44, how many you actually need this semester

Twenty-six, and they are worth separating out, because a list of 44 is intimidating and most of it is for later.

The remaining keywords are storage classes and qualifiers you will meet in a later semester (auto, extern, static, register, volatile, inline, restrict) and the C11 additions for concurrency and alignment, which a first-year program never needs.

A program that proves case sensitivity

#include <stdio.h>

int main(void)
{
    int total = 10;
    int Total = 20;
    int TOTAL = 30;

    printf("total = %d, Total = %d, TOTAL = %d\n", total, Total, TOTAL);
    printf("their sum is %d\n", total + Total + TOTAL);
    return 0;
}

total = 10, Total = 20, TOTAL = 30
their sum is 60

Three declarations, three separate variables, three different values. The compiler did not complain, because as far as it is concerned these names have nothing to do with one another.

This is legal and it is a terrible idea. The reason to know it is that it explains the error you will actually make: declaring studentName and then writing studentname, and being told the second is undeclared.

What this does NOT mean

A keyword is not a function. sizeof is a keyword and an operator, built into the language. printf is not a keyword; it is an ordinary identifier that happens to name a library function, and you could declare a variable called printf if you were determined to cause trouble.

main is not a keyword. It is an ordinary identifier. The language reserves its meaning as the starting point of a program, not the name itself. This is why it is not in the table of 44.

NULL, TRUE and FALSE are not keywords. NULL is a macro from several standard headers. TRUE and FALSE are not part of C at all; they are things programmers define for themselves. C99 added _Bool and the header stdbool.h, which defines bool, true and false as macros. Macros, not keywords.

An underscore is not a letter, but it is allowed. The grammar lets a name start with one, which is why the reservation rules above exist at all.

A long name is not slow. Identifier names exist only in your source. After compilation the machine code has no idea what anything was called. total_marks_obtained costs exactly what t costs at run time, so choose the readable one.

Quick revision

• An identifier starts with a letter or underscore, continues with letters, digits and underscores, and contains nothing else.
• Case sensitive. total and Total are different.
• It may not be a keyword.
• C17 has 44 keywords; C89 had 32; C99 added 5 and C11 added 7.
• Do not begin your own identifiers with an underscore: those names are reserved for the implementation.
• Guaranteed significance: at least 63 characters within a file, at least 31 for external names.
• main, printf and NULL are not keywords.

Test yourself

1. Which of these are valid identifiers: _total, 2sum, sum2, net pay, net_pay, double, Double?

Valid: _total, sum2, net_pay, Double. Invalid: 2sum starts with a digit, net pay contains a space, double is a keyword. _total is valid but should be avoided, because leading underscores are reserved.

2. How many keywords are there in C, and why do you see two different answers?

44 in C11 and C17. The 32 that most books print is the C89 list; C99 added five keywords and C11 added seven.

3. Is Main a valid identifier? Is it the entry point of the program?

It is a valid identifier and it is not the entry point. C is case sensitive, so Main is an ordinary name and the linker will still be looking for main.

4. Why are the newest keywords spelled _Bool and _Static_assert instead of bool and static_assert?

Because names beginning with an underscore and a capital letter were already reserved for the implementation, so no existing program could have been using them. Adding bool as a keyword would have broken every program that had a variable of that name.

5. Can you use printf as a variable name?

Yes, because it is not a keyword. You should not: it hides the library function for the rest of that scope, and the next printf call will not compile.

6. int marks-obtained = 50; does not compile. Why?

Because - is not allowed in an identifier. The compiler reads marks, then a subtraction, then obtained, and none of that is a declaration.

What can be asked on this, and how to answer it

"What are identifiers? State the rules for writing an identifier." Define it as a user-defined name for a variable, function, array, structure or label. Then give the six rules, and give two or three invalid examples with the reason each is invalid. The examples are where the marks are; the rules alone read as memorised.

"What are keywords? How do they differ from identifiers?" A keyword is a name reserved by the language with a fixed meaning, and there are 44 in C17. An identifier is a name the programmer invents. The keywords are fixed and few; identifiers are unlimited and chosen. A keyword cannot be used as an identifier.

"List any ten keywords in C." Take them from the twenty-six in the table above, so that every one you write is a keyword you can also explain if asked.

"Is C case sensitive? Give an example." Yes. total and Total are two different identifiers and may be declared in the same program with different values. Give the three-variable program from this chapter.

What the standard actually guarantees

This is the table that is true everywhere. It is the standard's own required minimum magnitudes.

Two further guarantees are worth as much as the table:

1. sizeof(char) is 1. Every other size is measured in units of it.
2. The sizes are ordered and the ranges nest: char no larger than short, no larger than int, no larger than long, no larger than long long. So a short value always fits in an int, whatever the machine.

Notice what is not guaranteed. int is not four bytes. float is not four bytes. Nothing says int and long differ. On a small embedded processor int really is two bytes and the minimum above really is the range.

What this machine actually has

Ask the machine. That is what sizeof is for: an operator, not a function, that gives the size of a type or of an object in bytes.

#include <stdio.h>

int main(void)
{
    printf("type          bytes\n");
    printf("char          %5zu\n", sizeof(char));
    printf("short         %5zu\n", sizeof(short));
    printf("int           %5zu\n", sizeof(int));
    printf("long          %5zu\n", sizeof(long));
    printf("long long     %5zu\n", sizeof(long long));
    printf("float         %5zu\n", sizeof(float));
    printf("double        %5zu\n", sizeof(double));
    printf("long double   %5zu\n", sizeof(long double));
    printf("void *        %5zu\n", sizeof(void *));
    return 0;
}

type          bytes
char              1
short             2
int               4
long              8
long long         8
float             4
double            8
long double      16
void *            8

Those are the sizes on the 64-bit Linux machine that compiled this book's programs. Four of them differ elsewhere, and these are the four worth knowing about:

• long is 4 bytes on 64-bit Windows, not 8. Code that assumes a long can hold a large count is not portable between Linux and Windows. long long is 8 everywhere that has it.
• long double is 16 bytes here, 8 on 64-bit Windows with MSVC, and 12 on 32-bit Linux. It is the least portable type in C.
• void * is 8 bytes on any 64-bit machine and 4 on a 32-bit one. It is the size of an address, so it tracks the machine, not the standard.
• int is 4 bytes on every desktop machine and 2 on many microcontrollers.

%zu is the conversion for a value of type size_t, which is what sizeof produces. Using %d for it is a mistake that -Wall catches and that a great many textbooks make.

Signed against unsigned, and the trap in it

An unsigned type cannot hold a negative value. What it does instead is the thing to learn, because it is defined behaviour and it surprises everybody once.

#include <stdio.h>

int main(void)
{
    unsigned int u = 0;
    int i = 0;

    printf("as unsigned, 0 - 1 is %u\n", u - 1);
    printf("as signed,   0 - 1 is %d\n", i - 1);
    return 0;
}

as unsigned, 0 - 1 is 4294967295
as signed,   0 - 1 is -1

Subtracting one from an unsigned zero does not give minus one and it is not an error. Unsigned arithmetic wraps round: the result is reduced modulo one more than the largest value the type can hold, so it comes out as the largest value. This is exactly why a loop written as

for (unsigned int i = n; i >= 0; i--)

never ends. An unsigned i is always at least zero, so the condition is always true.

Use int for counting unless you have a reason not to. unsigned is for bit patterns, for sizes returned by the library, and for the one case where you genuinely need the extra range.

The floating-point types, and why double

float and double hold approximations. They are stored as a sign, a set of significant digits and an exponent, in the manner of scientific notation, which means a fixed number of significant digits and not a fixed number of decimal places.

The number of decimal digits you can rely on is in <float.h> as FLT_DIG and DBL_DIG. On the machine that ran this book's programs those are 6 and 15, and those two values are typical of every desktop machine, because both types follow the same international format for floating-point arithmetic.

Six digits is not many. Here is what that costs, in a program that is not buggy:

#include <stdio.h>

int main(void)
{
    float f = 123456789.0f;
    double d = 123456789.0;

    printf("as a float  : %.1f\n", (double) f);
    printf("as a double : %.1f\n", d);
    printf("0.1 + 0.2 as a double, to 20 places: %.20f\n", 0.1 + 0.2);
    return 0;
}

as a float  : 123456792.0
as a double : 123456789.0
0.1 + 0.2 as a double, to 20 places: 0.30000000000000004441

The float did not store 123456789. It stored the nearest value it is able to represent, and the last two digits are not the ones that were written. Nothing went wrong: a float has about seven significant decimal digits and was asked for nine.

Try the same program with 1234567.0f and the float prints it back perfectly. Seven digits happens to be inside what a float can do, which is exactly why this trap is hard to spot: it appears only once the numbers grow, and by then the program is finished and trusted.

And 0.1 + 0.2 is not 0.3, in any language, on any machine that uses binary floating point, because one tenth cannot be written exactly in binary any more than one third can be written exactly in decimal.

The rule that follows is absolute and it is worth marks: never compare two floating-point values with ==. Compare the size of their difference against a small tolerance instead. Chapter 16 gives the form.

Use double, not float. A float saves four bytes, which no program in this course will notice, and costs nine significant digits. float exists for very large arrays and for hardware that is faster at it.

The complete picture

The conversion to print each one

Getting this wrong is undefined behaviour, not a small mistake, because printf reads its arguments according to what the format string says is there. -Wall catches nearly all of it, which is the best argument for compiling with it.

There is no conversion for float in printf, and it is not an omission: a float argument is automatically promoted to double when passed, so %f is correct for both. In scanf, which takes addresses and promotes nothing, %f is for a float and %lf is for a double . Confusing the two in scanf is a real and common bug.

What this does NOT mean

int is not four bytes. It is four bytes on the machines you will use. The language says at least two. Write sizeof(int) when you need the number and never the literal 4.

sizeof is not a function. It is an operator and it is evaluated by the compiler, not at run time. sizeof x without brackets is legal for an object; brackets are required for a type name.

char is not "the character type" and nothing else. It is a one-byte integer, and whether it is signed is up to the implementation. When you want a small number use signed char or unsigned char and say which. When you want a character, use char.

unsigned does not mean positive. It means non-negative, and it means arithmetic that wraps rather than going negative.

float is not "less accurate for big numbers only". It has about six significant digits at every magnitude. float can hold 3.4 times ten to the thirty-eighth; it just cannot tell that number from its neighbours.

A type is not a promise about the value. Declaring int age does not stop anyone storing -500 in it. Checking the value is your job, and it is part of what integrity meant in chapter 6.

Quick revision

• Basic types: char, int, float, double, plus void.
• Modifiers: short, long, signed, unsigned.
• sizeof(char) is 1 by definition; everything else is measured in those units.
• The standard fixes minimum ranges, not sizes: int at least -32767 to +32767.
• Sizes never shrink going char, short, int, long, long long.
• Here: char 1, short 2, int 4, long 8, long long 8, float 4, double 8, pointer 8.
• long is 4 bytes on 64-bit Windows. long long is 8 everywhere.
• Unsigned arithmetic wraps modulo the range; 0u - 1 is the maximum value.
• float about 6 significant digits, double about 15. Use double.
• Never compare floating-point values with ==.
• sizeof gives a size_t; print it with %zu.

Test yourself

1. What is the size of int in C?

The standard does not say. It requires a range of at least -32767 to +32767, so at least two bytes, and it is four bytes on every desktop machine. sizeof(int) is the only reliable answer for a given machine.

2. Which is bigger, int or long?

long is never smaller than int, and on many machines they are the same size. sizeof(long) >= sizeof(int) is guaranteed; > is not.

3. What does this print, and why?

unsigned int u = 5;
printf("%u\n", u - 10);

A very large number, the maximum for unsigned int minus four, which is 4294967291 where unsigned int is 32 bits. Unsigned arithmetic is reduced modulo one more than the maximum, so it cannot produce a negative result.

4. Why should you not write if (x == 0.1) when x is a double?

Because 0.1 has no exact binary representation, so the value stored is the nearest one that does, and any arithmetic that produced x may have landed on a different nearest value. Test if (fabs(x - 0.1) < 1e-9) instead.

5. How many bytes does char occupy, and how do you know?

One, by definition. sizeof(char) is 1 in every conforming implementation, because the byte is the unit sizeof measures in.

6. Give the right printf conversion for sizeof(int), and say why %d is wrong.

%zu. sizeof produces a size_t, which is an unsigned type that may be wider than int, so %d tells printf to read the wrong number of bytes as the wrong kind of value.

What can be asked on this, and how to answer it

"Explain the data types in C with their sizes and ranges." Give the four basic types and the four modifiers, then the table of typical sizes, and then the sentence that earns the extra marks: the standard fixes minimum ranges rather than sizes, so the correct way to get a size is sizeof. Give int as 2 bytes minimum and 4 in practice, and you have answered both versions of the question.

"What is the difference between signed and unsigned?" A signed type spends one bit on the sign and can hold negative values; an unsigned type of the same width holds only non-negative values and reaches roughly twice as far. Add that unsigned arithmetic wraps modulo the range rather than going negative, and give 0u - 1 as the example.

"Differentiate between float and double." Both hold approximations. float is typically 4 bytes with about 6 significant decimal digits; double is typically 8 with about 15. double is the default for floating-point constants and the type to prefer. float is used to save space in large arrays.

"What is the use of the void data type?" Three uses: the return type of a function that returns no value, the parameter list of a function that takes no arguments, and void *, a pointer to an object of unspecified type.

"What is sizeof? Write a program to find the size of each data type." sizeof is a compile-time operator giving the size in bytes of a type or object, with sizeof(char) equal to 1 by definition. Then give the program in this chapter, and remember %zu.

Character constants

A single character in single quotation marks. Its type is int, not char, which surprises everyone the first time.

#include <stdio.h>

int main(void)
{
    printf("'A' as a character is %c\n", 'A');
    printf("'A' as a number is %d\n", 'A');
    printf("sizeof('A') is %zu, and sizeof(char) is %zu\n",
           sizeof('A'), sizeof(char));
    printf("'A' + 1 is %d, and as a character %c\n", 'A' + 1, 'A' + 1);
    return 0;
}

'A' as a character is A
'A' as a number is 65
sizeof('A') is 4, and sizeof(char) is 1
'A' + 1 is 66, and as a character B

The value is the character's code in the execution character set, which is ASCII on any machine you will use. So 'A' is genuinely usable as the number 65, and '0' as 48, and that is what makes c - '0' convert a digit character into its numeric value.

An escape sequence is a character constant: '\n', '\t', '\\', '\0'. Each is one character. Chapter 7 has the list.

'A' and "A" are not the same thing. The first is one character whose value is 65. The second is a string literal: an array of two characters, A and the terminating zero. Chapter 12.

'AB' is not a string and not an error you can rely on. It is a multi-character constant, its value is implementation-defined, and -Wall warns about it. Never write one.

String literals

Text in double quotation marks. Strictly it is a literal rather than a constant, and the distinction is real: a string literal is an array of char, and an array is not a constant expression.

"Hello"

That is six characters in memory, not five: H, e, l, l, o and a terminating \0 that the compiler adds. The count of the terminator is what chapter 12 and the whole string library depend on.

A string literal must not be modified. It may be stored in read-only memory, and a program that writes into one may crash. Declare const char *s = "Hello"; when you only mean to read it.

Two string literals written next to each other are joined into one, which is how a long piece of text is spread over several source lines:

printf("This is one long line of output that would not "
       "fit comfortably in the source, so it is split.\n");

Enumeration constants

An enum declares a set of named integer constants. They are the only constants that are genuinely part of the type system rather than the syntax.

#include <stdio.h>

enum day { MON, TUE, WED, THU, FRI, SAT, SUN };
enum grade { FAIL = 0, PASS = 40, FIRST = 60, DISTINCTION = 70 };

int main(void)
{
    enum day today = WED;

    printf("MON is %d and SUN is %d\n", MON, SUN);
    printf("today is %d\n", today);
    printf("the pass mark is %d and a distinction is %d\n", PASS, DISTINCTION);
    return 0;
}

MON is 0 and SUN is 6
today is 2
the pass mark is 40 and a distinction is 70

Numbering starts at 0 and increases by one unless you set a value, and after a value that you set, counting continues from it. An enumeration constant has type int.

The three ways to name a constant, and which to use

This is the part examiners like, because the three are genuinely different.

1. #define, a preprocessor macro.

#define PI 3.14159
#define MAX_STUDENTS 60

The preprocessor replaces the name with the text. There is no type, no storage and no scope: the substitution happens everywhere below the directive, and a mistake in it is reported against the line where the name was used, not where it was defined. By convention the name is in capitals.

2. const, a qualified variable.

const double pi = 3.14159;
const int max_students = 60;

This is a real object with a real type, which the compiler will not let you assign to. It obeys scope, it appears in a debugger, and the compiler type-checks every use of it. This is the one to prefer.

3. enum, for a set of related whole numbers.

Best where the values are a group: days, states, menu choices, error codes. It gives them a type as well as values, which #define cannot.

The array-size row is the one real reason #define survives in C. const int n = 10; int a[n]; is a variable-length array, which C99 allows and which is not the same thing as a fixed-size array; #define N 10 and enum { N = 10 }; both give a genuine constant expression.

What this does NOT mean

A constant is not a variable that cannot change. A constant has no memory of its own; it is a value written in the program. A const variable is a variable that cannot change, which is a different thing with a confusingly similar name.

#define does not create a constant of any type. It creates a text substitution. #define HALF 1/2 used as x HALF becomes x 1/2, which is (x * 1) / 2, and for an integer x of 3 that is 1 rather than 1.5. Chapter 22 is why macro definitions get brackets round them.

A leading zero is not formatting. 0113 is octal. If you want the decimal number 113, write 113.

'A' is not of type char. In C a character constant has type int. (In C++ it is char, which is one of the few differences that shows up in a first program.)

3.14 is not a float. It is a double. Assigning it to a float narrows it, and 3.14f is how you write a float constant.

A string literal is not modifiable. char *s = "Hello"; s[0] = 'J'; compiles and may crash. Use an array if you mean to change the text: char s[] = "Hello"; copies it into memory you own.

Quick revision

• Four kinds of constant: integer, floating, character, enumeration. String literals are a fifth thing and are arrays.
• Integer bases: decimal, octal with a leading 0, hexadecimal with 0x. 011 is 9.
• Integer suffixes: U, L, LL and combinations. Prefer capital L.
• A floating constant is a double unless suffixed f or L.
• A character constant is one character in single quotes and has type int, with the value of the character's code.
• 'A' is 65 in ASCII; '0' is 48; c - '0' converts a digit character to a number.
• A string literal in double quotes carries a terminating \0 and must not be modified.
• enum numbers from 0, continues from any value you set, and has type int.
• Three ways to name one: #define (text, no type), const (typed, scoped, preferred), enum (a typed set of ints).

Test yourself

1. What is the value of 010 + 10?

1. 010 is octal for 8, and 10 is decimal ten.

2. What is the type of 3.14, and how do you write the same value as a float?

double. Write 3.14f.

3. What does printf("%d\n", 'a') print, and why is it not an error?

97 on an ASCII machine. A character constant has type int and its value is the character's code, so %d is the correct conversion for it.

4. How many bytes does "Hi" occupy?

Three: H, i and the terminating \0.

5. Give one thing const can do that #define cannot, and one thing #define can do that const cannot.

const has a type, so the compiler checks every use of it, and it obeys scope. #define yields a constant expression usable as a fixed array size, which a const int does not in C.

6. After enum colour { RED = 5, GREEN, BLUE };, what is BLUE?

1. Counting continues from the value that was set, so GREEN is 6 and BLUE is 7.

7. Why does 7 / 2 give 3 while 7.0 / 2 gives 3.5?

In the first both operands are integer constants, so integer division discards the fractional part. In the second 7.0 is a double, so the 2 is converted to double and the division is done in floating point.

What can be asked on this, and how to answer it

"What is a constant? Explain the types of constants in C with examples." Define it, then give the four kinds with two examples each, and the rules that fix the type: octal and hexadecimal notation, the integer suffixes, floating constants being double by default, and a character constant having type int. Mention string literals and their terminating \0.

"Distinguish between #define and const." Give the table's rows: preprocessor against compiler, no type against a type, no scope against scope, unchecked against type-checked, and the one advantage #define keeps, which is a constant expression for an array size. Prefer const and say so.

"What is an enumeration? How are its values assigned?" A set of named integer constants declared with enum. Values start at 0, increase by one, and may be set explicitly, after which counting continues from the set value. Give a day or a grade example.

"What is the difference between 'A' and "A"?" 'A' is a character constant of type int with the value 65 in ASCII, occupying the space of an int. "A" is a string literal: an array of two char, A followed by \0. This is a favourite one-mark question.

"Write a program to show that a character constant has a numeric value." Print 'A' with both %c and %d, and 'A' + 1 as well, as this chapter does.

Initialisation

Initialisation is giving a variable a value at the moment it is created. Assignment is giving it a value later. They look similar and they are different events.

int marks = 75;          /* initialisation: created and set at once */
int total;               /* created, holding nothing useful       */
total = 0;               /* assignment: set afterwards            */

Several at once, each with its own value:

int a = 1, b = 2, c = 3;

int a = b = c = 0; does not do what it looks like. b and c must already exist; only a is being declared. Write the three separately.

The thing that goes wrong: an uninitialised variable

This is the most important paragraph in the chapter. A variable declared inside a function without an initialiser holds whatever was in that memory already. Not zero. Not a random number in any useful sense. Simply whatever was there.

The program below is wrong on purpose, and the compiler says so.

#include <stdio.h>

int main(void)
{
    int total;
    int count = 5;

    total = total + count;
    printf("total is now %d\n", total);
    return 0;
}

The compiler's own words, which are the point of the listing:

uninitialised.c: In function ‘main’:
uninitialised.c:8:11: warning: ‘total’ is used uninitialized [-Wuninitialized]
    8 |     total = total + count;
      |     ~~~~~~^~~~~~~~~~~~~~~
uninitialised.c:5:9: note: ‘total’ was declared here
    5 |     int total;
      |         ^~~~~

The value that program prints is not a fact about your machine or ours. Reading an uninitialised automatic variable is undefined behaviour: the standard permits the program to print anything, to print a different thing each time, or to do something else entirely. A program that appears to work because the memory happened to contain zero is the worst possible outcome, because it will stop appearing to work on the day it matters.

The habit that prevents it entirely: never declare a variable without a value unless the very next thing you write gives it one. A counter starts at 0. A running total starts at 0. A running product starts at 1. A "largest so far" starts at the first element, not at zero, which is chapter 36's trap.

Where variables live, and what that changes

Three places, and where a variable is declared decides both how long it lives and who can see it.

Automatic, the default: declared inside a function or a block.

void f(void)
{
    int x = 1;       /* created when f starts, gone when f returns */
}

Created on entry, destroyed on exit, and not initialised unless you say so. Every call gets a fresh one. This is what almost every variable in this course is.

Static: declared with static inside a function.

void f(void)
{
    static int calls = 0;   /* created once, survives between calls */
    calls++;
}

Created once before the program starts, lives until it ends, keeps its value between calls, and is initialised to zero if you do not initialise it. Visible only inside the function.

Global, also called external: declared outside every function.

int shared = 0;

void f(void) { shared++; }

Lives for the whole program, visible to every function in the file, and is initialised to zero if you do not initialise it.

Use automatic variables. A global is visible to everything, so any function may have changed it, and working out what a program does then means reading all of it. Chapter 21 says the same thing about blocks.

Here are the three side by side, with the counting they make possible:

#include <stdio.h>

int total_calls = 0;              /* global: zero by default, set here for clarity */

int count_up(void)
{
    static int mine = 0;          /* static: survives between calls */
    int fresh = 0;                /* automatic: new every call */

    mine = mine + 1;
    fresh = fresh + 1;
    total_calls = total_calls + 1;
    printf("static %d, automatic %d, global %d\n", mine, fresh, total_calls);
    return mine;
}

int main(void)
{
    count_up();
    count_up();
    count_up();
    return 0;
}

static 1, automatic 1, global 1
static 2, automatic 1, global 2
static 3, automatic 1, global 3

The static variable counts. The automatic one is created afresh each time and cannot. That difference is the whole idea, and it is a standing exam question.

Naming, which is not a side issue

Chapter 6 made clarity the second characteristic after integrity, and a variable's name is where most of a program's clarity comes from.

• Say what it holds, and in what unit. rate_percent rather than rate. seconds_elapsed rather than time.
• Length in proportion to scope. i is a perfectly good name for a loop counter that lives three lines. A global needs a name that makes sense far from where it was declared.
• Be consistent. total_marks and totalMarks in one program means a reader has to remember which you used where. This book uses lower case with underscores, which is the usual style in C.
• Do not encode the type. int iCount tells a reader what the declaration already told them.

What this does NOT mean

Declaring a variable does not give it a value. For an automatic variable it gives you a name for some memory whose contents are whatever they were. This is the single most common first-year bug.

Initialisation is not assignment. Initialisation happens once, when the object is created, and is the only way to set a const object or an array's contents. Assignment happens whenever the statement runs. For const int n = 5; the first is legal and n = 6; is not.

static does not mean constant. A static variable can be changed as freely as any other. What static fixes is how long it lives and who can see it.

A global variable is not "faster because it is not passed". It is a name with a long life and no owner. The cost of passing a parameter is nothing; the cost of not knowing who changed a value is hours.

C does not zero your automatic variables and you must not rely on a compiler that appears to. Many compilers in a debug build fill new memory with a recognisable pattern, which makes the bug visible. The same program in a release build will do something else.

Quick revision

• A variable is named memory of a known type. int marks; defines one.
• A definition creates storage. A declaration, with extern, only promises one exists.
• Every definition is a declaration; not every declaration is a definition.
• Since C99, a declaration may go anywhere a statement may go. Declare at first use.
• Initialisation sets a value when the object is created; assignment sets it later.
• An uninitialised automatic variable holds rubbish, and reading it is undefined behaviour.
• Static and global variables are zero by default. Automatic ones are not.
• A static variable in a function is created once and keeps its value between calls.
• Prefer automatic variables. Prefer names that say what the value is and in what unit.

Test yourself

1. What is the difference between a declaration and a definition?

A definition creates the variable and sets aside memory for it. A declaration states the name and type and promises a definition exists elsewhere, which is what extern int x; does. A variable is defined once and may be declared many times.

2. What is the value of x after int x; inside a function?

Unspecified. The variable holds whatever was in that memory, and reading it before assigning to it is undefined behaviour.

3. And after static int x; inside a function?

Zero. Static and global objects with no initialiser are set to zero before the program starts.

4. What does this print, and why?

void f(void) { static int n = 0; n++; printf("%d ", n); }
/* called three times */

1 2 3. The static variable is created once and keeps its value between calls.

5. Why is int a = b = 0; a mistake in a declaration?

Because only a is being declared. b must already exist, and if it does not the line does not compile. Declare and initialise each variable in its own right.

6. Give two reasons to prefer an automatic variable to a global one.

It cannot be changed by any other function, so the reasoning about its value is local. And it exists only while it is needed, so two parts of the program cannot accidentally share it.

What can be asked on this, and how to answer it

"What is a variable? How is it declared and initialised?" Define it as a named location in memory of a given type whose value can change while the program runs. Give the declaration form, the initialisation form, and the distinction between initialisation and assignment. Add that an automatic variable with no initialiser has no defined value, which is the part that earns the extra mark.

"Distinguish between declaration and definition of a variable." Give the two-sentence answer above with int x; against extern int x;, and the rule that one definition and many declarations are allowed.

"Explain the storage classes in C." Name auto, static, extern and register, and for each give where it is written, how long the variable lives, who can see it and what its default value is. The table in this chapter is the answer; register is a request that the value be kept in a processor register, which modern compilers ignore, and its one real consequence is that you cannot take its address.

"What happens if a variable is used without initialising it?" Its value is whatever was in that memory, reading it is undefined behaviour, and the program may print anything or behave differently on different runs or different compilers. Static and global variables are the exception: they are zero.

"Write a program to show the difference between an automatic and a static variable." Give the three-call program in this chapter and point at the two columns of its output.

The space in " %c" is the fix for the commonest bug in first-semester C. After reading a number with scanf("%d", &n), the newline you pressed is still waiting in the input, so the next "%c" reads the newline instead of what the user types. A leading space in the format tells scanf to skip any amount of whitespace first.

getchar returns an int, not a char, and that is not an oversight. It has to be able to return every possible character and the separate value EOF for "there is no more input", and a char has no spare value to use. Store it in an int.

A string is an array of characters with a zero on the end

#include <stdio.h>

int main(void)
{
    char name[] = "Anita";

    printf("the string is %s\n", name);
    printf("it needs %zu bytes\n", sizeof name);
    printf("byte by byte: ");
    for (int i = 0; i < (int) sizeof name; i++) {
        printf("[%d]=%d ", i, name[i]);
    }
    printf("\n");
    printf("as characters: ");
    for (int i = 0; i < (int) sizeof name - 1; i++) {
        printf("%c", name[i]);
    }
    printf("\n");
    return 0;
}

the string is Anita
it needs 6 bytes
byte by byte: [0]=65 [1]=110 [2]=105 [3]=116 [4]=97 [5]=0
as characters: Anita

Five letters, six bytes. The sixth is the zero the compiler added, and printing the bytes as numbers is the clearest way to see it. name[5] is 0, and it is not the character '0', whose code is 48. The difference between '\0' and '0' is worth a mark on its own.

char name[] = "Anita"; lets the compiler count for you, and it counts the terminator. Writing the size yourself is where mistakes live.

The four ways to declare a string, and which is which

char a[] = "Anita";       /* array of 6, contents copied in, changeable   */
char b[20] = "Anita";     /* array of 20, first 6 used, rest set to zero  */
char c[6] = "Anita";      /* exactly fits: 5 letters and the terminator   */
const char *d = "Anita";  /* a POINTER to the literal, NOT changeable     */

char e[5] = "Anita"; compiles in C and gives you an array of five characters with no terminator. It is not a string, and passing it to printf("%s") walks off the end of the array. Count the terminator.

The difference between a and d is the one that matters and it is not cosmetic:

• a is an array. The characters are yours, in your memory, and a[0] = 'B'; is legal.
• d points at the string literal itself, which the program may have put in read-only memory. d[0] = 'B'; compiles without const and may crash.

The rule: if you mean to change the text, use an array. If you only mean to read it, use const char *.

What goes wrong, and it is always the terminator

1. The array is one byte too small. char s[5] = "Anita"; has no room for the zero. char s[6] or char s[] is correct.

2. strlen and sizeof are different numbers. strlen counts the characters up to the terminator. sizeof gives the size of the array, terminator and all unused bytes included.

#include <stdio.h>
#include <string.h>

int main(void)
{
    char a[] = "Anita";
    char b[20] = "Anita";

    printf("a: strlen %zu, sizeof %zu\n", strlen(a), sizeof a);
    printf("b: strlen %zu, sizeof %zu\n", strlen(b), sizeof b);
    return 0;
}

a: strlen 5, sizeof 6
b: strlen 5, sizeof 20

3. scanf("%s") stops at the first space. Reading "Anita Desai" with %s gives you "Anita" and leaves the rest waiting. Use fgets when the input has spaces in it.

4. scanf("%s") has no idea how big your array is. It writes as many characters as arrive. scanf("%19s", name) for a char name[20] is the safe form: 19 characters and the terminator.

5. A string cannot be compared with ==. if (a == b) compares two addresses, not two texts, and is almost always false. strcmp is chapter 37.

6. A string cannot be copied with =. a = b; does not compile for arrays. strcpy is chapter 37.

Reading a whole line safely

#include <stdio.h>
#include <string.h>

int main(void)
{
    char line[40];

    if (fgets(line, (int) sizeof line, stdin) != NULL) {
        line[strcspn(line, "\n")] = '\0';     /* cut the newline off */
        printf("you typed [%s], %zu characters\n", line, strlen(line));
    }
    return 0;
}

Anita Desai

you typed [Anita Desai], 11 characters

fgets takes the size of the array, so it cannot overflow it, and it keeps the newline you pressed. The strcspn line finds the position of the first newline and puts a terminator there, which is the ordinary way of trimming it. If there was no newline, strcspn returns the length and the assignment is harmless.

What this does NOT mean

A string is not a data type. There is no string in C. There is an array of char with a convention about its last byte, and a library of functions that all obey that convention.

'\0' is not '0', and neither is "0". '\0' has the value 0. '0' has the value 48. "0" is two bytes: 48 and then 0.

sizeof is not the length. For char b[20] = "Anita";, sizeof b is 20 and strlen(b) is 5.

A char is not guaranteed to be signed. Whether plain char can hold a negative value is left to the implementation. It matters only if you store numbers in a char, in which case write signed char or unsigned char.

gets does not exist any more, and never use it. It reads a line with no idea of the size of your array. It was removed from the language in C11, and any book that shows it is describing a language that no longer has it. fgets is the replacement.

Quick revision

• A char is one byte holding an integer: the character's code.
• %c prints the character, %d prints the code.
• c - '0' converts a digit character to its value, guaranteed by the standard.
• A string is characters in consecutive memory ending in '\0'.
• "Anita" occupies 6 bytes. n characters need n + 1.
• char s[] = "..." lets the compiler count, terminator included.
• char s[] is changeable memory of yours; const char *s points at a literal you must not change.
• strlen counts to the terminator; sizeof gives the whole array.
• getchar returns int, so that EOF is distinguishable.
• scanf(" %c", &c): the leading space skips the leftover newline.
• scanf("%s") stops at whitespace and does not know your array size. Use %19s or fgets.
• Never gets. It was removed from the language.

Test yourself

1. How many bytes does char s[] = "Hello"; occupy, and what is in the last one?

Six. The last holds '\0', the value zero, which marks the end of the string.

2. What is the difference between 'A', "A" and '\0'?

'A' is a character constant of type int with the value 65 in ASCII. "A" is a string literal: two bytes, 65 and 0. '\0' is the null character, value 0.

3. char s[5] = "Hello"; compiles. Why is it wrong?

There is no room for the terminator, so s holds five characters and is not a string. Any library function or %s conversion will read past the end of the array.

4. Why does getchar return an int?

So that it can return any character value and also the distinct value EOF, which means there is no more input. A char has no value left over to mean that.

5. After scanf("%d", &n), why does scanf("%c", &c) seem to read nothing?

Because the newline from the Return key is still in the input, and %c reads it. Write scanf(" %c", &c): the leading space skips whitespace first.

6. Your program must read a full name with a space in it. Which input function, and why not the other?

fgets, because scanf("%s") stops at the first whitespace character and would read only the first word.

7. For char b[20] = "Anita";, what are strlen(b) and sizeof b?

5 and 20.

What can be asked on this, and how to answer it

"What is a string in C? How is it stored?" A string is an array of characters terminated by the null character '\0'. It is stored as the characters in consecutive bytes with the terminator after the last one, so n characters need n + 1 bytes, and there is no separate length: every library function finds the end by looking for the terminator.

"What is the significance of the null character?" It marks the end of a string. Every string literal gets one automatically, and the library's string functions depend on it. Without one, a function walks past the end of the array, which is undefined behaviour.

"Distinguish between a character and a string." A character is one byte in single quotation marks holding a code; a string is an array of characters in double quotation marks with a terminator. 'A' is one byte's worth of value; "A" is two bytes.

"Distinguish between strlen and sizeof for a character array." strlen is a library function that counts characters up to the terminator, at run time. sizeof is a compile-time operator giving the size of the whole array including the terminator and any unused space.

"Write a program to read a string and display it." Use fgets with sizeof of the array, trim the newline, and print with %s. Say in one line why not gets: it has no bound and was removed from the language in C11.

What typedef does NOT do, with proof

It does not create a new type. The name is an alias, and the two are the same type for every purpose the language has.

#include <stdio.h>

typedef int Metres;
typedef int Feet;

int main(void)
{
    Metres distance = 100;
    Feet height = 6;

    /* Nonsense, and the compiler has no objection: both are int. */
    int nonsense = distance + height;

    printf("adding metres to feet gives %d, and -Wall -Wextra said nothing\n",
           nonsense);
    return 0;
}

adding metres to feet gives 106, and -Wall -Wextra said nothing

That program compiles clean. Adding metres to feet is meaningless and the compiler cannot know it, because Metres and Feet are both spellings of int. So typedef is documentation, not protection. If you need the compiler to keep two quantities apart, you need two different structure types, which is chapter 42.

It does not allocate anything. typedef is a declaration, not a definition of an object. No memory is set aside.

It cannot extend a type. typedef cannot make an integer bigger or add an operation. It only renames.

It is not a macro. The pointer example above is the proof. typedef is handled by the compiler and understands the grammar of declarations; #define is handled by the preprocessor and understands only text.

Where typedef really earns its place

Three uses account for nearly all of it in real C.

1. Shortening a structure name. In C, a structure's name includes the keyword: struct student. A typedef lets you write Student. This is the commonest use by a wide margin, and chapter 42 gives it.

2. Naming a pointer-to-function type, which is otherwise unreadable.

typedef int (*Comparison)(const void *, const void *);

3. Making a program's own vocabulary portable. The standard library does this everywhere, and you have already used the results: size_t is a typedef for whatever unsigned type is right for a size on this machine, and FILE, time_t, ptrdiff_t and wchar_t are all typedef names. That is why sizeof prints with %zu and not %u: the actual type behind size_t differs between machines, and the typedef is what lets your program not care.

That last point is the honest answer to "why does typedef exist": it lets a program name a type by its purpose while the compiler chooses the representation.

Naming style

There is no rule, and there are two common conventions.

• Capitalised: Marks, Percentage, Student. Used in this book, because it makes a type name visible at a glance.
• _t suffix: marks_t, student_t. Common in systems code, and it imitates the library's size_t and time_t.

Strictly, names ending in _t are reserved by POSIX for the system's own headers, so the capitalised form is the safer habit. Either way, be consistent within a program.

Quick revision

• typedef existing-type new-name; gives a type a second name.
• The trick: write the variable declaration, put typedef in front, and the name declared becomes a type name.
• It creates no new type: sizeof proves it, and two typedef names for int add together without complaint.
• It allocates nothing and is handled by the compiler, not the preprocessor.
• Unlike #define, it knows it is declaring a type, so IntPtr p, q; makes two pointers.
• It obeys scope, so a typedef inside a function is local to it.
• Main uses: shortening struct names, naming function-pointer types, and giving a portable name to a machine-dependent type. size_t, FILE and time_t are library typedefs.

Test yourself

1. Write a typedef that names the type "array of 10 double", and declare two such arrays with it.

typedef double Vector[10];
Vector a, b;

2. Is sizeof(Marks) the same as sizeof(unsigned int) after typedef unsigned int Marks;?

Yes. Marks is another name for unsigned int, not a new type.

3. What is wrong with #define IntPtr int * followed by IntPtr p, q;?

It expands to int * p, q;, so p is a pointer and q is a plain int. A typedef would have made both pointers.

4. Will the compiler stop you adding a Metres to a Feet if both are typedef int?

No. They are the same type, so there is nothing for it to object to. Use two distinct structure types if you want that checked.

5. Name three typedef names from the standard library and say why each is a typedef rather than a fixed type.

size_t, time_t and FILE. Each hides a representation that differs between implementations, so a program can name the purpose and let the library choose the type.

6. Can a typedef be written inside a function?

Yes, and it then obeys the same scope rules as any other declaration in that block: it is visible from that point to the end of the block and nowhere else.

What can be asked on this, and how to answer it

"What is typedef? Explain with an example." Define it as a way of giving an existing type an additional name, give the syntax, give two examples of which one is an array or pointer type, and say plainly that no new type is created. The last part is where the marks separate.

"Distinguish between typedef and #define." Give the table's rows: compiler against preprocessor, type-aware against text substitution, scoped against not scoped, and the pointer example where the two genuinely differ.

"What are the advantages of typedef?" Readability, because a declaration can name the purpose of a value; brevity, because struct student becomes Student; portability, because a program can use a name whose underlying type the implementation chooses; and maintainability, because a representation can be changed in one line.

"Does typedef create a new data type?" No. It creates a new name for an existing type. The two names are interchangeable everywhere, and the compiler will not distinguish values of them.

That last sentence is where the marks are lost. The type of an expression is decided by the operands, not by what you assign it to.

#include <stdio.h>

int main(void)
{
    int total = 7;
    int count = 2;

    double wrong = total / count;
    double right = (double) total / count;

    printf("7 / 2 assigned to a double  : %.4f\n", wrong);
    printf("(double) 7 / 2              : %.4f\n", right);
    printf("7 %% 2 is %d, so the fraction thrown away was %d/2\n",
           total % count, total % count);
    return 0;
}

7 / 2 assigned to a double  : 3.0000
(double) 7 / 2              : 3.5000
7 % 2 is 1, so the fraction thrown away was 1/2

total / count is integer division, giving 3. Assigning 3 to a double gives 3.0. The fraction was gone before the assignment happened, and no amount of double on the left recovers it.

The fix is to make one operand floating-point. (double) total / count promotes count too, by rule 2. So does total / (double) count, and so does total * 1.0 / count.

Rule 3: assignment converts to the left-hand type

On assignment the value is converted to the type of the variable, and if it will not fit, something is lost. Two cases matter.

Floating-point to integer: the fraction is discarded, not rounded.

#include <stdio.h>
#include <math.h>

int main(void)
{
    printf("(int) 3.7   is %d\n", (int) 3.7);
    printf("(int) 3.2   is %d\n", (int) 3.2);
    printf("(int) -3.7  is %d\n", (int) -3.7);
    printf("round(3.7)  is %.0f\n", round(3.7));
    printf("round(-3.7) is %.0f\n", round(-3.7));
    return 0;
}

(int) 3.7   is 3
(int) 3.2   is 3
(int) -3.7  is -3
round(3.7)  is 4
round(-3.7) is -4

Truncation is towards zero, so (int) -3.7 is -3 and not -4. If you want rounding, use round from <math.h>; if you want the largest integer no greater than the value, use floor.

Integer to a narrower integer: the high bits are discarded. Assigning 300 to a char does not give you 300 and does not give you an error. -Wall -Wextra will usually warn, which is the reason to compile with them.

What a cast is for, and when to use one

Four legitimate uses, and they are worth knowing as a list, because a cast is also a way of telling the compiler to stop objecting, which is a way of hiding a bug.

1. To force floating-point arithmetic. The most common use in this course.

double average = (double) total / count;

2. To discard a fraction deliberately, where truncation is what you mean.

int whole_rupees = (int) amount;

3. To pick the right overload of a library function, or to satisfy a parameter type, most often (double) for a float or (int) for a char in a printf argument.

4. To say "I know this is unused", with (void).

(void) unused_parameter;

A cast used to silence a warning you do not understand is a bug you have hidden. -Wall warning about a conversion is usually telling you the truth.

The worked example: the average of three marks

This is the shape of several of the lab's practicals, and it is where the rule bites.

#include <stdio.h>

int main(void)
{
    int m1 = 63, m2 = 58, m3 = 72;
    int total = m1 + m2 + m3;

    printf("total is %d\n", total);
    printf("wrong  : total / 3           = %d\n", total / 3);
    printf("wrong  : assigned to a double = %.4f\n", (double) (total / 3));
    printf("right  : (double) total / 3   = %.4f\n", (double) total / 3);
    printf("right  : total / 3.0          = %.4f\n", total / 3.0);
    return 0;
}

total is 193
wrong  : total / 3           = 64
wrong  : assigned to a double = 64.0000
right  : (double) total / 3   = 64.3333
right  : total / 3.0          = 64.3333

Both correct forms agree, and both differ from the wrong one. Read the third line carefully: casting after the division changes nothing, because the division has already happened. The cast has to be on an operand.

What this does NOT mean

A cast does not change the variable. (int) x produces a new value of type int; x is untouched and still a double. A cast is an operator producing a result, not an instruction to the variable.

Conversion is not rounding. Converting a floating-point value to an integer discards the fractional part, towards zero.

Assigning to a double does not make the arithmetic floating-point. The expression's type was fixed by its operands before the assignment was reached.

An implicit conversion is not an error, and that is the problem. C converts silently in most cases, so a lost fraction or a truncated value does not stop the program. -Wall -Wextra is what makes the risky ones visible.

A cast between unrelated pointer types is not a conversion of the data. It reinterprets the bits. That is a later topic and it is not what this chapter is about.

char to int is not "losing information". It is a widening, and it is exact. The losing direction is int to char.

Quick revision

• Implicit conversion is C's; explicit conversion is a cast, written (type) value.
• Rule 1, integer promotion: anything narrower than int becomes int before arithmetic.
• Rule 2, usual arithmetic conversions: the narrower operand is converted to the wider. long double down to int.
• Rule 3, assignment: the value is converted to the left-hand type, and may lose data.
• The type of an expression is decided by its operands, never by what it is assigned to.
• 7 / 2 is 3 in any context. (double) 7 / 2 is 3.5.
• Floating-point to integer truncates towards zero: (int) -3.7 is -3. Use round to round.
• A cast applies to an operand, so it must be written before the division, not around it.
• Compile with -Wall -Wextra: most damaging conversions warn.

Test yourself

1. What does printf("%d\n", 5 / 2) print, and what does printf("%.2f\n", 5 / 2.0) print?

2 and 2.50. The first is integer division; in the second one operand is a double, so the other is converted and the division is floating-point.

2. double avg = sum / n; where both are int gives a whole number. Fix it two ways.

double avg = (double) sum / n; or double avg = sum / (double) n;. Either makes one operand a double, and rule 2 converts the other.

3. What is (int) -2.9?

-2. Truncation is towards zero.

4. What is the type and value of 'a' + 1?

int, and 98 on an ASCII machine. The char is promoted to int before the addition.

5. char c = 300; compiles with a warning. What is in c?

An implementation-defined value: the high bits of 300 do not fit in one byte and are discarded. It is not 300, and the warning is telling you so.

6. Why does (double) (total / 3) not give you the fractional average?

Because the division inside the brackets is integer division and has already thrown the fraction away. The cast then converts the whole number 3 to 3.0.

7. Name the four places an implicit conversion happens.

In a mixed-type expression, on assignment, when passing an argument to a function, and when returning a value.

What can be asked on this, and how to answer it

"What is type conversion? Explain implicit and explicit conversion with examples." Define both, give the three rules with one example each, and give (double) total / count as the explicit case that matters. Say that the expression's type comes from its operands, because that sentence is what the question is really testing.

"What is typecasting? Give its syntax and two uses." A cast converts a value to a named type at a point you choose, written (type) expression. Two uses: forcing floating-point division, and deliberately discarding a fraction. Add that a cast produces a value and does not change the variable.

"Explain the rules of automatic type conversion in an expression." Integer promotion first, then the usual arithmetic conversions towards the wider type, then, on assignment, conversion to the left-hand type with possible loss. Give the ordering from long double down to int.

"Write a program to find the average of three integers and explain the conversion involved." Give the program in this chapter, and explain that total / 3 is integer division, so one operand must be made a double before dividing.

"What is the difference between (int) 3.7 and round(3.7)?" The cast truncates towards zero, giving 3. round from <math.h> rounds to the nearest, giving 4.0 as a double. For -3.7 they give -3 and -4.

a / b            = 3
(double) a / b   = 3.4000
a / (double) b   = 3.4000
a / 5.0          = 3.4000
1 / 2            = 0     <- both integers
1.0 / 2          = 0.5000

1 / 2 is 0. This turns up inside larger expressions and is easy to miss: x 1 / 2 is (x 1) / 2, which for an integer x of 7 is 3, while x (1 / 2) is x 0, which is 0. Neither is 3.5.

The remainder operator

% gives what is left after integer division. It requires both operands to be integers. 7.5 % 2 does not compile; there is fmod in <math.h> for floating-point remainders.

What % is actually used for is worth listing, because these five uses cover nearly every appearance of it in this course:

1. Is it divisible? n % 2 == 0 tests even. year % 4 == 0 is the first part of the leap-year test in chapter 16.
2. Extract the last digit. n % 10. With n / 10 to remove it, that is the whole of the reverse-the-digits practical in chapter 27.
3. Wrap a value into a range. (i + 1) % n steps round a circle of n positions.
4. Split a quantity into units. Seconds into minutes and seconds, paise into rupees and paise.
5. Test a multiple. i % 5 == 0 to print every fifth line.

#include <stdio.h>

int main(void)
{
    int seconds = 3725;

    printf("%d seconds is %d h %d m %d s\n",
           seconds, seconds / 3600, (seconds / 60) % 60, seconds % 60);
    printf("the last digit of 3725 is %d\n", 3725 % 10);
    printf("3725 without its last digit is %d\n", 3725 / 10);
    printf("is 3725 even? %d  (1 means yes)\n", 3725 % 2 == 0);
    return 0;
}

3725 seconds is 1 h 2 m 5 s
the last digit of 3725 is 5
3725 without its last digit is 372
is 3725 even? 0  (1 means yes)

Negative operands

Division truncates towards zero, so % takes the sign of the left-hand operand. This is fixed by the standard since C99 and it is worth checking once rather than guessing.

#include <stdio.h>

int main(void)
{
    printf(" 17 /  5 = %3d     17 %% 5 = %3d\n",  17 /  5,  17 %  5);
    printf("-17 /  5 = %3d    -17 %% 5 = %3d\n", -17 /  5, -17 %  5);
    printf(" 17 / -5 = %3d     17 %% -5 = %3d\n",  17 / -5,  17 % -5);
    printf("-17 / -5 = %3d    -17 %% -5 = %3d\n", -17 / -5, -17 % -5);
    return 0;
}

 17 /  5 =   3     17 % 5 =   2
-17 /  5 =  -3    -17 % 5 =  -2
 17 / -5 =  -3     17 % -5 =   2
-17 / -5 =   3    -17 % -5 =  -2

So -17 % 5 is -2, not 3. If you need a non-negative remainder for wrapping round a circle, write ((a % n) + n) % n.

Division by zero

Integer division by zero is undefined behaviour. Not zero, not an error you can catch, not infinity. On most machines the program is killed.

There is no way to recover from it afterwards, so the only correct handling is to test first:

if (count != 0) {
    average = (double) total / count;
} else {
    printf("no marks were entered\n");
}

Floating-point division by zero is different: it is defined by the floating-point standard and gives infinity or a "not a number" value rather than killing the program. Do not rely on that. Test the divisor.

The practical: simple interest from input

MU's Practical 1(a) reads the principal, the rate and the number of years from the user and prints the simple interest. Here it is, with the input checked, which is the part that separates a program from a program that works.

#include <stdio.h>

int main(void)
{
    double principal, rate, years;

    printf("Enter principal, rate per year and number of years: ");
    if (scanf("%lf %lf %lf", &principal, &rate, &years) != 3) {
        printf("\nThose were not three numbers.\n");
        return 1;
    }

    double interest = principal * rate * years / 100.0;

    printf("\nPrincipal        : %10.2f\n", principal);
    printf("Rate per year    : %10.2f %%\n", rate);
    printf("Number of years  : %10.2f\n", years);
    printf("Simple interest  : %10.2f\n", interest);
    printf("Amount repayable : %10.2f\n", principal + interest);
    return 0;
}

15000 8.5 2

Enter principal, rate per year and number of years:
Principal        :   15000.00
Rate per year    :       8.50 %
Number of years  :       2.00
Simple interest  :    2550.00
Amount repayable :   17550.00

Four things in that program are the difference between a pass and a good mark.

• %lf in scanf, not %f. scanf takes an address and does no promotion, so %f means "a float " and %lf means "a double ". Passing a double * to %f writes four bytes into an eight-byte object and is a real bug. In printf the opposite is true: %f is right for both, because a float argument is promoted to double.
• scanf returns a count, the number of items it successfully read. Checking it against 3 is the whole of the input validation, and it is one line.
• / 100.0, not / 100. Here it makes no difference because the operands are already double, but writing 100.0 is the habit that saves you when they are not.
• %% in the format string prints one per cent sign. A single % starts a conversion.

For the algorithm and flowchart that MU asks for in the same practical, see chapter 2.

Arithmetic on characters, which is legal and useful

A char is a small integer, so all five operators work on it. Two uses are standard:

#include <stdio.h>

int main(void)
{
    char digit = '7';
    char lower = 'q';

    printf("'7' as a number is %d\n", digit - '0');
    printf("'q' in upper case is %c\n", lower - 'a' + 'A');
    printf("the 5th letter of the alphabet is %c\n", 'A' + 4);
    return 0;
}

'7' as a number is 7
'q' in upper case is Q
the 5th letter of the alphabet is E

lower - 'a' + 'A' works on any machine whose letters are consecutive, which is every machine you will use, but the standard does not guarantee it. toupper from <ctype.h> is the portable form and is chapter 34.

What this does NOT mean

/ is not always integer division. It is integer division only when both operands are integer types. The operator is the same; the operands decide.

% is not "percent". It is the remainder after integer division. To compute a percentage you divide and multiply by 100, in floating point.

% does not work on double. Use fmod from <math.h>.

There is no exponentiation operator in C. 2 ^ 3 is not 8; ^ is bitwise exclusive-or and gives 1. Use pow(2, 3) from <math.h>, or multiply, and for a square prefer x * x to pow(x, 2).

a % b for negative a is not always positive. It takes the sign of a.

Integer overflow is not "wrapping round". For signed integers it is undefined behaviour, unlike unsigned arithmetic which is defined to wrap. INT_MAX + 1 is not reliably INT_MIN.

Quick revision

• Five operators: + - * / %. Unary - as well.
• / on two integers discards the fraction. Make one operand a double for a real quotient.
• % needs integer operands; fmod is the floating-point version.
• (a / b) * b + (a % b) is always a.
• Division truncates towards zero, so % takes the sign of the left operand: -17 % 5 is -2.
• Non-negative wrap: ((a % n) + n) % n.
• Integer division by zero is undefined behaviour. Test the divisor.
• No exponentiation operator. ^ is bitwise exclusive-or.
• Signed overflow is undefined; unsigned arithmetic wraps by definition.
• In scanf, a double needs %lf. In printf, %f serves both float and double.

Test yourself

1. What are 17 / 5, 17 % 5, 17.0 / 5 and 17 % 5.0?

3, 2, 3.4, and the last does not compile: % requires integer operands.

2. Write an expression that gives the tens digit of an integer n.

(n / 10) % 10.

3. What is -7 % 3, and why?

-1. Division truncates towards zero, so -7 / 3 is -2, and the identity (-2) * 3 + (-1) gives -7.

4. A program must print an average to two decimal places from int total and int count. Write the statement.

if (count != 0) printf("%.2f\n", (double) total / count);

5. Convert 3725 seconds into hours, minutes and seconds using only / and %.

Hours 3725 / 3600, minutes (3725 / 60) % 60, seconds 3725 % 60, giving 1 h 2 m 5 s.

6. Why is %lf needed in scanf but not in printf?

scanf receives a pointer and performs no conversion, so the length modifier tells it whether the target is a float or a double. In printf a float argument is automatically promoted to double, so %f handles both.

7. What does 2 ^ 3 give in C?

1. ^ is bitwise exclusive-or, not exponentiation. Two is 10 and three is 11 in binary, and their exclusive-or is 01.

What can be asked on this, and how to answer it

"Explain the arithmetic operators in C with examples." Give the five with a worked value each, then spend the rest of the answer on the two that need it: integer division and its fix, and the remainder operator with its integer-only restriction and the identity. That is the shape the marks follow.

"What is the difference between / and %?" / gives the quotient and % the remainder of an integer division. / works on any arithmetic type and is integer division only when both operands are integers; % requires integer operands. (a / b) * b + (a % b) is a.

"Write a program to calculate simple interest taking principal, rate and years as input." Give this chapter's program. The examiner's follow-up is nearly always why %lf, or what happens if the user types a letter, so keep the scanf check in.

"What is the output of printf("%d", 5/22)?" 4. / and have equal precedence and group left to right, so it is (5 / 2) 2, which is 2 2. Chapter 20 is precedence in full.

"Write a program to convert a given number of seconds into hours, minutes and seconds." Give the three expressions above and say in one line why % 60 is needed on the minutes: dividing by 60 gives total minutes, and the hours must be taken out of it.

&& and || are binary and produce 1 or 0. ! is unary and also produces 1 or 0, so !0 is 1 and !5 is 0, not -5.

#include <stdio.h>

int main(void)
{
    int age = 20;
    int marks = 65;

    printf("age >= 18 && marks >= 60 is %d\n", age >= 18 && marks >= 60);
    printf("age <  18 || marks >= 60 is %d\n", age <  18 || marks >= 60);
    printf("!(age >= 18)             is %d\n", !(age >= 18));
    printf("!0 is %d and !5 is %d\n", !0, !5);
    return 0;
}

age >= 18 && marks >= 60 is 1
age <  18 || marks >= 60 is 1
!(age >= 18)             is 0
!0 is 1 and !5 is 0

Short circuiting, which is a guarantee and not an optimisation

&& evaluates its left operand first. If that is false, the answer must be false, so the right operand is not evaluated at all. || does the same when the left operand is true. The standard guarantees this, which means you may rely on it, and you will need to.

#include <stdio.h>

int calls = 0;

int noisy(int value)
{
    calls = calls + 1;
    return value;
}

int main(void)
{
    calls = 0;
    printf("0 && noisy(1) is %d, and noisy was called %d time(s)\n",
           0 && noisy(1), calls);

    calls = 0;
    printf("1 || noisy(1) is %d, and noisy was called %d time(s)\n",
           1 || noisy(1), calls);

    calls = 0;
    printf("1 && noisy(1) is %d, and noisy was called %d time(s)\n",
           1 && noisy(1), calls);
    return 0;
}

0 && noisy(1) is 0, and noisy was called 0 time(s)
1 || noisy(1) is 1, and noisy was called 0 time(s)
1 && noisy(1) is 1, and noisy was called 1 time(s)

The counter proves it. And this is what makes the following safe, which is the reason the guarantee matters:

if (count != 0 && total / count > 50)

If count is zero the division never happens. Write the two tests in the other order and the program divides by zero. Chapter 15 said the only correct handling of division by zero is to test first; short circuiting is what lets you do it in one expression.

The leap year, in full

MU's Practical 1(c). The Gregorian rule:

1. A year divisible by 4 is a leap year,
2. except that a year divisible by 100 is not,
3. except that a year divisible by 400 is.

So 2024 is a leap year, 1900 is not, and 2000 is.

Written as one expression:

year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)

The brackets are not optional. && binds tighter than ||, so without them the expression would group as (year % 4 == 0 && year % 100 != 0) || year % 400 == 0, which is a different test. It happens to give the right answer for every year, which is exactly why the mistake survives: it is wrong reasoning that produces right answers, and a viva question about 1900 will expose it.

#include <stdio.h>

int is_leap(int year)
{
    return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
}

int main(void)
{
    int years[] = {1900, 1996, 2000, 2023, 2024, 2100, 2400};

    for (int i = 0; i < 7; i++) {
        printf("%d is %sa leap year\n",
               years[i], is_leap(years[i]) ? "" : "not ");
    }
    return 0;
}

1900 is not a leap year
1996 is a leap year
2000 is a leap year
2023 is not a leap year
2024 is a leap year
2100 is not a leap year
2400 is a leap year

And reading the year from the user, which is what the practical asks:

#include <stdio.h>

int main(void)
{
    int year;

    printf("Enter a year: ");
    if (scanf("%d", &year) != 1) {
        printf("\nThat was not a year.\n");
        return 1;
    }
    if (year < 1) {
        printf("\nThere is no year %d in this calendar.\n", year);
        return 1;
    }

    if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) {
        printf("\n%d is a leap year.\n", year);
    } else {
        printf("\n%d is not a leap year.\n", year);
    }
    return 0;
}

1900

Enter a year:
1900 is not a leap year.

For the algorithm and flowchart the same practical asks for, see chapter 2, which draws this test as three decision diamonds.

Two traps worth a mark each

1. a < b < c does not mean what it says in mathematics. It groups as (a < b) < c, and (a < b) is 0 or 1, so the whole thing compares 0 or 1 against c. Write a < b && b < c.

The listing below is wrong on purpose, and gcc says so before it is even run:

#include <stdio.h>

int main(void)
{
    int a = 10, b = 5, c = 1;

    printf("mathematically 10 < 5 < 1 is false\n");
    printf("in C, a < b < c gives %d, because (a < b) is %d and %d < c is %d\n",
           a < b < c, a < b, a < b, (a < b) < c);
    printf("written correctly, a < b && b < c gives %d\n", a < b && b < c);
    return 0;
}

chained.c: In function ‘main’:
chained.c:9:14: warning: comparisons like ‘X<=Y<=Z’ do not have their mathematical meaning [-Wparentheses]
    9 |            a < b < c, a < b, a < b, (a < b) < c);
      |            ~~^~~

It runs anyway, because a warning is not an error, and this is what it prints:

mathematically 10 < 5 < 1 is false
in C, a < b < c gives 1, because (a < b) is 0 and 0 < c is 1
written correctly, a < b && b < c gives 0

2. Never compare floating-point values with ==. Chapter 9 said why: the stored value is the nearest representable one, and arithmetic can land on a different neighbour.

#include <stdio.h>
#include <math.h>

int main(void)
{
    double x = 0.1 + 0.2;

    printf("x == 0.3 is %d\n", x == 0.3);
    printf("fabs(x - 0.3) < 1e-9 is %d\n", fabs(x - 0.3) < 1e-9);
    printf("x is actually %.20f\n", x);
    return 0;
}

x == 0.3 is 0
fabs(x - 0.3) < 1e-9 is 1
x is actually 0.30000000000000004441

fabs(x - y) < tolerance is the form to write, and the tolerance is chosen for the problem.

What this does NOT mean

A relational expression does not produce a special truth type. It produces an int, 1 or 0, which is why it can be printed with %d and added up.

"True" is not 1. Any non-zero value is true as a condition. if (7) runs, and !7 is 0. Only the operators produce 1.

& and | are not && and ||. The single-character forms are bitwise operators: they combine the bits of their operands and they always evaluate both sides. 1 & 2 is 0 while 1 && 2 is 1.

! is not negation. !x is 1 or 0. Arithmetic negation is -x.

Short circuiting is not an optimisation the compiler may skip. It is required by the standard, and programs depend on it for safety.

if (x = 5) is not a syntax error. It is a legal assignment used as a condition, and it is nearly always a typing mistake for ==.

Quick revision

• Six relational operators: < > <= >= == !=. Each yields int 1 or 0.
• Zero is false; any non-zero value is true.
• = assigns, == compares. if (x = 5) is legal and always true.
• Three logical operators: &&, ||, !.
• && and || short-circuit, guaranteed by the standard, left operand first.
• count != 0 && total / count > 50 is safe because of it.
• && binds tighter than ||, so an OR inside an AND needs brackets.
• Leap year: y % 4 == 0 && (y % 100 != 0 || y % 400 == 0).
• a < b < c is a bug. Write a < b && b < c.
• Never compare floating-point values with ==; use fabs(x - y) < tolerance.
• & and | are bitwise and evaluate both operands.

Test yourself

1. What is the value of 5 > 3 and what is its type?

1, of type int.

2. What does if (n = 0) do?

It assigns 0 to n and then tests 0, which is false, so the body never runs. It was almost certainly meant to be if (n == 0).

3. Write the leap-year condition and say why the brackets are needed.

year % 4 == 0 && (year % 100 != 0 || year % 400 == 0). Without them, && binding tighter than || would group the expression as (y % 4 == 0 && y % 100 != 0) || y % 400 == 0, which is a different test built on wrong reasoning.

4. Why is if (n != 0 && 100 / n > 5) safe while if (100 / n > 5 && n != 0) is not?

&& evaluates the left operand first and skips the right if the left is false. In the first form the division is reached only when n is non-zero. In the second the division happens first and divides by zero.

5. What is !(-5)?

1. Minus five is non-zero, so it is true, and the logical NOT of true is 0.

6. Give the difference between && and &.

&& is logical AND: it produces 1 or 0 and does not evaluate its right operand if the left is false. & is bitwise AND: it combines the bits of its operands and always evaluates both.

7. Is 2100 a leap year?

No. It is divisible by 4 and by 100 and not by 400, so the century exception applies.

What can be asked on this, and how to answer it

"Explain the relational and logical operators in C." Give the six relational with a value each, then the three logical, and then the two things the examiner is looking for: that the result is an int of 1 or 0, and that && and || short-circuit. Give the safe-division example for the second.

"What is short-circuit evaluation? Give an example where it matters." Define it, say the standard guarantees it, and give count != 0 && total / count > 50. Say that reversing the order makes the program divide by zero, which is what turns it from a nicety into a rule.

"Distinguish between = and ==." = assigns and yields the value assigned; == compares and yields 1 or 0. if (x = 5) is always true, and if (x == 5) tests. This is a favourite one-mark question.

"Write a program to check whether a year is a leap year." Give this chapter's program with the full three-part rule, and state the three test cases that show you understand it: 2024 yes, 1900 no, 2000 yes.

"Distinguish between logical and bitwise operators." Logical operators treat their operands as true or false, produce 1 or 0, and short-circuit. Bitwise operators work on the individual bits, produce a bit pattern, and always evaluate both operands. 1 && 2 is 1; 1 & 2 is 0.

i = 5; printf with ++i gives 6, and i is now 6
i = 5; printf with i++ gives 5, and i is now 6
i = 5; printf with --i gives 4, and i is now 4
i = 5; printf with i-- gives 5, and i is now 4

Each of those printf calls passes i twice, once through the operator and once plainly, and the order in which printf's arguments are evaluated is unspecified. The program above is therefore relying on something it should not, and it is shown here only because it is what every textbook shows. The next section is the honest version, and it is the one to learn from.

The honest version: one change per statement

#include <stdio.h>

int main(void)
{
    int i = 5;
    int taken;

    taken = ++i;
    printf("after taken = ++i : taken is %d and i is %d\n", taken, i);

    i = 5;
    taken = i++;
    printf("after taken = i++ : taken is %d and i is %d\n", taken, i);

    i = 5;
    taken = --i;
    printf("after taken = --i : taken is %d and i is %d\n", taken, i);

    i = 5;
    taken = i--;
    printf("after taken = i-- : taken is %d and i is %d\n", taken, i);
    return 0;
}

after taken = ++i : taken is 6 and i is 6
after taken = i++ : taken is 5 and i is 6
after taken = --i : taken is 4 and i is 4
after taken = i-- : taken is 5 and i is 4

In every case i ends up as 6 or 4. The only thing that differs is what was handed to taken, and that is the entire content of the topic.

When the difference does not matter

i++;        /* as a statement on its own */
++i;        /* identical effect          */

As a complete statement, nothing uses the expression's value, so the two forms do exactly the same thing. Both compile to the same instruction. Use whichever you find clearer; this book uses i++ in a for loop because that is what every C program does.

The claim that ++i is faster than i++ is folklore. It was never true for an int on any compiler you will use. It can matter in C++ for a large object with an overloaded operator, and C has no such thing.

When the difference matters: walking an array

This is the real use, and it is worth seeing once now and again in chapter 37.

#include <stdio.h>

int main(void)
{
    int a[5] = {10, 20, 30, 40, 50};
    int i = 0;
    int sum = 0;

    while (i < 5) {
        sum = sum + a[i++];         /* use a[i], THEN step i */
    }
    printf("sum with a[i++] is %d, and i ended at %d\n", sum, i);

    i = 0;
    printf("the first three, taken with a[i++]: ");
    printf("%d ", a[i++]);
    printf("%d ", a[i++]);
    printf("%d\n", a[i++]);
    return 0;
}

sum with a[i++] is 150, and i ended at 5
the first three, taken with a[i++]: 10 20 30

Each printf above is a separate statement, so each i++ is safely sequenced against the others. That is the discipline: one modification of a variable per statement.

The undefined-behaviour question, and how to answer it

Question banks ask for the value of things like this:

i = 5;
j = i++ + ++i;
printf("%d %d\n", i, j);

There is no answer. The standard says that if two side effects on the same object are unsequenced, the behaviour is undefined, and there are two modifications of i here with nothing sequencing them. Undefined behaviour means the standard places no requirement on the result at all: the program may print anything, may print something different on the next compiler, and is not required to be consistent.

gcc says so itself. This listing is wrong on purpose:

#include <stdio.h>

int main(void)
{
    int i = 5;
    int j;

    j = i++ + ++i;
    printf("i is %d and j is %d, and neither is guaranteed\n", i, j);
    return 0;
}

This book does not print what that program produced, and will not. Its result is undefined, so any number printed here would be a claim about a program the standard makes no promise about, and a reader would reasonably take it for the answer. The compiler's warning is the whole of what can honestly be shown:

unsequenced.c: In function ‘main’:
unsequenced.c:8:10: warning: operation on ‘i’ may be undefined [-Wsequence-point]
    8 |     j = i++ + ++i;
      |         ~^~

The answer to write in an examination, which is correct and complete:

The expression modifies i twice without an intervening sequence point, so by clause 6.5 of the standard the behaviour is undefined. The standard imposes no requirement on the result, so no value can be given, and different compilers will produce different answers. Written correctly as two statements, j = i++; j = j + ++i; the result is defined.

Some examiners want the number their own textbook prints. If you are certain that is what is wanted, give the textbook value and add the sentence above. The sentence cannot be marked wrong and it is the difference between having memorised an answer and understanding one.

Which expressions are safe

The last row is the exception that makes the rule clear: &&, | |, the comma operator and the conditional operator ?: all impose an order, so they sequence their operands. Everything else does not.

The one rule to take away

Modify a variable at most once in a statement, and do not also read it elsewhere in that statement. Follow it and you will never meet this problem. Break it and no amount of care about prefix and postfix will save you.

What this does NOT mean

++ does not work on a constant. 5++ does not compile. The operand must be something that can be assigned to.

++i is not "faster". For an int the two forms compile identically.

Postfix does not mean "later". The increment happens as part of evaluating the expression, not at the end of the statement. What is postponed is nothing; what differs is which value the expression yields.

Undefined behaviour is not "whatever your compiler does". It is a licence for the compiler to do anything, including assuming the case cannot arise and optimising on that basis. A program with undefined behaviour cannot be reasoned about at all.

i = i + 1 is not worse than i++. It is longer and perfectly correct. Prefer ++ where the thing being stepped is long enough that repeating it invites a mistake.

Quick revision

• ++ adds one, -- subtracts one.
• Prefix ++i yields the new value; postfix i++ yields the old.
• Read the operator in the order written: ++i is increment-then-use; i++ is use-then-increment.
• As a whole statement the two forms are identical in effect.
• Modifying a variable twice in one statement is undefined behaviour, not a puzzle.
• &&, | |, ?: and the comma operator sequence their operands; nothing else does.
• The operand must be assignable: 5++ does not compile.
• -Wall reports an unsequenced modification, and it is right.

Test yourself

1. After int i = 10; int j = i++; what are i and j?

i is 11 and j is 10. Postfix yields the old value.

2. After int i = 10; int j = ++i; what are i and j?

Both 11. Prefix yields the new value.

3. Is there a difference between i++; and ++i; as complete statements?

No. The value of the expression is discarded, so both simply add one.

4. What is the value of j after int i = 5; int j = i++ + ++i;?

The question has no answer. i is modified twice with nothing sequencing the two, so the behaviour is undefined and the standard permits any result.

5. Is a[i] = i++; safe?

No. i is both read, to index the array, and modified, and the two are unsequenced. Write a[i] = i; i++;.

6. Why is x = i++ && i++; safe when x = i++ + i++; is not?

&& is guaranteed to evaluate its left operand fully, with a sequence point, before the right. Addition imposes no such order.

7. Rewrite sum = sum + a[i++]; without the increment operator.

sum = sum + a[i]; i = i + 1;

What can be asked on this, and how to answer it

"Explain the increment and decrement operators with examples." Give the four forms in a table with what each yields, the read-in-order rule, and a two-line program showing taken = i++ against taken = ++i. Add that as a standalone statement the two are identical, because that is the part most answers leave out.

"Distinguish between prefix and postfix increment." Prefix increments first and yields the new value; postfix yields the old value and then increments. In both cases the variable ends one larger. Give int i = 5; j = ++i; against int i = 5; j = i++; with the values.

"What is the output of i = 5; printf("%d %d", i++, ++i);?" Say that the behaviour is undefined: i is modified twice in one expression with nothing sequencing the two, and the order of evaluation of function arguments is unspecified besides. No value can be given, and different compilers differ. Then give the correct rewrite.

"Can ++ be applied to an expression like (a + b)?" No. The operand must be a modifiable object, and a + b is a value, not a place. (a + b)++ does not compile.

Where an assignment in a condition is deliberate, put extra brackets round it. That is the convention that tells a reader, and the compiler, that you meant it, and it is what turns off the warning.

The compound assignment operators

Five more exist for the bitwise operators, &=, |=, ^=, <<= and >>=. They work the same way. MU names no bitwise operator on this paper, so they are not taught here; know that they exist.

#include <stdio.h>

int main(void)
{
    int x = 10;

    printf("x starts at %d\n", x);
    x += 3;  printf("after x += 3 : %d\n", x);
    x -= 5;  printf("after x -= 5 : %d\n", x);
    x *= 4;  printf("after x *= 4 : %d\n", x);
    x /= 3;  printf("after x /= 3 : %d\n", x);
    x %= 7;  printf("after x %%= 7 : %d\n", x);
    return 0;
}

x starts at 10
after x += 3 : 13
after x -= 5 : 8
after x *= 4 : 32
after x /= 3 : 10
after x %= 7 : 3

Three reasons to prefer the compound form, and the third is the one that is not obvious.

1. The variable is named once, so a long left-hand side cannot be mistyped on one side only.
2. It is shorter to read, once you are used to it.
3. The brackets are implied round the right-hand side. x = a + b is x = x (a + b), not x = x * a + b. This is a guarantee of the language, and it is the opposite of what happens with a careless #define (chapter 22).

#include <stdio.h>

int main(void)
{
    int x = 10, a = 2, b = 3;
    int y = 10;

    x *= a + b;                 /* x = x * (a + b) */
    y = y * a + b;              /* the careless reading */
    printf("x *= a + b   gives %d\n", x);
    printf("y = y * a + b gives %d\n", y);
    return 0;
}

x *= a + b   gives 50
y = y * a + b gives 23

The compound operators are not simply text substitution in one other way too: in a[f()] += 1 the expression f() is evaluated once. Written out as a[f()] = a[f()] + 1 it would be evaluated twice.

Assignment converts

The right-hand side is converted to the type of the left-hand side, and chapter 14's third rule applies: something may be lost.

#include <stdio.h>

int main(void)
{
    int i;
    double d;
    char c;

    i = 3.99;      printf("int i = 3.99      gives %d\n", i);
    d = 7 / 2;     printf("double d = 7 / 2  gives %.4f\n", d);
    c = 'A' + 2;   printf("char c = 'A' + 2  gives %c\n", c);
    i = -3.99;     printf("int i = -3.99     gives %d\n", i);
    return 0;
}

int i = 3.99      gives 3
double d = 7 / 2  gives 3.0000
char c = 'A' + 2  gives C
int i = -3.99     gives -3

double d = 7 / 2; is 3.0. The division is integer division and it happened before the assignment was reached. This is the same trap as chapter 14's and it is worth meeting twice.

The comma operator, briefly

, is also an operator: it evaluates its left operand, discards the result, evaluates its right operand, and yields that. It does impose an order, so it is one of the four operators that sequence their operands.

for (i = 0, j = n - 1; i < j; i++, j--)

That is nearly the only place you will see it, and it is the right place: two counters stepped in one for header. Chapter 28.

The commas separating function arguments and separating declarators are not the comma operator. They are punctuation, and they impose no order, which is why printf("%d %d", i++, i) is unsafe.

What this does NOT mean

= is not equality. == is. = stores.

x += 1 is not x++. They have the same effect on x, and x++ as an expression yields the old value while x += 1 yields the new one. As statements they are the same.

Assignment does not return a variable. It yields a value. (a = b) = c does not compile in C, because the result of an assignment is not an lvalue.

Chained assignment does not mean all the variables get the same stored value. Each step converts to its own type. i = d = 3.7 leaves different values in i and d.

x = a + b is not x = x a + b. The right-hand side is bracketed by the language.

An lvalue is not "a variable". An array element, a structure member and *p are all lvalues. A const object is an lvalue that cannot be assigned to.

Quick revision

• = stores the right-hand side, converted to the left-hand type, and yields the stored value.
• The left-hand side must be an lvalue: a place, not a value.
• = groups right to left, so a = b = c = 0 works.
• An assignment is an expression: while ((c = getchar()) != EOF) uses that, and if (x = 5) is the bug that comes from it.
• Ten compound operators; the five arithmetic ones are += -= *= /= %=.
• x op= y is x = x op (y): the right-hand side is bracketed, and the left-hand side is evaluated once.
• Assignment converts, and may lose data. double d = 7 / 2; is 3.0.
• The comma operator evaluates left then right and yields the right; the commas between function arguments are not it.

Test yourself

1. What is the value of the expression x = 7?

1. An assignment yields the value it stored.

2. What does a = b = 5; do, and in what order?

b = 5 is evaluated first, because = groups right to left; it yields 5, which is then assigned to a. Both end as 5.

3. Rewrite total = total + marks[i] * weight; with a compound operator, and say what the brackets do.

total += marks[i] weight;. The right-hand side is implicitly bracketed, so this is total = total + (marks[i] weight), which is what was wanted.

4. x = 10; x *= 2 + 3; What is x?

1. The right-hand side is bracketed, so it is x = x * (2 + 3).

5. Why does while (c = getchar() != EOF) not work?

!= binds tighter than =, so getchar() != EOF is evaluated first and its 1 or 0 is stored in c. The character is lost. Write while ((c = getchar()) != EOF).

6. What is in d after double d = 5 / 2;?

2.0. Both operands are int, so integer division gives 2, which is then converted on assignment.

7. Is (a = b) = c; legal?

No. The result of an assignment in C is a value, not an lvalue, so it cannot appear on the left of another assignment.

What can be asked on this, and how to answer it

"Explain the assignment operators in C." Give plain = with the lvalue requirement and the conversion rule, then the compound operators in a table, then the three properties that earn the extra marks: an assignment is an expression with a value, = groups right to left, and x op= y brackets the right-hand side and evaluates the left-hand side once.

"What is the difference between x = x + 5 and x += 5?" They have the same effect. += names the variable once, which matters when the left-hand side is long, and it brackets the right-hand side, so x += a + b differs from x = x + a + b only in that the first cannot be misread. Add that x is evaluated once in the compound form.

"Why does if (a = 10) always execute its body?" Because a = 10 is an assignment expression whose value is 10, and any non-zero value is true. It was almost certainly meant to be if (a == 10).

"What is an lvalue?" An expression that designates an object, so it may appear on the left of an assignment: a variable, an array element, a structure member, or *p. 5 and a + b are not lvalues, and a const object is an lvalue that may not be assigned to.

"Explain the comma operator." It evaluates its left operand, discards the value, evaluates its right operand and yields that, with a guaranteed order between them. Its normal use is stepping two counters in a for header. Note that the commas separating function arguments are punctuation, not this operator.

Nested, in one expression. This is the answer the question is asking for.

#include <stdio.h>

int main(void)
{
    int a, b, c;

    printf("Enter three numbers: ");
    if (scanf("%d %d %d", &a, &b, &c) != 3) {
        printf("\nThose were not three numbers.\n");
        return 1;
    }

    int largest = a > b ? (a > c ? a : c) : (b > c ? b : c);

    printf("\nThe largest of %d, %d and %d is %d\n", a, b, c, largest);
    return 0;
}

34 91 57

Enter three numbers:
The largest of 34, 91 and 57 is 91

Read the expression in two halves. a > b decides which of a and b could still win. If a won, the remaining question is a against c; if b won, it is b against c. Three comparisons at most, and the brackets make the structure visible.

The brackets round the inner conditionals are not required, because ?: groups right to left, but write them. Nested conditionals without brackets are the standard example of unreadable C.

Two-step, which is clearer. Worth giving as well, and saying why you did:

int largest = a > b ? a : b;
largest = largest > c ? largest : c;

In the viva, the question after "write it" is usually "which would you prefer and why". The honest answer is the two-step form for readability, and the nested form because the question asked for one expression. Say both.

The same thing with if, for comparison

int largest;
if (a > b) {
    largest = a > c ? a : c;
} else {
    largest = b > c ? b : c;
}

or entirely without the conditional operator:

int largest = a;
if (b > largest) largest = b;
if (c > largest) largest = c;

That last form is the one that scales: for ten numbers it becomes a loop, and the nested conditional does not. It is chapter 36's pattern, and it is the right answer to "find the largest in an array". It is not the answer to this practical, which names the operator.

Where it is genuinely the right tool

1. Choosing a word inside output. The example that started the chapter.

2. Choosing a value in an initialisation, where if would force you to declare without a value first.

const double rate = years > 5 ? 8.5 : 7.25;

3. Guarding a division, shown above.

4. Singular and plural.

#include <stdio.h>

int main(void)
{
    for (int n = 0; n <= 3; n++) {
        printf("%d file%s found\n", n, n == 1 ? "" : "s");
    }
    return 0;
}

0 files found
1 file found
2 files found
3 files found

Where it is the wrong tool: anywhere the two branches do something rather than produce a value. x > 0 ? printf("pos\n") : printf("neg\n"); works and is bad style, because it uses an expression's value for nothing and hides a decision inside one. Use if.

Nesting, and when to stop

A conditional operator can be nested in either branch, and ?: groups right to left, so:

grade = marks >= 70 ? 'O'
      : marks >= 60 ? 'A'
      : marks >= 55 ? 'B'
      : marks >= 50 ? 'C'
      : marks >= 40 ? 'D'
      :               'F';

Laid out one condition per line like that, it is readable and it is a genuine use: every branch produces a value of the same kind. Written on one line it is unreadable. Chapter 25 gives the same thing as an else if ladder, which is what most programs use.

What this does NOT mean

?: is not a shorter if. It is an expression, so it has a value and must produce one. if is a statement and produces nothing. Where you want two branches that act rather than evaluate, if is correct.

It does not evaluate both branches. Exactly one is evaluated, guaranteed.

The two branches are not free to be any types. They are converted to a common type, which is the type of the whole expression. cond ? 1 : 2.5 has type double and yields 1.0 when the condition is true, not 1.

It is not the only ternary operator, it is the only one C has. "Ternary" describes the number of operands. Since C has exactly one such operator, the two names have come to mean the same thing.

Nesting is not automatically bad. A ladder of conditions each producing a value, laid out one per line, is clear. What is bad is nesting inside the condition rather than inside a branch, and putting it all on one line.

Quick revision

• condition ? a : b yields a if the condition is non-zero, otherwise b.
• It is the only operator in C with three operands, so "ternary" and "conditional" name the same thing.
• Exactly one branch is evaluated, which makes it safe for guarding a division.
• It is an expression, so it can appear inside a printf argument or an initialiser, where if cannot.
• It groups right to left, so nesting in the false branch needs no brackets. Write them anyway.
• The two branches are converted to a common type, which becomes the type of the expression.
• Greatest of three: a > b ? (a > c ? a : c) : (b > c ? b : c).
• Use if when the branches act rather than produce a value.

Test yourself

1. What is the value of 5 > 3 ? 10 : 20?

10.

2. Write one statement that prints "even" or "odd" for an int n.

printf("%s\n", n % 2 == 0 ? "even" : "odd");

3. Write the greatest of three numbers using only the conditional operator.

int largest = a > b ? (a > c ? a : c) : (b > c ? b : c);

4. Is count != 0 ? total / count : 0 safe when count is zero?

Yes. Only the branch selected is evaluated, so the division never happens when count is zero.

5. What is the type and value of 1 ? 1 : 2.5?

Type double, value 1.0. The two branches are converted to a common type before the expression has a value.

6. Why can ?: appear inside a printf argument when if cannot?

Because ?: is an operator and produces a value, and a function argument must be an expression. if is a statement and has no value.

7. Rewrite max = a > b ? a : b; using if.

if (a > b) max = a; else max = b;

What can be asked on this, and how to answer it

"What is the conditional operator? Explain with an example." Give the form, say it is the only ternary operator in C, give one example that produces a value inside a larger expression, and add that exactly one branch is evaluated. That last point is what distinguishes a full answer.

"Write a program to find the greatest of three numbers using the conditional operator." Give this chapter's program with the nested expression, and read the expression out in the two halves. Keep the scanf return check; it is one line and it is the difference between a program and a program that works.

"Distinguish between the conditional operator and the if-else statement." ?: is an expression: it produces a value and can be used wherever a value is wanted, and each branch must be an expression. if-else is a statement: it selects which statement to execute, the branches may contain any number of statements, and it produces no value. Both evaluate only the branch selected.

"Can the conditional operator be nested? Give an example." Yes, in either branch, and it groups right to left. Give the grade ladder laid out one condition per line, and say that beyond three or four branches an else if ladder or a switch is clearer.

What to actually memorise, because nobody recalls a sixteen-row table under pressure:

1. Unary before binary.
2. * / % before + -.
3. Arithmetic before relational.
4. Relational before == and !=.
5. && before ||.
6. Logical before ?:, and ?: before assignment.
7. Assignment and the unary operators go right to left; everything else goes left to right.
8. Comma is last.

Those eight cover every expression on this paper.

The five groupings that are asked about

gcc warns on two of the lines below, and that is the chapter's point made for us: the cases this section calls surprising are the cases the compiler itself thinks you should bracket.

#include <stdio.h>

int main(void)
{
    int a = 10, b = 5, c = 2;

    printf("a + b * c        = %d, grouped a + (b * c)\n", a + b * c);
    printf("a > b == 1       = %d, grouped (a > b) == 1\n", a > b == 1);
    printf("a & b == 0       = %d, grouped a & (b == 0)  <- surprising\n",
           a & b == 0);
    printf("!a + b           = %d, grouped (!a) + b\n", !a + b);
    printf("a - b - c        = %d, grouped (a - b) - c\n", a - b - c);
    printf("c * a %% b        = %d, grouped (c * a) %% b\n", c * a % b);
    return 0;
}

surprising.c: In function ‘main’:
surprising.c:8:63: warning: suggest parentheses around comparison in operand of ‘==’ [-Wparentheses]
    8 |     printf("a > b == 1       = %d, grouped (a > b) == 1\n", a > b == 1);
      |                                                             ~~^~~
surprising.c:10:18: warning: suggest parentheses around comparison in operand of ‘&’ [-Wparentheses]
   10 |            a & b == 0);
      |                ~~^~~~

It compiles and runs, and prints this:

a + b * c        = 20, grouped a + (b * c)
a > b == 1       = 1, grouped (a > b) == 1
a & b == 0       = 0, grouped a & (b == 0)  <- surprising
!a + b           = 5, grouped (!a) + b
a - b - c        = 3, grouped (a - b) - c
c * a % b        = 0, grouped (c * a) % b

The third line is the famous one. & sits below == in the table, so a & b == 0 means a & (b == 0), which is almost never what anyone intends. It is the reason many style guides require brackets round any bitwise operation. The same applies to a & b | c.

Order of evaluation: the part that is not fixed

Now the other half of MU's label, and it is a genuinely different question.

Precedence does not tell you when anything is computed. In f() + g() h(), precedence tells you the expression is f() + (g() h()). It does not tell you whether f, g or h is called first. The standard leaves that unspecified, which means the compiler may choose, may choose differently at a different optimisation level, and need not tell you.

#include <stdio.h>

int order[3];
int next = 0;

int record(int who, int value)
{
    order[next] = who;
    next = next + 1;
    return value;
}

int main(void)
{
    int total = record(1, 2) + record(2, 3) * record(3, 4);

    printf("the expression is %d, which precedence alone settles\n", total);
    printf("but the calls happened in the order %d, %d, %d\n",
           order[0], order[1], order[2]);
    printf("and that order is UNSPECIFIED: another compiler may differ\n");
    return 0;
}

the expression is 14, which precedence alone settles
but the calls happened in the order 1, 2, 3
and that order is UNSPECIFIED: another compiler may differ

The value, 14, is fixed by precedence: 2 + (3 * 4). The order the three functions ran in is the compiler's choice, and the program printing it does not make it a rule.

The same is true of function arguments. printf("%d %d\n", f(), g()) does not say which of f and g runs first.

The four operators that DO fix an order

&&    left operand fully evaluated first, then the right only if needed
||    left operand fully evaluated first, then the right only if needed
?:    condition fully evaluated first, then exactly one branch
,     left operand fully evaluated and discarded, then the right

Those four, and nothing else. Chapters 16, 19 and 18 each proved one of them with a counter.

Undefined behaviour, which is a third thing again

Unspecified order becomes undefined behaviour when two unsequenced operations touch the same object and at least one of them modifies it.

• f() + g(): unspecified order. Legal, and the value is well defined if neither function touches the other's data.
• i++ + ++i: undefined behaviour. i is modified twice with nothing sequencing the two.

The difference matters. Unspecified means "one of several possible behaviours, and the standard does not say which". Undefined means "no requirement at all". Chapter 17 has the rule and the compiler's own warning.

What to do about all this

Two habits, and they cost nothing.

1. Bracket for the reader, not for the compiler. a + b * c needs no brackets and reads fine. (a & b) == 0 needs them to be correct and a && (b || c) needs them to be correct. Where a reader would have to consult a table, add brackets.

2. One side effect per statement. Then the unspecified order cannot reach you.

int x = f();
int y = g();
int total = x + y;      /* the order is now yours, and visible */

What this does NOT mean

Precedence is not order of evaluation. Precedence groups; order decides when. This is the whole point of MU's two-part label.

Left-to-right associativity does not mean left-to-right evaluation. f() - g() - h() groups as (f() - g()) - h(), and the three calls may still happen in any order.

Brackets do not force an order of evaluation. (f()) + (g()) is exactly as unspecified as f() + g(). Brackets change grouping, nothing else.

A precedence table does not settle i++ + ++i. That expression is undefined behaviour, and no table can give it a value.

&& is not "higher precedence than ||" in the sense of running first. It is higher precedence, so it groups tighter; separately, it also fixes an order. Two different guarantees that happen to hold for the same operator.

Quick revision

• Precedence groups an expression; associativity breaks ties at equal precedence; order of evaluation decides when operands are computed.
• * / % above + -; arithmetic above relational; relational above equality; && above ||; ?: above assignment; comma last.
• Unary operators, ?: and assignment go right to left. Everything else goes left to right.
• & and | sit BELOW ==, so a & b == 0 is a & (b == 0). Bracket bitwise operations.
• Order of evaluation of most operands, and of all function arguments, is unspecified.
• Only &&, ||, ?: and the comma operator fix an order.
• Unspecified is not undefined: f() + g() is fine, i++ + ++i is not.
• Brackets change grouping, never order.

Test yourself

1. What is 2 + 3 * 4 - 6 / 3?

1. It groups as 2 + (3 * 4) - (6 / 3), which is 2 + 12 - 2.

2. What is 10 - 4 - 3, and why not 9?

1. - is left-associative, so it groups as (10 - 4) - 3.

3. What does a & b == 0 group as, and is it what a programmer usually wants?

a & (b == 0), because == has higher precedence than &. It is almost never what was wanted; write (a & b) == 0.

4. In f() + g(), which function is called first?

Unspecified. The standard does not fix it, and different compilers or different optimisation levels may differ.

5. Name the only four operators in C that impose an order on their operands.

&&, ||, ?: and the comma operator.

6. Does adding brackets to f() + g() fix the order of the calls?

No. Brackets affect grouping only. To fix the order, put the calls in separate statements.

7. What is 5 > 3 > 1?

1. It groups as (5 > 3) > 1, which is 1 > 1, which is 0.

What can be asked on this, and how to answer it

"Explain operator precedence and associativity in C with examples." Define both, give the eight rules worth memorising rather than the whole table, and give three worked expressions with their grouping shown in brackets. Include one surprising case, for which a & b == 0 or 5 > 3 > 1 is ideal.

"What is the difference between precedence and order of evaluation?" Precedence and associativity decide how the expression is grouped, and are completely fixed by the language. Order of evaluation decides when each operand is computed, and for most operators the standard leaves it unspecified. Give f() + g() * h(): precedence fixes the value, the order of the three calls is the compiler's choice.

"Which operators guarantee an order of evaluation?" &&, ||, the conditional operator and the comma operator. Say what the guarantee buys: count != 0 && total / count > 5 cannot divide by zero.

"Give the precedence table for C operators." Reproduce the levels from arithmetic downwards, which is what is actually being asked, and say that the bitwise and shift levels sit between the equality operators and &&. Marking the associativity of each level is usually worth a mark on its own.

"Evaluate a = 2, b = 3; printf("%d", a++ * b-- + --a);" Say that the behaviour is undefined, because a is modified twice in one expression with nothing sequencing the two operations, and no precedence table can give it a value. Rewrite it as separate statements to show what a defined version looks like.

pass 0: fresh is 1, kept is 1
pass 1: fresh is 1, kept is 2
pass 2: fresh is 1, kept is 3

static changes the lifetime and not the scope. kept still cannot be named outside the loop body; it simply survives out there, waiting.

Shadowing

An inner block may declare a name that already exists outside it. The inner declaration hides the outer one for the rest of that block. This is legal, it is occasionally useful, and it is usually a mistake.

#include <stdio.h>

int value = 100;               /* global */

int main(void)
{
    int value = 10;            /* hides the global */
    printf("in main, value is %d\n", value);

    {
        int value = 1;         /* hides main's */
        printf("in the inner block, value is %d\n", value);
    }

    printf("back in main, value is %d again\n", value);
    return 0;
}

in main, value is 10
in the inner block, value is 1
back in main, value is 10 again

Three objects called value exist at once and each printf reaches the nearest one. Nothing is wrong with that program and it is still a bad idea: a reader has to count braces to know which value a line means, and a typing mistake that was meant for one will silently hit another. Give the inner variable a different name.

The one honest use of shadowing is a loop counter: for (int i = ...) inside a function that also has an i somewhere far away. Even then, a different name is clearer.

for and its own scope

Since C99, a variable declared in a for header belongs to the loop.

for (int i = 0; i < n; i++) {
    ...
}
/* i does not exist here */

This is the form to use. It says the counter is the loop's business and nobody else's, and it means two loops in one function can both use i without interfering. Chapter 28.

Initialisation

The general rule: an object may be given a value at the point it is created, and for some kinds of object that is the only way to give it one.

A scalar: covered in chapter 11.

int marks = 75;
double rate = 8.5;
char grade = 'A';

An array: a braced list. Chapter 36 is arrays proper; this is the initialisation rule.

#include <stdio.h>

int main(void)
{
    int a[5] = {10, 20, 30, 40, 50};   /* all five given            */
    int b[5] = {10, 20};               /* the rest are set to 0     */
    int c[5] = {0};                    /* every element 0           */
    int d[] = {1, 2, 3};               /* size counted for you: 3   */
    int e[5] = {[4] = 99, [0] = 11};   /* C99: by position, any order */

    printf("a: "); for (int i = 0; i < 5; i++) printf("%d ", a[i]);
    printf("\nb: "); for (int i = 0; i < 5; i++) printf("%d ", b[i]);
    printf("\nc: "); for (int i = 0; i < 5; i++) printf("%d ", c[i]);
    printf("\nd has %zu elements: ", sizeof d / sizeof d[0]);
    for (int i = 0; i < 3; i++) printf("%d ", d[i]);
    printf("\ne: "); for (int i = 0; i < 5; i++) printf("%d ", e[i]);
    printf("\n");
    return 0;
}

a: 10 20 30 40 50
b: 10 20 0 0 0
c: 0 0 0 0 0
d has 3 elements: 1 2 3
e: 11 0 0 0 99

Four rules come out of that:

1. A partly initialised array has the rest set to zero. So int c[5] = {0}; zeroes the whole array, and it is the standard idiom for doing so.
2. An array with no initialiser at all is not zeroed if it is automatic. int a[5]; inside a function holds rubbish, exactly as a single int does.
3. int d[] = {1, 2, 3}; lets the compiler count. sizeof d / sizeof d[0] then recovers the count, and that expression is worth memorising.
4. Designated initialisers, [4] = 99, were added in C99 and let you give elements by position in any order, with everything else zero.

A string: chapter 12's rule, which is the array rule with a terminator.

char name[] = "Anita";      /* 6 bytes, counted for you */
char buf[20] = "Anita";     /* 20 bytes, 14 of them zero */

You may initialise a character array from a string literal and you may not assign one. char s[6]; s = "Anita"; does not compile. Initialisation and assignment are different events, and only the first can fill an array.

const and initialisation

A const object can only ever be given its value at initialisation, because assignment to it is not allowed. That is the point of it.

const double PI = 3.14159;     /* the only chance to set it */

What this does NOT mean

A block is not a function. Both use braces. A function has a name, parameters and a return type, and is called; a block is a piece of a function.

Scope is not lifetime. Scope is where a name is visible; lifetime is how long the object exists. A static variable in a block has block scope and program lifetime.

Entering a block does not clear it. An automatic variable with no initialiser holds whatever was in that memory, every time the block is entered.

Shadowing is not an error. It compiles, and that is the problem.

A partly initialised array is not partly undefined. The elements you did not give are zero. This is the one case where C does zero things for you, and it applies only when there is an initialiser present.

int a[5] = {1}; does not set every element to 1. It sets the first to 1 and the rest to 0. int a[5] = {0}; happens to work as "all zero" only because the fill value is also zero.

Quick revision

• A block is braces containing declarations and statements, and counts as one statement.
• A name declared in a block is visible from its declaration to the closing brace.
• An automatic object is created on entry to its block and destroyed on exit, and is not zeroed.
• static in a block changes lifetime to the whole program; scope is unchanged.
• An inner declaration of the same name shadows the outer one. Legal, and to be avoided.
• Since C99, for (int i = ...) scopes the counter to the loop.
• An array is initialised with a braced list; elements left out are zero.
• int a[5] = {0}; zeroes an array; int a[5]; in a function does not.
• int d[] = {1,2,3}; counts for you, and sizeof d / sizeof d[0] recovers the count.
• C99 designated initialisers: int e[5] = {[4] = 99};.
• An array can be initialised from a string literal but never assigned one.
• A const object must be given its value at initialisation.

Test yourself

1. What is the scope of a variable declared inside an if body?

From its declaration to the closing brace of that body. It cannot be named after the if.

2. Does a variable declared inside a loop body keep its value between passes?

No. It is created and destroyed on each pass. Declare it before the loop, or make it static, if it must persist.

3. What is shadowing? Is it an error?

Declaring a name in an inner block that already exists in an enclosing scope, so that the inner one hides the outer for the rest of the block. It is legal and usually a mistake.

4. After int a[5] = {1, 2}; what is a[4]?

1. Elements not given in an initialiser are set to zero.

5. After int a[5]; inside a function, what is a[4]?

Unspecified. With no initialiser an automatic array is not zeroed.

6. How do you find the number of elements of int d[] = {4, 8, 15, 16};?

sizeof d / sizeof d[0], which is 4. That works only where the array itself is in scope, not on a parameter, which chapter 41 explains.

7. Why must a const object be initialised rather than assigned?

Because assignment to a const object is not allowed, so initialisation is the only point at which it can be given a value.

What can be asked on this, and how to answer it

"What is a block? Explain block structure in C." Define it as braces enclosing declarations and statements, counting as a single statement. Say where blocks appear, give the scope rule, and give a nested example showing that the inner block sees the outer names and not the reverse. Mention that this is why if and while can govern several statements.

"Explain scope and lifetime with an example." Scope is the region of the program where a name is visible; lifetime is the period for which the object exists. For an automatic variable they coincide with the block. Give the static case as the one where they differ, with the three-pass loop program.

"What is variable shadowing?" An inner declaration hiding an outer name of the same spelling for the extent of the inner block. Give the three-level value program, and say that it is legal and should be avoided because a reader must count braces to know which object a line means.

"How is an array initialised? What happens to elements not given a value?" With a braced list at the point of declaration. Elements omitted are set to zero, provided an initialiser is present; with no initialiser at all an automatic array is not zeroed. Give int a[5] = {0}; as the idiom for zeroing, and the empty-bracket form that lets the compiler count.

Now the part that matters. A macro is text substitution, so the text is dropped into the middle of whatever expression surrounds it, and precedence then applies to the result.

#include <stdio.h>

#define BAD_SQUARE(x)  x * x
#define GOOD_SQUARE(x) ((x) * (x))

#define BAD_HALF(x)    x / 2
#define GOOD_HALF(x)   ((x) / 2.0)

int main(void)
{
    printf("BAD_SQUARE(3)      = %d\n", BAD_SQUARE(3));
    printf("BAD_SQUARE(2 + 1)  = %d   <- wanted 9\n", BAD_SQUARE(2 + 1));
    printf("GOOD_SQUARE(2 + 1) = %d\n", GOOD_SQUARE(2 + 1));
    printf("100 / BAD_SQUARE(5)  = %d   <- wanted 4\n", 100 / BAD_SQUARE(5));
    printf("100 / GOOD_SQUARE(5) = %d\n", 100 / GOOD_SQUARE(5));
    printf("BAD_HALF(7)  = %d   <- integer division\n", BAD_HALF(7));
    printf("GOOD_HALF(7) = %.2f\n", GOOD_HALF(7));
    return 0;
}

BAD_SQUARE(3)      = 9
BAD_SQUARE(2 + 1)  = 5   <- wanted 9
GOOD_SQUARE(2 + 1) = 9
100 / BAD_SQUARE(5)  = 100   <- wanted 4
100 / GOOD_SQUARE(5) = 4
BAD_HALF(7)  = 3   <- integer division
GOOD_HALF(7) = 3.50

Work through the two failures by substitution, which is exactly what the preprocessor did.

• BAD_SQUARE(2 + 1) becomes 2 + 1 2 + 1. Precedence groups that as 2 + (1 2) + 1, which is 5.
• 100 / BAD_SQUARE(5) becomes 100 / 5 5. Left to right, that is (100 / 5) 5, which is 100.

Two sets of brackets, always. Round each parameter where it appears, and round the whole body. ((x) * (x)) survives both attacks.

The second macro trap: an argument evaluated twice

#include <stdio.h>

#define SQUARE(x) ((x) * (x))

int calls = 0;

int next(void)
{
    calls = calls + 1;
    return calls;
}

int main(void)
{
    calls = 0;
    int result = SQUARE(next());

    printf("SQUARE(next()) gave %d, and next() ran %d times\n", result, calls);
    printf("a FUNCTION would have called it once and given 1\n");
    return 0;
}

SQUARE(next()) gave 2, and next() ran 2 times
a FUNCTION would have called it once and given 1

SQUARE(next()) expands to ((next()) * (next())), so the function runs twice and multiplies two different numbers. The same happens with SQUARE(i++), which then also modifies i twice in one expression and is undefined behaviour. A real function cannot do this, and that is the strongest argument for writing one.

Macro against function

Prefer a function. Use a macro for a constant, for conditional compilation, and for the rare case where the same code must work for several types.

Conditional compilation

#include <stdio.h>

#define DEBUG 1

int main(void)
{
#if DEBUG
    printf("debug: the program has started\n");
#endif

    printf("doing the real work\n");

#ifdef DEBUG
    printf("debug: DEBUG is defined, whatever its value\n");
#endif

#ifndef RELEASE
    printf("RELEASE is not defined\n");
#endif

#if DEBUG > 5
    printf("this line is not compiled at all\n");
#else
    printf("DEBUG is 1, so this branch was compiled\n");
#endif
    return 0;
}

debug: the program has started
doing the real work
debug: DEBUG is defined, whatever its value
RELEASE is not defined
DEBUG is 1, so this branch was compiled

The text in a branch that is not taken is not compiled. It is removed before the compiler sees it, so it need not even be valid C, and an error in it will not be reported. That is what makes conditional compilation useful for code that only works on one operating system, and it is also why a mistake inside a switched-off branch can sit there for years.

#ifdef NAME tests whether the name is defined, not whether it is true. #define DEBUG 0 followed by #ifdef DEBUG takes the branch. Use #if DEBUG when you mean the value.

The standard predefined macros, which are always available and are genuinely useful:

#include <stdio.h>

int main(void)
{
    printf("this is line %d of file %s\n", __LINE__, __FILE__);
    printf("the C standard in use is %ld\n", __STDC_VERSION__);
    return 0;
}

this is line 5 of file lines.c
the C standard in use is 201710

__FILE__ prints whatever name the file was compiled under. That listing was saved as lines.c, so that is what it printed; on your machine it will be the name you chose. __LINE__ is 5 because the printf is the fifth line of the file, counting the #include as line 1.

The include guard

A header included twice would declare everything twice. The standard protection is a macro that records that the file has been seen:

#ifndef STUDENT_H
#define STUDENT_H

/* the contents of the header */

#endif

The first time, STUDENT_H is not defined, so the body is included and the macro is defined. The second time, the body is skipped. Every header in the standard library does this, and you should do it in any header of your own.

What this does NOT mean

The preprocessor does not understand C. It has no idea what a type, an expression or a scope is. It moves text.

A macro is not a constant. It has no type and no address. const gives you one that does.

A macro is not a function. No type checking, no single evaluation of arguments, and no recursion.

A directive does not take a semicolon. #define N 10; puts the semicolon into the program: int a[N]; becomes int a[10;];.

#ifdef does not test a value. It tests whether a name is defined at all.

Text in an untaken branch is not checked. It is removed, errors and all.

#include does not import a library. It inserts a text file of declarations. The library code is joined on by the linker, which is chapter 5.

Quick revision

• The preprocessor edits text before compilation, driven by lines starting with #, and takes no semicolon.
• #include <...> for system headers, #include "..." for your own.
• #define NAME text substitutes text. No type, no storage.
• #define NAME(p) text is function-like, and needs no space before the bracket.
• Bracket every parameter and the whole body: #define SQUARE(x) ((x) * (x)).
• A macro argument is evaluated once per appearance in the body, so SQUARE(next()) calls next twice.
• Prefer a function; use a macro for constants, conditional compilation and type-independent code.
• #ifdef tests definedness; #if tests a value.
• Untaken conditional branches are removed before compilation and are not checked.
• Include guard: #ifndef X / #define X / body / #endif.
• __LINE__, __FILE__ and __STDC_VERSION__ are always defined.

Test yourself

1. What does #define SQ(x) x*x give for SQ(3+1), and why?

3+13+1, which is 7. The text is substituted and then precedence applies. Write ((x) (x)).

2. What is wrong with #define MAX 100;?

The semicolon is part of the replacement text, so int a[MAX]; becomes int a[100;]; and does not compile.

3. Give two differences between a macro and a function.

A macro is expanded as text by the preprocessor with no type checking; a function is compiled once and its arguments are type-checked. And a macro may evaluate an argument more than once, while a function evaluates each argument exactly once.

4. #define DEBUG 0 then #ifdef DEBUG. Is the branch taken?

Yes. #ifdef asks whether the name is defined, not what its value is. Use #if DEBUG to test the value.

5. Write an include guard for a header called student.h.

#ifndef STUDENT_H
#define STUDENT_H
/* contents */
#endif

6. How many times does next() run in SQUARE(next()) where SQUARE(x) is ((x) * (x))?

Twice, because x appears twice in the body and each appearance is replaced by the argument text.

7. Why is #define SQUARE (x) ((x)*(x)) wrong?

The space before the bracket makes it an object-like macro whose replacement text is (x) ((x)*(x)). Remove the space.

What can be asked on this, and how to answer it

"What is the C preprocessor? List and explain its directives." Define it as a text-processing stage that runs before the compiler, driven by lines beginning with #, understanding no C. Give the table of directives with one line each, and note that no directive takes a semicolon.

"Explain #define with examples of both kinds of macro." Give an object-like macro and a function-like one, then spend the answer on the bracket rule, with SQ(3+1) giving 7 as the worked failure. That example is what the question is really for.

"Distinguish between a macro and a function." Give four rows of the table: preprocessor against compiler, no type checking against full, an argument possibly evaluated several times against exactly once, and code repeated at each use against one copy called. Conclude that a function is preferable unless the code must work for several types.

"What is conditional compilation? Why is it used?" Including or excluding source text at compile time with #if, #ifdef, #ifndef, #else, #elif and #endif. Used for code specific to one machine or operating system, for debugging output that can be switched off, and for include guards. Add that untaken text is removed before the compiler sees it.

"What is an include guard and why is it needed?" A #ifndef / #define / #endif wrapper round a header, so that including the header twice declares its contents once. Without it, a second inclusion would redeclare everything and the compilation would fail.

The marks are 20, nothing was printed, and passed was still incremented. The indentation is a lie and the compiler never sees it.

The habit that prevents it: always write the braces, even for one statement. It costs two characters and it removes a whole class of bug, including the one that appears later when you add a second line to the body.

The empty statement, and the semicolon that should not be there

#include <stdio.h>

int main(void)
{
    int count = 0;

    for (int i = 0; i < 5; i++);      /* the stray semicolon */
    {
        count = count + 1;
    }
    printf("count is %d, and the loop body ran %d time(s)\n", count, 0);

    count = 0;
    for (int i = 0; i < 5; i++) {
        count = count + 1;
    }
    printf("written correctly, count is %d\n", count);
    return 0;
}

stray.c: In function ‘main’:
stray.c:7:5: warning: this ‘for’ clause does not guard... [-Wmisleading-indentation]
    7 |     for (int i = 0; i < 5; i++);      /* the stray semicolon */
      |     ^~~
stray.c:8:5: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘for’
    8 |     {
      |     ^

count is 1, and the loop body ran 0 time(s)
written correctly, count is 5

The first for has an empty statement as its body, so it counts to five doing nothing, and the block below it then runs once as an ordinary block. count ends as 1 and not 5.

The same mistake after an if is worse, because the body then always runs:

if (marks >= 40);          /* an if with an empty body */
    printf("pass\n");      /* an ordinary statement: always runs */

When an empty body is what you actually want, write the braces so a reader can see you meant it:

while (getchar() != '\n') {
    /* discard the rest of the line */
}

A declaration is a statement, since C99

Chapter 11 said a declaration may go anywhere a statement may go. Two consequences worth naming here:

for (int i = 0; i < n; i++) { ... }    /* declared in the for header */

if (x > 0) {
    int y = x * 2;                     /* declared where first needed */
    printf("%d\n", y);
}

A declaration may not be the single governed statement of an if or a loop without braces, because there would be no block for it to live in and it would be useless. if (x) int y = 5; does not compile.

Indentation and layout

None of it is required and all of it matters.

• One statement per line. Two on a line hides one of them.
• Indent the body of every block by the same amount. Four spaces in this book.
• The opening brace on the same line as the if or while, the closing brace on a line of its own, lined up under the keyword. This is the layout the first C book used and the one most C uses.
• Whatever you choose, use it everywhere. Mixed layout is how a missing brace stays hidden.

A program can legally be written like this, and you should see it once so that you know the compiler does not care:

#include <stdio.h>
int main(void){int i;for(i=0;i<3;i++){printf("%d ",i);}printf("\n");return 0;}

0 1 2

That is the same program as a properly laid out one. It compiles to identical machine code. Layout is entirely for the reader, which is why chapter 6 put clarity second only to integrity.

What this does NOT mean

A semicolon does not separate statements. It terminates one. So the last statement in a block needs one, and a lone semicolon is a statement.

Indentation does not create a block. Only braces do. This is the difference from Python, and it is the source of the passed++ bug above.

A block does not need a semicolon after it. if (x) { ... } has no semicolon after the closing brace. A do-while is the one exception, and the semicolon there belongs to the while, not to the block.

An expression statement is not required to do anything. x + 1; is a legal statement that computes a value and discards it.

A block is not only for if and loops. A block on its own is a legal statement anywhere, and limiting a variable's life is a good reason to write one.

Quick revision

• A statement is one instruction terminated by a semicolon.
• The semicolon terminates, it does not separate: the last statement needs one too.
• A lone ; is the empty statement and does nothing.
• A block is braces round several statements and counts as one statement.
• if, else, while, for and do each govern exactly one statement, which is why blocks are needed.
• Always write the braces, even for a single statement.
• A stray semicolon after for (...) or if (...) gives it an empty body, and the code below then runs unconditionally.
• Since C99 a declaration is a statement and may go anywhere one may go.
• Indentation is for the reader; the compiler ignores it entirely.

Test yourself

1. What does this print?

int x = 5;
if (x > 10)
    printf("big\n");
    printf("done\n");

done. Only the first printf is governed by the if; the second is an ordinary statement that always runs.

2. How many times does the body run?

for (int i = 0; i < 3; i++);
    printf("hello\n");

The loop body is the empty statement and runs three times doing nothing. printf is not the body and runs once.

3. Is ; a valid C statement?

Yes. It is the empty statement, and it does nothing.

4. Does a block need a semicolon after its closing brace?

No, except after the while clause of a do-while, where the semicolon belongs to the do-while statement.

5. Why is if (x) int y = 5; not legal?

A declaration cannot be the single governed statement of an if. There is no block for the declared name to live in, so the language does not allow it. Write if (x) { int y = 5; ... }.

6. Name the six kinds of statement other than declarations.

Expression, empty, compound (block), selection, iteration, jump. Labelled statements are a seventh.

What can be asked on this, and how to answer it

"What is a statement? What is a compound statement?" A statement is a single instruction terminated by a semicolon. A compound statement, or block, is a sequence of declarations and statements enclosed in braces and treated as one statement, which is how several statements are given to an if or a loop.

"What is the significance of the semicolon in C?" It terminates a statement rather than separating statements, so every statement including the last in a block needs one. A semicolon alone is the empty statement, which is why a misplaced one changes the meaning of a program instead of being an error.

"Find the error: if (a > b); printf("a is bigger");" The semicolon gives the if an empty body, so the printf is an ordinary statement and runs whatever the comparison gives. Remove the semicolon.

"Why should braces be used even for a single statement?" Because the if or loop governs exactly one statement, so a second line added later is silently outside the body, and because the indentation then agrees with what the compiler sees. It costs nothing and removes a whole class of bug.

a > 0 is true, so the inner if is reached. b > 100 is false, so the else runs, printing the second line. The message that claims to be the outer else is in fact the inner one, and it printed.

To attach an else to the outer if, use braces. There is no other way.

#include <stdio.h>

int main(void)
{
    int a = 5, b = 10;

    if (a > 0) {
        if (b > 100) {
            printf("a positive, b over a hundred\n");
        }
    } else {
        printf("a is not positive\n");
    }
    printf("finished, and nothing above printed\n");
    return 0;
}

finished, and nothing above printed

Now a > 0 is true, the inner if fails, and there is no else for it, so nothing prints from the decision at all. That is what the first program was trying to say.

The one-line rule to write in an exam: an else matches the nearest preceding unmatched if in the same block, regardless of layout; braces are the only way to change that.

Nesting

An if may contain another if in either branch, to any depth. Beyond two levels it becomes hard to read, and the two usual cures are an else if ladder (chapter 25) and pulling the decision into a function that returns early.

#include <stdio.h>

const char *category(int age)
{
    if (age < 0) {
        return "not an age";
    }
    if (age < 13) {
        return "child";
    }
    if (age < 20) {
        return "teenager";
    }
    if (age < 60) {
        return "adult";
    }
    return "senior";
}

int main(void)
{
    int ages[] = {-1, 5, 15, 30, 70};

    for (int i = 0; i < 5; i++) {
        printf("%3d -> %s\n", ages[i], category(ages[i]));
    }
    return 0;
}

 -1 -> not an age
  5 -> child
 15 -> teenager
 30 -> adult
 70 -> senior

That shape, a series of ifs that each return, is called an early return, and it is usually the clearest way to write a decision with several outcomes. Each test reads as "if this, we are done", and nothing is nested.

The three mistakes

1. = for ==. if (x = 5) assigns and is always true. Chapters 16 and 18.

2. A semicolon after the condition. if (x > 0); gives the if an empty body. Chapter 23.

3. Comparing floating-point values with ==. Chapter 9. Use a tolerance.

#include <stdio.h>
#include <math.h>

int main(void)
{
    double x = 0.1 + 0.2;

    if (x == 0.3) {
        printf("exact comparison said equal\n");
    } else {
        printf("exact comparison said NOT equal\n");
    }
    if (fabs(x - 0.3) < 1e-9) {
        printf("comparison with a tolerance said equal\n");
    }
    return 0;
}

exact comparison said NOT equal
comparison with a tolerance said equal

What this does NOT mean

if does not need else. The else is optional and is often better left out, especially when the if returns.

The braces are not optional in practice. They are optional in the grammar. Leave them out and you meet the passed++ bug of chapter 23 and the dangling else of this one.

Indentation does not bind an else. Only braces do.

The condition does not have to be a comparison. Any expression will do, and zero is false.

if (a > b > c) is not a range test. It groups as (a > b) > c. Chapter 20.

An if is not an expression. It has no value, so it cannot appear inside a printf argument. That is what the conditional operator of chapter 19 is for.

Quick revision

• if (condition) statement and if (condition) statement else statement.
• The brackets round the condition are required; there is no then.
• Zero is false, anything else is true, so if (n) and if (!n) are idiomatic.
• Each branch governs exactly one statement; use a block for more.
• An else matches the nearest unmatched if, whatever the indentation.
• Braces are the only way to attach an else to an outer if.
• A semicolon after the condition gives an empty body.
• if (x = 5) assigns and is always true.
• Never == on floating-point values; compare the size of the difference.
• A series of ifs that each return is usually clearer than nesting.

Test yourself

1. What does this print, and why?

int a = 5, b = 10;
if (a > 0)
    if (b > 100)
        printf("X\n");
else
    printf("Y\n");

Y. The else belongs to the inner if, not the outer one, whatever the indentation suggests. a > 0 is true, b > 100 is false, so the inner else runs.

2. How do you make that else belong to the outer if?

Put braces round the inner if: if (a > 0) { if (b > 100) printf("X\n"); } else printf("Y\n");

3. What is the difference between if (n) and if (n == 0)?

They are opposites. if (n) is true when n is not zero; if (n == 0) is true when it is.

4. Why is if (x > 0); almost always a bug?

The semicolon is the empty statement, so the if has an empty body and the statement that follows runs regardless of the condition.

5. Rewrite this without nesting:

if (marks >= 40) { if (attendance >= 75) printf("allowed\n"); }

if (marks >= 40 && attendance >= 75) printf("allowed\n");

6. Can an if statement appear as a function argument?

No. if is a statement and has no value. Use the conditional operator: printf("%s\n", x > 0 ? "pos" : "neg");

What can be asked on this, and how to answer it

"Explain the if and if-else statements with syntax and examples." Give both forms, say the brackets are required and there is no then, give a worked program, and add the rule that each branch governs one statement so a block is needed for more. Mention that zero is false and anything else is true.

"What is the dangling else problem? How is it resolved?" An else is matched to the nearest preceding unmatched if, so in a nested if without braces the else binds to the inner one even when the indentation suggests otherwise. It is resolved with braces, which are the only way to change the match. Give the trace-the-output example.

"Find the output" with nested ifs and no braces. Rewrite the code with the braces the compiler infers, then trace it. Showing that rewrite is what earns the marks, because it demonstrates the rule rather than the answer.

"Distinguish between if-else and the conditional operator." if-else is a statement: it selects which statement runs and has no value, and each branch may hold any number of statements. ?: is an expression: it produces a value and each branch must be a single expression. Both evaluate only the branch selected.

The practical: the roots of a quadratic equation

MU's Practical 2(a). For ax^2 + bx + c = 0 the discriminant is b^2 - 4ac, and its sign decides the kind of roots. That is three cases, so it is a ladder.

#include <stdio.h>
#include <math.h>

int main(void)
{
    double a, b, c;

    printf("Enter a, b and c for a*x*x + b*x + c = 0: ");
    if (scanf("%lf %lf %lf", &a, &b, &c) != 3) {
        printf("\nThose were not three numbers.\n");
        return 1;
    }
    if (fabs(a) < 1e-12) {
        printf("\nWith a = 0 this is not a quadratic equation.\n");
        return 1;
    }

    double d = b * b - 4 * a * c;

    printf("\nDiscriminant b*b - 4*a*c = %.4f\n", d);
    if (d > 1e-12) {
        double r1 = (-b + sqrt(d)) / (2 * a);
        double r2 = (-b - sqrt(d)) / (2 * a);
        printf("Two distinct real roots: %.4f and %.4f\n", r1, r2);
    } else if (d > -1e-12) {
        double r = -b / (2 * a);
        printf("One repeated real root: %.4f\n", r);
    } else {
        double real = -b / (2 * a);
        double imag = sqrt(-d) / (2 * a);
        printf("Two complex roots: %.4f + %.4fi and %.4f - %.4fi\n",
               real, imag, real, imag);
    }
    return 0;
}

1 -7 12

Enter a, b and c for a*x*x + b*x + c = 0:
Discriminant b*b - 4*a*c = 1.0000
Two distinct real roots: 4.0000 and 3.0000

Four things in that program are the difference between a pass and a good mark.

1. a is checked for zero first. With a zero the formula divides by zero, and the equation is not quadratic anyway. No textbook solution checks this and the viva question is always "what if a is zero".

2. The discriminant is never compared with ==. It is a double computed by arithmetic, so the exactly-zero case will usually miss by a fraction. Chapter 9's rule applies: the tests are d > tolerance for positive, then d > -tolerance for what is left, which means "within the tolerance of zero", and the final else is genuinely negative.

Read those two tests as a ladder and the trick becomes clear: by the time the second test runs, d > 1e-12 has already failed, so d > -1e-12 can only mean -1e-12 < d <= 1e-12. The ladder did the work that an && would otherwise have to.

3. sqrt(-d) and not sqrt(d) in the complex branch. d is negative there, and sqrt of a negative double gives a not-a-number value.

4. 1e-12 is a choice, not a constant of nature. It is small relative to the sizes in this problem. For very large coefficients it would be too small and for very small ones too large; saying so in a viva is worth more than the program.

Run with different coefficients and the other two branches show:

#include <stdio.h>
#include <math.h>

int main(void)
{
    double sets[3][3] = {{1, -7, 12}, {1, -4, 4}, {1, 2, 5}};

    for (int i = 0; i < 3; i++) {
        double a = sets[i][0], b = sets[i][1], c = sets[i][2];
        double d = b * b - 4 * a * c;

        printf("a=%.0f b=%.0f c=%.0f  d=%.0f  ", a, b, c, d);
        if (d > 1e-12) {
            printf("real and distinct: %.4f, %.4f\n",
                   (-b + sqrt(d)) / (2 * a), (-b - sqrt(d)) / (2 * a));
        } else if (d > -1e-12) {
            printf("real and repeated: %.4f\n", -b / (2 * a));
        } else {
            printf("complex: %.4f +/- %.4fi\n",
                   -b / (2 * a), sqrt(-d) / (2 * a));
        }
    }
    return 0;
}

a=1 b=-7 c=12  d=1  real and distinct: 4.0000, 3.0000
a=1 b=-4 c=4  d=0  real and repeated: 2.0000
a=1 b=2 c=5  d=-16  complex: -1.0000 +/- 2.0000i

The leap year as a ladder

Chapter 16 wrote the leap-year rule as one expression. It is also three nested exceptions, and written as a ladder it reads as the rule itself:

#include <stdio.h>

int is_leap(int year)
{
    if (year % 400 == 0) {
        return 1;                 /* a century divisible by 400 IS a leap year */
    } else if (year % 100 == 0) {
        return 0;                 /* any other century is NOT */
    } else if (year % 4 == 0) {
        return 1;                 /* otherwise divisible by 4 IS */
    } else {
        return 0;
    }
}

int main(void)
{
    int years[] = {1900, 1996, 2000, 2023, 2024, 2100, 2400};

    for (int i = 0; i < 7; i++) {
        printf("%d %s\n", years[i], is_leap(years[i]) ? "leap" : "not leap");
    }
    return 0;
}

1900 not leap
1996 leap
2000 leap
2023 not leap
2024 leap
2100 not leap
2400 leap

Notice the order: most specific first. 400 before 100 before 4. Written the other way round, year % 4 would catch 1900 and answer wrongly. It is the same ordering lesson as the grades, in a form MU actually sets.

When to use a ladder, and when not to

A ladder on a single variable against single values is what switch is for, and switch says so more clearly:

if (choice == 1) { ... }
else if (choice == 2) { ... }
else if (choice == 3) { ... }

What this does NOT mean

else if is not a keyword. It is else followed by an if statement. C has no elif and no elseif.

A ladder does not test every condition. It stops at the first true one. This is why order matters and why later tests need no lower bound.

The final else is not required. Without one, a value matching no test simply falls through and nothing happens, which is sometimes right and is often a missing case.

A ladder is not a switch. A ladder tests arbitrary conditions; switch compares one integer expression against constants. Neither replaces the other.

Ordering from most to least demanding is not a style preference. Reversed, the ladder gives wrong answers, as grade_wrong shows.

Quick revision

• An else-if ladder is nested if-else written flat. Nothing was added to the language.
• The tests run in order; the first true one wins and the rest are skipped.
• Order overlapping tests from most demanding to least.
• Later tests need no upper bound, because earlier ones have been ruled out.
• The final else is optional and catches everything else.
• Quadratic roots: check a is not zero, then the sign of bb - 4a*c, with a tolerance rather than ==.
• sqrt(-d) in the complex branch, because d is negative there.
• Leap year as a ladder: 400, then 100, then 4, in that order.
• Use switch where one integer is compared against separate constants.

Test yourself

1. Is else if a single keyword?

No. It is an else whose governed statement is another if. The ladder layout is nested if-else written flat.

2. What is wrong with this ladder?

if (m >= 40) g = 'D';
else if (m >= 70) g = 'O';

Everything from 70 upwards satisfies the first test, so the second is never reached. Order from most demanding to least: test 70 first.

3. In the quadratic program, why is the second test d > -1e-12 rather than d == 0?

Because d is a double computed by arithmetic and will rarely be exactly zero even when the roots are repeated. The ladder has already ruled out d > 1e-12, so d > -1e-12 means d is within the tolerance of zero.

4. Why must a be checked before the discriminant?

Because 2 * a is a divisor in every branch, and with a zero the equation is not quadratic at all.

5. Write the leap-year test as a ladder and say why the order cannot be reversed.

Test year % 400 == 0 first, then year % 100 == 0, then year % 4 == 0. Reversed, year % 4 would catch 1900 and report it as a leap year, because the century exception would never be reached.

6. When is a switch better than a ladder?

When a single integer or character expression is being compared against separate constant values, as in a menu. switch states that intent and the compiler can often implement it as a jump table.

What can be asked on this, and how to answer it

"Explain the else-if ladder with syntax and an example." Give the syntax, say plainly that it is nested if-else written flat and that else if is not a keyword, then give the grade program. Include the ordering rule and one example of it going wrong, because that is what the question is really testing.

"Write a program to find the roots of a quadratic equation." Give this chapter's program. Keep the a == 0 check and the tolerance, and be ready to explain both: those are the two follow-up questions.

"Write a program to find the grade of a student from marks." Give grade_right, ordered from the highest boundary down, and say in one line why later tests need no upper bound.

"Distinguish between an else-if ladder and a switch statement." A ladder tests any conditions at all, on any number of variables, in a fixed order. A switch compares one integer or character expression against constant values, in no particular order, and may fall through. Use a ladder for ranges and a switch for discrete values. Add that switch cannot test a double or a string.

And it prints three lines when the programmer wanted one:

two
three
default

choice was 2, so control jumped to case 2 and then simply carried on downwards through case 3 and default. A case is a label, not a block.

Where you genuinely want fall-through past some statements, say so. gcc, and the standard from C23, accept an attribute:

case 1:
    printf("one, and continuing\n");
    /* fall through */
case 2:
    printf("two\n");
    break;

The comment silences the warning in gcc and, more importantly, tells the next reader that you meant it.

The practical: a menu-driven calculator

MU's Practical 2(b), in her own words: a menu-driven program using switch case to add, subtract, multiply or divide based on the user's choice.

#include <stdio.h>

int main(void)
{
    int choice;
    double a, b;

    printf("1 add\n2 subtract\n3 multiply\n4 divide\n");
    printf("Enter your choice: ");
    if (scanf("%d", &choice) != 1) {
        printf("\nThat was not a choice.\n");
        return 1;
    }
    printf("Enter two numbers: ");
    if (scanf("%lf %lf", &a, &b) != 2) {
        printf("\nThose were not two numbers.\n");
        return 1;
    }

    printf("\n");
    switch (choice) {
        case 1:
            printf("%.4f + %.4f = %.4f\n", a, b, a + b);
            break;
        case 2:
            printf("%.4f - %.4f = %.4f\n", a, b, a - b);
            break;
        case 3:
            printf("%.4f * %.4f = %.4f\n", a, b, a * b);
            break;
        case 4:
            if (b == 0.0) {
                printf("Division by zero is not defined.\n");
            } else {
                printf("%.4f / %.4f = %.4f\n", a, b, a / b);
            }
            break;
        default:
            printf("%d is not one of the four choices.\n", choice);
            break;
    }
    return 0;
}

4
22 7

1 add
2 subtract
3 multiply
4 divide
Enter your choice: Enter two numbers:
22.0000 / 7.0000 = 3.1429

Three things earn the marks here.

1. The division-by-zero check. Chapter 15 said the only correct handling is to test first. Here the operands are double, so a division by zero would not kill the program, and it would print inf, which is not an answer a student should hand in.

b == 0.0 on a double is the one case where comparing with == is right: zero is exactly representable, and what is being asked is whether the user typed a zero, not whether an arithmetic result landed on zero.

2. The default branch. An input the menu does not offer must be reported, not ignored.

3. Both scanf calls are checked. Two lines for the whole of the input validation.

The practical says "menu driven", and a real menu repeats until the user asks to stop. That needs a loop round the switch, which is chapter 29's do-while, and the full version is in chapter 44.

A case can share a body

Counting vowels is the standard example, and it is worth one program:

#include <stdio.h>

int main(void)
{
    const char *text = "Programming with C";
    int vowels = 0, consonants = 0, spaces = 0, others = 0;

    for (int i = 0; text[i] != '\0'; i++) {
        char c = text[i];
        if (c >= 'A' && c <= 'Z') {
            c = c - 'A' + 'a';
        }
        switch (c) {
            case 'a': case 'e': case 'i': case 'o': case 'u':
                vowels++;
                break;
            case ' ':
                spaces++;
                break;
            default:
                if (c >= 'a' && c <= 'z') {
                    consonants++;
                } else {
                    others++;
                }
                break;
        }
    }
    printf("\"%s\"\n", text);
    printf("vowels %d, consonants %d, spaces %d, others %d\n",
           vowels, consonants, spaces, others);
    return 0;
}

"Programming with C"
vowels 4, consonants 12, spaces 2, others 0

default here does real work rather than reporting an error, which is a legitimate use: the cases pick out the special values and default handles the general one.

switch against an else-if ladder

A case cannot express a range. case 1 ... 5: is a gcc extension, not standard C, and a program that uses it will not compile elsewhere. For ranges, use a ladder.

What this does NOT mean

A case is not a block. It is a label. Control enters at the label and continues until a break or the closing brace.

break is not optional. Leaving it out is legal and is nearly always a bug. -Wextra warns.

switch cannot test a double. Equality on floating-point values is unreliable, so the language does not allow it.

switch cannot test a string. A string is an array, and == on arrays compares addresses. Use strcmp in a ladder.

default is not required and is not necessarily last. It may go anywhere; put it last because that is where a reader looks. Its absence means unmatched values do nothing.

A case value cannot be a variable. It must be a constant expression the compiler can evaluate.

switch is not always faster than a ladder. A compiler may build a jump table for a dense set of values, which is fast, or a chain of comparisons, which is not. Choose on clarity.

Quick revision

• switch (expr) evaluates the expression once and jumps to the matching case label.
• The expression must be integer, char or enum. Never a double or a string.
• Each case value is a distinct compile-time constant.
• Control falls through from one case to the next unless stopped by break.
• Empty consecutive labels, case 'B': case 'C':, are the deliberate fall-through you want.
• default handles everything unmatched; it is optional and conventionally last.
• -Wextra warns about an implicit fall-through. A / fall through / comment silences it and documents intent.
• switch cannot express a range; use an else-if ladder.
• A break inside a switch leaves the switch, not any enclosing loop. Chapter 30.

Test yourself

1. What does this print when n is 2?

switch (n) {
    case 1: printf("one ");
    case 2: printf("two ");
    case 3: printf("three ");
}

two three . Control enters at case 2 and falls through case 3, because there is no break.

2. Can switch be used on a double?

No. The controlling expression must have integer type, because equality comparison of floating-point values is not reliable.

3. Can two case labels have the same value?

No. The compiler rejects a duplicate, because there would be no way to decide which to jump to.

4. Is default compulsory? Must it come last?

Neither. Without it, an unmatched value does nothing. It may appear anywhere, and it is put last by convention.

5. How do you make case 'B' and case 'C' do the same thing?

Write the labels one after the other with nothing between them: case 'B': case 'C': statements break;

6. Why can a case value not be a variable?

Because the compiler must know every case value while compiling, so that it can decide where each value jumps to. A variable's value is not known until the program runs.

7. How would you handle marks bands 40 to 49, 50 to 59 and 60 to 100 with a switch?

Not directly, because a case cannot express a range. Either use an else-if ladder, or switch on marks / 10 so that each band becomes one or more distinct integers.

What can be asked on this, and how to answer it

"Explain the switch statement with syntax and an example." Give the syntax, say the expression is evaluated once and control jumps to the matching label, and stress that execution continues from there until a break. Give the four restrictions and a worked example with a deliberate shared case.

"What is fall-through in a switch? Give one useful and one harmful example." Control continuing from one case into the next when no break stops it. Useful: two labels sharing a body, case 'B': case 'C':. Harmful: a missing break running the next case's statements as well, which -Wextra warns about.

"Write a menu-driven program using switch to perform addition, subtraction, multiplication and division." Give this chapter's program. Keep the division-by-zero check and the default; they are the two things the examiner asks about.

"Distinguish between switch and if-else." Give the table's rows: one integer expression against constants versus arbitrary conditions, constant distinct labels versus any test, no ranges versus ranges, fall-through versus none, and the order of tests being irrelevant in one and part of the logic in the other.

"Can a switch be nested?" Yes, and a break in the inner one leaves only the inner switch. Nesting more than one level is hard to read; a function for the inner decision is usually better.