Major Practical 1 Notes | B.Sc. (Information Technology) Semester 1 | Mumbai University | munotes

The examination slip

Two hours. Thirty marks. MU prints the slip itself:

Three things follow from that table and all three change how you should prepare.

Both halves are examined on the same day, every sitting. Thirteen and twelve is as near equal as thirty divides. You cannot pass this paper on C alone, and you cannot pass it on SQL alone.

One question per half. You will be given one C program to write and one database task to perform. Which one is luck; that is exactly why all twenty practicals matter, and why this book works every one of them rather than the popular ones.

Five of the thirty marks are not a program at all. They are your journal and your answers to questions about it. That is a sixth of the paper available to anybody who has kept a proper notebook and can explain their own work out loud.

The sentence that stops a student at the door

MU prints it in row 14, above the slip: a certified copy of the journal is compulsory to appear for the practical examination.

Certified means signed by your subject teacher. It is signed practical by practical, through the semester, as you submit them. It cannot be certified the week before the examination, because the signatures are dated against sessions you either attended or did not.

So the journal is not a formality that carries five marks. It is the ticket. Without it you are not marked out of 25 instead of 30; you do not sit the examination.

What one journal entry contains

MU does not print a format, and different colleges ask for small variations, so ask your own teacher in the first week and follow what they say. What follows is the entry every college expects some version of, and it is the shape this book uses for all twenty practicals.

The heading. Practical number, the date you performed it, and the aim in one line, copied from the syllabus rather than invented. For Practical 1(a) the aim is "To calculate simple interest taking principal, rate of interest and number of years as input from user."

The algorithm. Numbered steps, in plain English, with a Start and a Stop. MU asks for one by name in three of Practical 1's programs, which means the examiner may ask for one in any of them.

The flowchart. Drawn, not described. The symbols are settled and there are only six you need; they are in [Writing the Algorithm, and Drawing the Flowchart].

The program. Written out in full, in ink, including the header lines. Indentation copied faithfully, because the person signing it reads the indentation to see whether you understood the structure.

The output. What actually appeared on the screen, including whatever you typed in. Not what the program should have printed. If the output in the journal is impossible for the program above it, that is the first thing a viva will ask about.

The conclusion. One or two lines saying what the practical demonstrated. Not "the program was executed successfully", which says nothing. Something like: "Interest is computed as P into R into N divided by 100, and the division must be written in floating point or the fraction is lost."

Worked example: one entry, end to end

Suppose you performed Practical 3(b), the factorial, on 12 August. The entry reads:

Practical 3(b) 12 August 2025

Aim: Write a program to calculate the factorial of a given number.

Algorithm: 1. Start. 2. Read n. 3. Set fact to 1 and i to 1. 4. While i is less than or equal to n, set fact to fact into i and increase i by 1. 5. Print fact. 6. Stop.

Flowchart: drawn, with the loop arrow returning above the comparison.

Program: the listing from [Practical 3(b): The Factorial of a Number], copied in full.

Output: Enter a number: 6 then 6! = 720

Conclusion: A factorial is built by repeated multiplication, so a loop that multiplies a running product by each value in turn is enough. The product grows very fast, and an int stops being able to hold it at 13.

That entry takes twenty minutes to write and is worth 2.5 marks of the internal plus its share of the five in the examination. There are twenty of them in the semester.

What beginners get wrong

Thinking the practical exam is about typing fast. It is two hours for one C program and one database task. Time is not the constraint; knowing which program to write is.

Leaving the journal to the end. The signatures are dated. A journal written in one weekend cannot be certified for sessions that have already passed.

Writing "output: program executed successfully". The output is a specific thing that specific run printed. An examiner reading a journal full of that sentence has been handed a reason to ask harder viva questions.

Preparing only the popular practicals. Q1 and Q2 are drawn from the whole module. Twenty practicals, two questions, and no way to know which two.

Quick revision

• Practical paper, 2 credits, 60 hours, 50 marks. No theory examination.
• 30 hours C plus 30 hours DBMS. Ten practicals in each.
• Internal 20 marks: 2.5 per practical for performance plus the write-up, 50 converted to 20.
• Semester end 30 marks, two hours: Q1 Module 1 for 13, Q2 Module 2 for 12, Q3 journal and viva for 5.
• A certified copy of the journal is compulsory to appear.
• The previous session's write-up is submitted at the next session.
• A journal entry: heading and aim, algorithm, flowchart, program, real output, conclusion.

Test yourself

1. How many marks is the semester end practical examination, and how is it divided? Thirty marks in two hours: 13 for a question from Module 1, 12 for a question from Module 2, and 5 for the journal and viva.

2. You have performed every practical but your journal is unsigned. What happens? You cannot appear for the practical examination. A certified copy of the journal is a condition of entry, not a component of the marks.

3. Your internal is out of 20 but marks are awarded at 2.5 each. How many practicals are counted? Twenty, because 20 practicals at 2.5 marks is 50, and MU converts that 50 to 20.

4. Which half of this paper has no theory paper behind it in Semester 1? Module 2, the DBMS half. Its Course Objectives are taught in the practical alone.

5. What is due at the beginning of each practical session? The written write-up of the previous session's practical.

The semicolon ends a statement. It is not optional, it is not a line separator, and a missing one is the error you will make most often this semester.

The three things a compiler can say

This is the part nobody teaches and every student needs on the first day.

It says nothing. The compilation succeeded. There is now an executable, and you run it. Silence is success.

It reports an error. Compilation failed, no executable was produced, and the old one from your last attempt is still sitting there. This is how a student ends up running yesterday's program and concluding that their edit did nothing.

It reports a warning. Compilation succeeded and an executable exists, but the compiler thinks you have written something you did not mean. It is almost always right.

#include <stdio.h>

int main(void)
{
    int marks = 30;
    printf("Marks: %f\n", marks);
    return 0;
}

That compiles. cc accepts it, produces an executable, and warns:

Marks: 0.000000

The warning says the format %f expects a double and the argument is an int. The program then prints nonsense, because printf read the bytes of an integer as though they were the bytes of a floating point number. What nonsense it prints is not fixed: the standard calls a mismatch between a conversion specification and its argument undefined behaviour, so another compiler, or the same compiler on another machine, may print a different number, or the same program may print a different number twice. Nothing crashed. Nothing was reported at run time. A student who ignores warnings has thrown away the only help they were going to get.

So compile with the warnings switched on, always:

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

-Wall and -Wextra turn on the two standard groups of warnings. -std=c17 fixes which version of the language the compiler judges you against, which matters because C has had five and they disagree in small ways.

Worked example: an error, read and fixed

You type this, missing one semicolon:

#include <stdio.h>

int main(void)
{
    printf("Total marks: ")
    printf("50\n");
    return 0;
}

The compiler refuses it, and this is exactly what it says:

interest.c:5:28: error: expected ';' after expression
    5 |     printf("Total marks: ")
      |                            ^
      |                            ;
1 error generated.

Read it in three parts and it stops being frightening.

interest.c:5:28 is the file, the line and the column. Line 5, column 28. Go there, and notice that the compiler has also printed the line and drawn an arrow at the exact character position, with the character it wanted underneath.

error: means nothing was built. Compare this with warning:, where something was.

expected ';' after expression is the complaint. The ^ underneath points at the position, and the ; under that is the compiler telling you what to type there.

One caution that will save you an hour. The line number is where the compiler noticed, which is not always where you went wrong. A missing semicolon on line 5 is reported on line 5 here, but a missing closing brace at the end of a function is often reported at the end of the file, many lines below the mistake. When a reported line looks perfectly correct, look at the line above it.

How to read the output blocks in this book

Every program in this book was compiled and run, and the block printed under it is what the program sent to the screen. From the next chapter onward many of the programs ask you for a number first, and there is one thing to know about those blocks before you meet one.

What you type is not in them. When you type 12000 and press Enter, the characters appear on screen because the terminal echoes them, not because the program printed them. So a run that looks like this on your machine:

Enter the principal: 12000
Enter the rate of interest: 8.5

is printed in this book as the program's own output, with the prompts running together and the typed numbers absent. The values that were fed in are shown separately, above the output, so you can reproduce the run exactly.

In your journal, write what appeared on the screen, with the numbers you typed in their places. That is the honest record of the run, and it is what the person signing your journal expects to see.

What beginners get wrong

Believing an unchanged output means an unchanged program. It usually means the compile failed and you ran the previous executable. Look for error: before you look at your logic.

Treating warnings as noise. Every warning in this book is either fixed or shown on purpose as a mistake to avoid. A listing that warns teaches a habit that will fail on somebody else's compiler.

Forgetting \n. Output runs together and looks wrong when the program is right.

Writing Main or MAIN. C distinguishes capitals from small letters everywhere: in main, in printf, and in every name you invent. Total and total are two different variables.

Saving the file as interest.txt. Some editors add the extension silently. The compiler will tell you it does not know what to do with it.

What goes in your journal

Nothing on its own. This chapter is the method you use for all twenty practicals, not a practical. Write the three steps on the inside cover of the notebook where you can find them, and start the journal at Practical 1.

Quick revision

• C is compiled. Write the .c file, compile it, run the executable.
• cc -std=c17 -Wall -Wextra prog.c -o prog then ./prog.
• #include <stdio.h> is needed for printf and scanf.
• Execution starts at main, whose body is inside braces, and which ends with return 0;.
• Every statement ends with a semicolon.
• \n is one character, the newline.
• Silence means success. error: means nothing was built. warning: means something was built and is probably wrong.
• The reported line number is where the compiler noticed, not always where the mistake is.

Test yourself

1. What is the difference between a source file and an executable? The source file is the text you write, in C. The executable is what the compiler produces from it, in the machine's own instructions, and it is the file you run.

2. Why is #include <stdio.h> needed? It brings in the declarations of the standard input and output library. printf and scanf live there, not in the language, so without it the compiler does not know what they are.

3. What does return 0; at the end of main mean? That the program finished normally. The value goes back to the operating system, where a non-zero value conventionally reports a failure.

4. A program compiled with a warning. Can you run it? Yes, an executable was produced. But the compiler has told you the program does not mean what you wrote, so fix it before you write it into your journal.

5. Your program prints the same wrong answer after you edited it. What is the first thing to check? Whether the compile succeeded. If it reported an error, no new executable was made and you have just run the old one.

Where a step depends on a condition, say so with if and otherwise, and number the branches:

3. If a is greater than b, go to step 4, otherwise go to step 6

Where steps repeat, say what makes them repeat and what makes them stop:

4. While n is greater than 0, repeat steps 5 and 6

5. Set rev to rev into 10 plus the remainder of n divided by 10

6. Set n to n divided by 10

The symbols, and what each one is for

There are six. You will not need a seventh in this paper.

Figure 3.1 The six symbols, and what each one is for

The terminator is the rounded box. A chart has exactly one Start and, in this paper, one Stop. Two Stops is not wrong in general, but a chart with three of them usually means the solution has not been thought through.

Input and output is the parallelogram, leaning right. Anything read from the user, anything printed to the screen. Some colleges teach a separate symbol for a printed document; you will not need it.

The process is the plain rectangle. A calculation, or a value put into a variable. One rectangle can hold two or three closely related assignments, as the loop body in this book's charts does.

The decision is the diamond. One arrow in, exactly two out, and the two must be labelled. Label them Yes and No, and write the question in the diamond with a question mark, so that reading the chart out loud makes sense: "a greater than b? Yes, go left."

The connector is the small circle with a letter in it. Use it when the chart will not fit in one column: put a circle marked A where the flow leaves, and another circle marked A where it arrives. It is a label, not a step.

The flow line is the arrow. It carries the order. Arrows go down and to the right by default, and an arrow that goes up is a loop returning, which is exactly what you want a reader to notice.

Worked example: from problem to chart, in four steps

The problem: read a number and print it with its digits reversed.

Step 1: write down what is given and what is wanted. Given: a whole number n. Wanted: the same digits, printed in the opposite order.

Step 2: solve it by hand once, and watch what you do. Take 4271. You peel the last digit off, 1, and start building the answer. Then 7, and the answer so far becomes 17. Then 2, giving 172. Then 4, giving 1724. You stop when there is nothing left to peel. Two operations keep appearing: the last digit of n, and n with its last digit removed.

Step 3: write the steps.

1. Start

2. Read n

3. Set rev to 0

4. While n is greater than 0, repeat steps 5 and 6

5. Set rev to rev into 10 plus the remainder of n divided by 10

6. Set n to n divided by 10

7. Print rev

8. Stop

Step 4: draw it. Every read and print becomes a parallelogram, every assignment a rectangle, and the "while" becomes a diamond with the loop body hanging under its Yes arm and an arrow returning from the bottom of the body to just above the diamond.

Figure 3.2 The shape every while loop has: test at the top, body below, arrow returning above the test

That returning arrow is the whole point of the picture. It goes back to a point above the diamond, not into the diamond's side, because the test is performed again before the body runs again. A chart whose arrow returns into the body instead of above the test is drawing a different program, and it is the commonest drawing mistake in a first-semester journal.

The two loop shapes, and how to tell them apart in a chart

What beginners get wrong

Writing C in the algorithm. scanf("%d", &n); is not a step. "Read n" is. An algorithm with semicolons in it has not done the job the algorithm exists to do.

A decision with one arrow out. A diamond always has two, and both are labelled. A single unlabelled arrow out of a diamond is a decision that decides nothing.

Unlabelled branches. Yes and No must be written on the arrows. A reader cannot guess, and neither can an examiner.

Forgetting Stop. A chart that runs off the bottom of the page is not finished.

Drawing the chart after the program. Then it is a picture of your code, which is not what it is for. Draw it first and the code writes itself.

What goes in your journal

For every practical where MU asks for them, and for any other where you have room: the numbered algorithm in ink, then the flowchart drawn with a ruler. Use a stencil if your college gives you one. The symbols must be the right shapes: a rectangle where a diamond belongs is marked wrong even when the logic is right.

Quick revision

• Algorithm: numbered steps, plain English, Start and Stop, no C.
• Five properties: finiteness, definiteness, input, output, effectiveness.
• Six symbols: terminator, input and output, process, decision, connector, flow line.
• A decision has exactly two exits and both are labelled Yes and No.
• A loop's returning arrow goes back to above the test, never into the body.
• while tests at the top and may run zero times; do while tests at the bottom and runs at least once.
• Both go in the journal, before the program.

Test yourself

1. Define an algorithm. A finite sequence of unambiguous steps which, carried out in order, solves a given problem in a finite time.

2. Which symbol is used for reading a value from the user, and which for a calculation? A parallelogram for input and output, a rectangle for a process such as a calculation.

3. How many arrows leave a decision box, and what must they carry? Exactly two, and each carries a label, Yes and No.

4. Your flowchart's loop arrow returns into the middle of the loop body. What is wrong? The test is then never performed again, so the chart shows a loop that never ends. The arrow must return above the decision.

5. Give the algorithm for finding the largest of two numbers.

1. Start. 2. Read a and b. 3. If a is greater than b, print a, otherwise print b. 4. Stop.

6. Why is an algorithm written before the program and not after? Because it settles the solution in language anybody can check, and because the program is then a translation rather than an invention. It is also what MU asks for in the journal.

printf("Enter the principal: "); prints the prompt. There is no \n at the end on purpose, so that the cursor stays on the same line and the number you type appears next to the words.

scanf("%f", &p); reads one number from the keyboard and stores it in p.

Two parts of that line deserve a paragraph each, because they are where first-semester marks are lost.

"%f" is the format specifier, and it tells scanf what kind of value to expect. %f is a float, %d a whole number, %c a single character, %s a string. Give scanf the wrong one and it reads the bytes wrongly; there is no error message.

&p is the address of p, and the & is not optional. scanf has to change the variable, and to change something it needs to be told where it lives, not what is currently in it. Leaving the & out compiles on many compilers with a warning and then behaves unpredictably at run time. There is one exception you will meet later: a string read with %s needs no &, because the name of an array already is an address.

si = (p r n) / 100; is the calculation. The is multiplication, / is division, and the brackets say do the multiplying first. The brackets are not needed here, because and / have the same precedence and run left to right, but they are worth writing: they make the formula look like the formula.

printf("Simple interest = %.2f\n", si); prints. Inside a printf the % markers are filled in from the values listed after the string, in order. %.2f means a float rounded to two decimal places, which is what money wants.

The trap: integer division

Declare everything int instead and the program goes wrong in a way nothing warns you about. Take a principal of 1250 at 7 per cent for 3 years. By hand: 1250 by 7 is 8750, by 3 is 26250, divided by 100 is 262.5.

#include <stdio.h>

int main(void)
{
    int p = 1250, r = 7, n = 3;

    printf("Integer division: %d\n", (p * r * n) / 100);
    printf("Floating point: %.2f\n", (float) p * r * n / 100);

    return 0;
}

Integer division: 262
Floating point: 262.50

Half a rupee has gone, and no compiler said a word. When both sides of a / are whole numbers C performs integer division: it throws the fractional part away rather than rounding it. 26250 divided by 100 is 262 with a remainder of 50, and the remainder is simply dropped.

The second line shows the fix when you cannot change the declarations. (float) p is a cast, which converts that one value to a float for this one expression. As soon as one side of an operator is a float, C converts the other side too and the whole calculation is done in floating point.

The worse version of the same trap is at the other end, when the value is read rather than computed:

#include <stdio.h>

int main(void)
{
    int rate = 8.5;

    printf("You meant 8.5, and the int is holding %d\n", rate);
    return 0;
}

You meant 8.5, and the int is holding 8

The fraction is gone before any arithmetic happens at all, so every figure the program prints afterwards is wrong by six per cent. Here the compiler does warn, because the constant 8.5 is visible in the source; when the 8.5 arrives through scanf into an int there is nothing in the source to warn about and the loss is silent. That is why the working program above declares all four variables float.

What beginners get wrong

Leaving out the & in scanf. The variable is not filled in and the value you see is whatever was in memory.

Using %d for a float, or %f for an int. The compiler warns with -Wall, and the printed value is nonsense. Match the specifier to the type every time.

Declaring the rate as int. A rate of 8.5 becomes 8, silently.

Writing si = p r n / 100 with everything int and believing the answer. Integer division truncates; it does not round.

Forgetting that printf prompts have no newline. That is deliberate here, but if you copy a prompt with \n into a program that reads three values, the layout looks wrong next to the journal.

Quick revision

• SI = (P R N) / 100, and the 100 is there because R is a percentage.
• float for anything with a fraction; int only for whole numbers.
• scanf("%f", &p): format specifier, and the & is the address.
• %d int, %f float, %c character, %s string.
• %.2f prints two decimal places.
• Integer divided by integer is integer division: the remainder is discarded, not rounded.
• A cast (float) p forces floating point arithmetic.
• 12000 at 8.5 per cent for 3 years is 3060.

What goes in your journal

Aim, the five-step algorithm, the flowchart with its five boxes, the program, the output with your own values written in, and a conclusion naming the one thing the practical demonstrated: that the rate and the result must be held in a floating point type or the division throws the fraction away.

Test yourself

1. Why is & needed in scanf("%f", &p) but not in printf("%f", p)? scanf must change p, so it needs the address of p. printf only reads the value, so the value itself is enough.

2. int a = 7, b = 2; What does a / b give, and why?

1. Both operands are integers, so C performs integer division and discards the fractional part rather than rounding it.

3. What does %.2f do? Prints a floating point value rounded to two places after the decimal point.

4. You typed 8.5 for the rate but the interest came out as though the rate were 8. What is the likeliest cause? The rate was declared int, so the fractional part was lost when the value was stored.

5. Rewrite step 3 of the algorithm for compound interest. Set CI to P into ((1 plus R divided by 100) raised to N) minus P. The reading and printing steps do not change.

Two diamonds, four rectangles, and every arm ends in a box. Notice that big = c appears twice. That is not a mistake: c wins both when a beat b and c beat a, and when b beat a and c beat b, and a flowchart shows each path separately rather than merging them early.

The program

#include <stdio.h>

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

    printf("Enter three numbers: ");
    scanf("%d %d %d", &a, &b, &c);

    big = (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);

    printf("Numbers: %d, %d, %d\n", a, b, c);
    printf("The greatest is %d\n", big);

    return 0;
}

34 78 56

Enter three numbers: Numbers: 34, 78, 56
The greatest is 78

One scanf reads all three, because "%d %d %d" asks for three integers and the spaces in the format string match any amount of whitespace, including the Enter you press between them. You may type them on one line or on three; scanf cannot tell the difference and does not care.

The same answer with if-else

#include <stdio.h>

int main(void)
{
    int a = 34, b = 78, c = 56, big;

    if (a > b) {
        if (a > c)
            big = a;
        else
            big = c;
    } else {
        if (b > c)
            big = b;
        else
            big = c;
    }

    printf("The greatest is %d\n", big);
    return 0;
}

The greatest is 78

Fourteen lines against one. That is why MU asks for the operator: it is the compact form, and a student who can write the nested conditional can certainly write the if-else.

Conditional operator against if-else

The rule of thumb: if the two branches produce a value, use the operator. If they do things, use if-else.

What it does NOT mean

It is not a shorter if. It is a different thing that happens to look similar. (x > 0) ? printf("yes") : printf("no"); compiles, but writing statements inside it is abuse, and a nested chain used for control flow is unreadable within three levels.

The colon is not an else keyword. ? and : are two halves of one operator and neither works without the other.

It does not need brackets round the condition. a > b ? a : b is legal, because > binds tighter than ?:. Brackets are still worth writing.

What beginners get wrong

Missing the second colon in a nested expression, which produces a long and unhelpful error because the compiler keeps looking for it.

Comparing with = instead of ==. (a = b) ? a : b assigns and then tests, which is legal C and always wrong here.

Writing a > b > c. That is legal and means something else: a > b gives 1 or 0, and 1 or 0 is then compared with c. There is no three-way comparison in C.

Forgetting the case where two numbers are equal. With 78, 78 and 56 this program prints 78, which is right; "greatest" does not mean "strictly greater than both others".

Quick revision

• condition ? value_if_true : value_if_false, the only ternary operator in C.
• It is an expression with a value, so it can be assigned or printed.
• Greatest of three: (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c).
• ?: groups from the right; bracket the inner expressions anyway.
• scanf("%d %d %d", &a, &b, &c) reads three integers separated by any whitespace.
• a > b > c does not mean what it looks like.

What goes in your journal

Aim, the eight-step algorithm, the flowchart with both diamonds, the program using the conditional operator, the output for your own three numbers, and a conclusion that states what the operator is: a three-operand expression that yields one of two values, which is why it can be assigned where an if-else cannot.

Test yourself

1. Why is the conditional operator called ternary? Because it takes three operands: the condition, the value when true and the value when false. It is the only operator in C that does.

2. Write an expression that gives the smaller of x and y. (x < y) ? x : y

3. Can you write int m = if (a > b) a; else b;? No. if is a statement and has no value, so it cannot appear on the right of an assignment. The conditional operator can.

4. What does a > b > c evaluate to when a is 5, b is 3 and c is 1? a > b is 1, and 1 > 1 is 0. So the whole expression is 0, which is false, even though 5 is greater than 3 which is greater than 1.

5. Rewrite the three-number expression to find the smallest. small = (a < b) ? ((a < c) ? a : c) : ((b < c) ? b : c);

The program

#include <stdio.h>

int main(void)
{
    int year;

    printf("Enter a year: ");
    scanf("%d", &year);

    if (year % 400 == 0)
        printf("%d is a leap year\n", year);
    else if (year % 100 == 0)
        printf("%d is not a leap year\n", year);
    else if (year % 4 == 0)
        printf("%d is a leap year\n", year);
    else
        printf("%d is not a leap year\n", year);

    return 0;
}

1900

Enter a year: 1900 is not a leap year

The four cases, all run

One run proves one case. Here are all four in one program, so that nothing is being taken on trust.

#include <stdio.h>

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

    for (int i = 0; i < 4; i++) {
        int y = years[i];
        int leap = (y % 400 == 0) || (y % 4 == 0 && y % 100 != 0);

        printf("%d: %s\n", y, leap ? "leap" : "not leap");
    }

    return 0;
}

2000: leap
1900: not leap
2024: leap
2023: not leap

That listing also shows the second way of writing the test, as one condition rather than a chain:

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

&& is and: both sides must be true. || is or: either side will do. != is not equal to. Read the expression aloud and it is the rule in English: divisible by 400, or else divisible by 4 but not by 100.

Both forms are correct and either is accepted. The chain of else if is easier to trace in a viva because it matches the flowchart box for box; the single condition is shorter and is what you will see in most code.

What beginners get wrong

Testing only year % 4 == 0. This is right for 2024, 2023, 2025 and every year a student is likely to try, and wrong for 1900, 2100 and 2200. It is the reason MU can set this practical at all.

Getting the order backwards. Testing % 100 before % 400 makes 2000 not a leap year.

Writing year % 4 = 0. One = assigns, two compare. With -Wall the compiler warns; without it the program is wrong and silent.

Using % on a float. It does not compile. The remainder operator is for whole numbers.

Mixing up && and ||. (y % 4 == 0 || y % 100 != 0) is true for almost every year, including 2023, because 2023 is not divisible by 100.

Quick revision

• Three rules in order: divisible by 400 is leap; else divisible by 100 is not; else divisible by 4 is leap; else not.
• % is the remainder operator, whole numbers only.
• "Divisible by n" is year % n == 0.
• %% prints a literal per cent sign inside printf.
• One condition form: (y % 400 == 0) || (y % 4 == 0 && y % 100 != 0).
• && is and, || is or, != is not equal to, == is equal to.
• 2000 is leap, 1900 is not, 2024 is leap, 2023 is not.

What goes in your journal

Aim, the seven-step algorithm, the flowchart with all three diamonds, the program, and the output. Run it four times, once for each case in the table, and write all four outputs in the journal: an examiner who sees only 2024 in a leap year write-up has been given a reason to ask whether you know about 1900.

Test yourself

1. Is 1900 a leap year? No. It is divisible by 100 and not by 400, so the second rule applies and it is an ordinary year of 365 days.

2. Why is testing year % 4 == 0 alone not enough? Because the Gregorian calendar skips the extra day in century years that are not divisible by 400. That test declares 1900 and 2100 to be leap years, and they are not.

3. What does 2023 % 4 give?

1. 2023 is 505 fours and 3 left over.

4. Write the leap year test as one expression. (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)

5. Why does printf("%d %% 4", n) print a per cent sign? Because %% is the escape for a literal per cent inside a format string. A single % would be read as the start of a format specifier.

6. How many days does February have in 2024 and in 1900? 29 in 2024, which is a leap year, and 28 in 1900, which is not.

The program

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

int main(void)
{
    float a, b, c, d, root1, root2, real, imag;

    printf("Enter a, b and c: ");
    scanf("%f %f %f", &a, &b, &c);

    if (a == 0) {
        printf("a is zero, so this is not a quadratic equation\n");
    } else {
        d = b * b - 4 * a * c;
        printf("Discriminant = %.2f\n", d);

        if (d > 0) {
            root1 = (-b + sqrt(d)) / (2 * a);
            root2 = (-b - sqrt(d)) / (2 * a);
            printf("Roots are real and different: %.2f and %.2f\n", root1, root2);
        } else if (d == 0) {
            root1 = -b / (2 * a);
            printf("Roots are real and equal: %.2f and %.2f\n", root1, root1);
        } else {
            real = -b / (2 * a);
            imag = sqrt(-d) / (2 * a);
            printf("Roots are complex: %.2f + %.2fi and %.2f - %.2fi\n",
                   real, imag, real, imag);
        }
    }

    return 0;
}

1 -7 12

Enter a, b and c: Discriminant = 1.00
Roots are real and different: 4.00 and 3.00

Check it by hand. With a as 1, b as minus 7 and c as 12, D is 49 minus 48, which is 1. The square root of 1 is 1, so the roots are (7 plus 1) over 2 and (7 minus 1) over 2, which are 4 and 3. And indeed x squared minus 7x plus 12 factorises as (x minus 4)(x minus 3).

All three cases, run

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

int main(void)
{
    float sets[3][3] = { {1, -7, 12}, {1, -4, 4}, {1, 2, 5} };

    for (int i = 0; i < 3; i++) {
        float a = sets[i][0], b = sets[i][1], c = sets[i][2];
        float d = b * b - 4 * a * c;

        printf("a=%.0f b=%.0f c=%.0f  D=%.0f  ", a, b, c, d);

        if (d > 0)
            printf("real and different: %.2f, %.2f\n",
                   (-b + sqrt(d)) / (2 * a), (-b - sqrt(d)) / (2 * a));
        else if (d == 0)
            printf("real and equal: %.2f\n", -b / (2 * a));
        else
            printf("complex: %.2f +- %.2fi\n", -b / (2 * a), sqrt(-d) / (2 * a));
    }

    return 0;
}

a=1 b=-7 c=12  D=1  real and different: 4.00, 3.00
a=1 b=-4 c=4  D=0  real and equal: 2.00
a=1 b=2 c=5  D=-16  complex: -1.00 +- 2.00i

The middle case is x squared minus 4x plus 4, which is (x minus 2) squared, so both roots are 2. The last is x squared plus 2x plus 5, whose roots are minus 1 plus 2i and minus 1 minus 2i.

Why a == 0 is tested first

Because dividing by 2 * a when a is zero is division by zero. With integers that crashes the program; with floats C gives you inf or nan, which prints as inf or nan and looks like a bug in your formula.

More importantly it is not a quadratic equation at all. With a of 0 the equation is b * x + c = 0, a linear equation with the single root minus c over b. Saying so is worth a mark; printing nan is worth none.

What beginners get wrong

Forgetting math.h. Without it the compiler does not know what sqrt returns and, in C17, refuses to compile at all.

Calling sqrt(d) before checking the sign of D. The square root of a negative number is nan, and every calculation that touches a nan gives nan.

Writing 2a for 2 * a. C has no implied multiplication. 2a is not an expression.

Writing b b as b ^ 2. In C, ^ is the bitwise exclusive-or operator, not a power. Use b b, or pow(b, 2) from math.h, and prefer b * b because it is faster and exact.

Using int for the coefficients. The roots of a quadratic are rarely whole numbers. Use float.

Quick revision

• D = b b - 4 a * c, the discriminant.
• D greater than 0: real and different. D equal to 0: real and equal. D less than 0: complex.
• Roots: (-b + sqrt(D)) / (2 a) and (-b - sqrt(D)) / (2 a).
• When D is negative, the real part is -b / (2 a) and the imaginary part is sqrt(-D) / (2 a).
• sqrt needs #include <math.h>, and on Linux the compiler may need -lm.
• Test a == 0 first: with a of 0 it is a linear equation, not a quadratic.
• ^ is not a power operator in C.

What goes in your journal

Aim, the nine-step algorithm, the flowchart with one decision for a == 0 and two more for the sign of D, the program, and three separate runs, one for each case, with the coefficients and the output of each. A journal that shows only the real and different case has demonstrated a third of the practical.

Test yourself

1. What is the discriminant, and what does it tell you? b b - 4 a * c. Its sign decides whether the roots are real and different, real and equal, or complex.

2. For x squared minus 4x plus 4, what are the roots? Both are 2. The discriminant is 16 minus 16, which is 0, so the roots are real and equal.

3. Which header declares sqrt, and what may the compiler need besides? math.h. On many Linux systems the mathematics library must also be linked with -lm.

4. Why must a == 0 be tested before anything else? Because the formula divides by 2 * a, and because with a of 0 the equation is linear and has one root, not two.

5. What does b ^ 2 compute in C? The bitwise exclusive-or of b and 2, not b squared. C has no power operator.

6. The program printed nan for both roots. What happened? sqrt was called with a negative discriminant. The sign of D must be tested before the square root is taken.

1
12 5
4
9 0
7
5

1 Add  2 Subtract  3 Multiply  4 Divide  5 Exit
Enter your choice: Enter two numbers: 12.00 + 5.00 = 17.00

1 Add  2 Subtract  3 Multiply  4 Divide  5 Exit
Enter your choice: Enter two numbers: Division by zero is not allowed

1 Add  2 Subtract  3 Multiply  4 Divide  5 Exit
Enter your choice: Please choose a number between 1 and 5

1 Add  2 Subtract  3 Multiply  4 Divide  5 Exit
Enter your choice: Calculator closed

Four passes through the loop: an addition, a division by zero that was refused, an invalid choice of 7 that was rejected, and 5 to stop.

Why do while and not while

do {
    ...
} while (choice != 5);

A do while loop runs its body first and tests afterwards, so the body always runs at least once. That is exactly what a menu needs: the menu has to be shown before the user can possibly have made a choice.

Write it as an ordinary while and the condition tests choice before anything has put a value in it, so the loop is deciding on whatever rubbish happened to be in that memory. The compiler warns about the uninitialised read, and that warning is the language telling you the loop is the wrong shape.

Why division by zero is refused rather than attempted

Dividing an int by zero crashes the program outright. Dividing a float by zero does not: C gives inf, or nan if the top is zero as well, and the program carries on printing meaningless results.

Neither is acceptable in a program that is going to be marked. The one line that tests y == 0 before the division is the difference between a program that handles a bad input and one that is defeated by it, and examiners look for it.

switch against if-else-if

What beginners get wrong

Leaving out break. The next case runs too. Nothing warns you.

Switching on a float. switch (price) does not compile.

Writing case choice:. A case label must be a constant known at compile time.

Testing the choice inside switch but reading the numbers outside it. Then an invalid choice still asks for two numbers. Read the operands only when the choice is one that needs them, as the program above does.

Forgetting default. The program above uses an if to reject bad input before the switch, which is equally good; what is not acceptable is a switch with neither, because an invalid choice then does nothing at all and the user cannot tell whether the program worked.

Quick revision

• switch (n) { case 1: ... break; default: ... }.
• The switch expression must be an integer type; case labels must be constants; no two labels may be equal.
• Without break, control falls through into the next case.
• Deliberate fall-through groups several labels onto one body.
• do while tests at the bottom, so the body runs at least once. A menu needs that.
• Test for division by zero before dividing, not after.
• switch compares one value against constants; if-else-if can test anything.

What goes in your journal

Aim, an algorithm whose steps include the loop and the five choices, a flowchart with the menu inside the loop and a decision for each case, the program, and one output showing at least three passes: a successful operation, a refused division by zero, and the exit. A run that shows only one addition has not demonstrated that the program is menu driven.

Test yourself

1. What happens if break is left out of a case? Execution falls through into the next case and keeps going until it meets a break or the end of the switch.

2. Can you switch on a float? No. The controlling expression must have an integer type: int, char or an enumeration.

3. Why is do while the right loop for a menu? Because it tests at the bottom, so the menu is always displayed at least once before the user's choice is examined.

4. Give one case where fall-through is wanted. Grouping several labels onto one body, such as the five vowels all leading to one printf.

5. What does 9.0 / 0 give in a float calculation, and why is that not good enough? inf. It does not crash, so the program carries on and prints a meaningless result, which is harder to notice than a crash.

6. What is the purpose of default? It is the case that runs when no label matches, so the program can tell the user their choice was not valid.

1. Right angled triangle
*
**
***
****
*****

2. Inverted triangle
*****
****
***
**
*

3. Right aligned triangle
    *
   **
  ***
 ****
*****

4. Pyramid
    *
   ***
  *****
 *******
*********

5. Hollow square
*****
*   *
*   *
*   *
*****

Five shapes, one skeleton, five different expressions inside it. Compare pattern 3 with pattern 4: the only difference is that the second inner loop runs row times instead of 2 * row - 1 times. That is what is meant by finding the rule.

The spaces are printed, not implied

Pattern 3 has a loop that prints a space. This is the step students leave out, and then wonder why the triangle will not move to the right.

The screen has no idea where you want a character to go. If you want four blanks before an asterisk, four blanks must be printed. A printf(" ") in a loop is how that is done, and the number of them is worked out exactly like the number of asterisks: write the rows out, count, and find the expression.

The pyramid's two rules, side by side

The asterisk counts go up by two each row and the spaces come down by one, which is what makes both edges slope at the same angle.

What beginners get wrong

Putting printf("\n") inside the inner loop. Then every asterisk is on a line of its own, and n rows become the whole pattern in a column.

Starting row at 0 but writing the rule as though it started at 1. Either is fine, but the rule must match. With row from 0 to n-1 the triangle's inner loop runs row + 1 times.

Not resetting the inner counter. In C the inner for sets col = 1 every time it starts, so this cannot happen; it is a real bug in languages where the loop variable is set outside.

Printing a tab instead of a space. A tab moves to the next tab stop, not one column, so the shape collapses.

Trying to draw the pattern with one loop. It cannot be done with one loop and a counter without effectively simulating two.

Quick revision

• Outer loop for rows, inner loop for the characters in a row, printf("\n") after the inner loop.
• Right angled triangle: inner loop runs row times.
• Inverted triangle: n - row + 1 times.
• Right aligned: n - row spaces, then row asterisks.
• Pyramid: n - row spaces, then 2 * row - 1 asterisks.
• Hollow square: print an asterisk when row or col is 1 or n, a space otherwise.
• Spaces must be printed; the screen will not indent for you.

What goes in your journal

Aim, the algorithm with both loops written as steps, the flowchart with the inner loop drawn inside the outer one, the program, and the printed pattern copied exactly, asterisk for asterisk. Write the counting table for your pattern beside it: it is the working, and it shows the examiner that you derived the rule instead of remembering it.

Test yourself

1. How many times does the inner loop run in total for a right angled triangle of 5 rows? 1 plus 2 plus 3 plus 4 plus 5, which is 15.

2. What goes wrong if printf("\n") is put inside the inner loop? Every asterisk goes onto its own line, so the pattern comes out as a single column.

3. For a pyramid of n rows, how many asterisks are in row r? 2 * r - 1, so row 1 has one and row 5 has nine.

4. How do you move a triangle to the right? Print spaces before the asterisks, with an inner loop of their own that runs n - row times.

5. Write the inner loop condition for an inverted triangle with n rows. col <= n - row + 1

6. Which characters are asterisks in a hollow square? Those in the first row, the last row, the first column or the last column. Everything else is a space.

4271

Enter a number: 4271 reversed is 1724

original exists only so that the number can be printed at the end. The loop destroys n as it works, and by the time it finishes n is zero. Keeping a copy before a loop consumes a value is a habit worth forming now.

Three inputs that show what the program really does

#include <stdio.h>

int main(void)
{
    int cases[] = {4271, 1200, 7};

    for (int i = 0; i < 3; i++) {
        int n = cases[i], rev = 0;

        while (n > 0) {
            rev = rev * 10 + n % 10;
            n = n / 10;
        }

        printf("%d reversed is %d\n", cases[i], rev);
    }

    return 0;
}

4271 reversed is 1724
1200 reversed is 21
7 reversed is 7

The middle one is worth a paragraph. 1200 reversed should read 0021, and the program prints 21. Nothing has gone wrong: 0021 and 21 are the same number, and a number has no leading zeros to print. If the zeros must appear, the answer is not a number at all but a string of characters, and it is handled with the string techniques of [Practical 6(a): Extracting Part of a String]. Saying that in a viva is worth more than the program.

Negative numbers, and what this program does with them

while (n > 0) is false immediately for a negative number, so the loop never runs and the answer is 0. That is a real limitation, and there are two honest things to do about it.

Say so, or handle it:

int sign = (n < 0) ? -1 : 1;
n = n * sign;              /* work with the positive value */
... the loop as before ...
rev = rev * sign;          /* put the sign back */

Either is acceptable in a first-semester practical. What is not acceptable is a program that prints 0 for minus 4271 and a student who does not know why.

Two more things this loop can do

Once you can peel digits off a number, three of the standard first-year programs are the same loop with a different body.

All three end with n = n / 10 and all three stop at n > 0. A palindrome number check is then the reverse program plus one comparison, which is why examiners set them together.

What beginners get wrong

Writing rev = rev + n % 10. That gives the sum of the digits, not the reverse. The multiply by ten is what makes the position.

Forgetting n = n / 10. The loop then peels the same last digit forever and the program hangs. If a program never finishes, look for the statement that was supposed to move the loop on.

Not saving the original. After the loop n is 0, so a program that prints n at the end prints 0.

Using % on a float. It does not compile. This program is about whole numbers throughout.

Declaring rev without setting it to 0. An uninitialised variable holds whatever was in that memory, so the answer has a random number added to the front of it. Initialise every accumulator.

Quick revision

• n % 10 is the last digit; n / 10 is the number without it.
• rev = rev * 10 + n % 10 appends a digit to the answer.
• Loop while n > 0; it stops when there is nothing left to peel.
• Set rev to 0 before the loop, and keep a copy of the original.
• while when you know the stopping condition, for when you know the count.
• Reversing 1200 gives 21, because a number has no leading zeros.
• The same loop gives the sum of digits and the count of digits.

What goes in your journal

Aim, the eight-step algorithm, the flowchart with the loop arrow returning above the test, the program, and the output. Write out the trace table from the top of this chapter for your own number: four rows showing n, the digit, and rev at each step. It is the clearest evidence that you know what the loop does, and it takes two minutes.

Test yourself

1. What does n % 10 give, and what does n / 10 give? The last digit, and the number with its last digit removed.

2. Why is rev multiplied by 10 before the digit is added? To move the digits already collected one place to the left, leaving the units place free for the new digit.

3. What does the program print for 1200, and is that wrong? 21, and it is not wrong. 0021 and 21 are the same number, and leading zeros cannot be printed from an integer.

4. Your program never stops. What is the likeliest cause? n = n / 10 is missing, so the condition n > 0 never becomes false.

5. Why a while loop rather than a for loop here? Because the number of repetitions is not known in advance. What is known is the stopping condition, and a condition tested at the top of a loop is a while.

6. How would you turn this into a sum of digits program? Replace the body with sum = sum + n % 10, keeping the same condition and the same n = n / 10.

So int fails at 13 and unsigned long long fails at 21. There is no C type that holds 21!, and a program that needs it must store the answer differently, in an array of digits.

The overflow, run

#include <stdio.h>

int main(void)
{
    unsigned int small = 1;
    unsigned long long big = 1;

    for (unsigned int i = 1; i <= 13; i++) {
        small = small * i;
        big = big * i;
    }

    printf("13! in an unsigned int:       %u\n", small);
    printf("13! in an unsigned long long: %llu\n", big);

    return 0;
}

13! in an unsigned int:       1932053504
13! in an unsigned long long: 6227020800

The true value is 6227020800. An unsigned int on this machine holds 32 bits, so it can count to 4294967295 and then starts again at zero. 6227020800 minus 4294967296 is 1932053504, which is exactly what it printed.

Two things follow, and the second is the one that matters.

Unsigned arithmetic wraps, and the standard says so. An unsigned value that grows too large is reduced modulo one more than the largest value it can hold. It is defined, predictable, and wrong for this purpose.

Signed overflow is not defined at all. If small had been a plain int, the C standard would place no requirement on what happens: any value, or none. That is why this demonstration is written in unsigned arithmetic. Never write a program that relies on a signed integer overflowing.

Guarding the input

A program that will be marked should refuse what it cannot compute rather than printing a wrapped value:

if (n < 0)
    printf("Factorial is not defined for a negative number\n");
else if (n > 20)
    printf("%d! is too large for this program\n", n);
else
    ... the loop ...

Three cases, all of them answered. That is a complete program; the one that prints 1932053504 for 13 without comment is not.

for against while, for this loop

Both loops can do either job. The question is which one lets a reader see what is happening, and in a counted loop it is the for.

What beginners get wrong

Starting fact at 0. Every product is then 0.

Writing for (i = 1; i < n; i++). One multiplication short: 5! comes out as 24.

Using int and believing 13!. The value wraps, and with a signed int the behaviour is not even defined.

Printing an unsigned long long with %d. The wrong specifier prints rubbish. Use %llu.

Returning 1 for a negative input. The factorial of a negative number does not exist; say so.

Forgetting that 0! is 1. The loop gets this right by itself; a student answering a viva often does not.

Quick revision

• n! = 1 2 ... * n. 0! is 1. Negative factorials do not exist.
• A multiplying accumulator starts at 1; an adding accumulator starts at 0.
• for (i = 1; i <= n; i++) fact = fact * i;
• int holds up to 12!, unsigned long long up to 20!. Nothing in C holds 21!.
• %llu prints an unsigned long long.
• Unsigned overflow wraps and is defined; signed overflow is undefined behaviour.
• 5! is 120, 6! is 720, 10! is 3628800, 13! is 6227020800.

What goes in your journal

Aim, the eight-step algorithm, a flowchart with the loop and the negative-input decision, the program, and the output. Run it three times: a normal value, 0, and a negative number, and write all three outputs down. Add one line to the conclusion about the limit of the type you used, with the value at which it fails. That one line is what separates this write-up from every other one in the class.

Test yourself

1. What is 0!, and why?

1. There is exactly one way to arrange nothing, and every formula built on factorials requires it.

2. Why is fact initialised to 1 and not to 0? Because the loop multiplies. Starting at 0 makes every product 0.

3. What is the largest factorial an int can hold on a typical machine? 12!, which is 479001600. 13! is 6227020800 and does not fit in 32 bits.

4. What does the C standard say about an int that overflows? Nothing. Signed integer overflow is undefined behaviour, so the program may print anything. Unsigned overflow, by contrast, is defined to wrap.

5. Which format specifier prints an unsigned long long? %llu.

6. Your 5! came out as 24. What is wrong? The loop condition is i < n instead of i <= n, so the final multiplication by 5 never happens.

10

How many terms? Fibonacci series: 0 1 1 2 3 5 8 13 21 34

The two if statements before the loop are not padding. Asked for one term, the program must print 0 and nothing else; asked for two, 0 and 1. Without those guards a request for one term prints two, which is a wrong answer to the question that was asked.

The same thing without the shuffle

There is a second form, a line shorter, that some colleges teach:

#include <stdio.h>

int main(void)
{
    int a = 0, b = 1, next, i;

    for (i = 1; i <= 10; i++) {
        printf("%d ", a);
        next = a + b;
        a = b;
        b = next;
    }

    printf("\n");
    return 0;
}

0 1 1 2 3 5 8 13 21 34

Here every term is printed at the top of the loop, so there are no special cases for one term and two, and the loop simply runs n times. It is the neater program. The first version is shown as well because it is the one that matches the algorithm most colleges expect in the journal, step for step.

What beginners get wrong

Writing a = b; b = next; in the wrong order, or using one variable too few. With only a and b and no next, assigning a = a + b destroys the value of a that the next line needs.

Starting the loop at 1 when the first two terms have already been printed. Then twelve terms come out when ten were asked for. If the first two are printed before the loop, the loop starts at 3.

Printing the series but never the term count asked for. Read n and honour it.

Assuming int is enough. F(47) is 2971215073, which is past the largest int. For a first-semester practical of ten or twenty terms this never bites, but it is a fair viva question, and the answer is to use long long.

Confusing this with factorial. Both are classic loops; one adds the two previous values, the other multiplies by a counter.

Quick revision

• Each term is the sum of the two before it. F(0) is 0, F(1) is 1.
• 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55.
• Keep two variables, a and b, and a third for the new term.
• After printing, a = b then b = next, in that order.
• Guard the cases n equal to 1 and n equal to 2 if the first terms are printed before the loop.
• F(47) overflows a 32-bit int; use long long for long series.

What goes in your journal

Aim, the nine-step algorithm, the flowchart with the loop and the two assignments in its body, the program, and the output for at least ten terms. Add the trace table from this chapter, four or five rows of a, b and next; it takes a minute and it is the proof that the shuffle is understood.

Test yourself

1. What are the first eight terms? 0, 1, 1, 2, 3, 5, 8, 13.

2. Why is a third variable needed? Because a and b must both be updated from values that the update itself destroys. next holds the new term while a takes the old b.

3. What goes wrong if b = next; is written before a = b;? b is overwritten first, so a is then given the new term instead of the old b, and the series goes wrong from the third term onward.

4. Asked for one term, what should the program print? 0, and nothing else.

5. State the rule for F(n). F(n) = F(n - 1) + F(n - 2) for n of 2 or more, with F(0) = 0 and F(1) = 1.

6. Why can the series not be printed far with an int? Because the terms grow quickly: F(47) is 2971215073, which is larger than a 32-bit signed int can hold.

a = area(s); is the call. The value in s is copied into the parameter side, the body runs, and the value that return produces becomes the value of the expression area(s), which is then assigned to a.

return side * side; computes and hands back. return does two things at once: it supplies the value, and it ends the function immediately. Any statement after it in the same block never runs.

area(3) inside the last printf shows that a call is an expression. It has a value, so it can go anywhere a value can go. The argument here is a constant rather than a variable, which is allowed: the argument is a value, not a place.

What void means, in both positions

void print_line(void);

Before the name, void means the function returns nothing. Such a function is called for what it does, not for what it gives back, and it ends either at its closing brace or at a bare return; with no value.

Inside the brackets, void means the function takes nothing. That is why main is written int main(void).

Empty brackets, float area(), are not the same thing in C as (void), and C23 finally made them mean the same. Write (void) and the question never arises.

Where the parameter lives

The parameter side exists only while the function is running. It is created when the call happens, it holds a copy of the argument, and it is destroyed when the function returns.

#include <stdio.h>

void spoil(float side);

int main(void)
{
    float s = 4.5;

    spoil(s);
    printf("Back in main, s is still %.2f\n", s);

    return 0;
}

void spoil(float side)
{
    side = 99;
    printf("Inside the function, side is %.2f\n", side);
}

Inside the function, side is 99.00
Back in main, s is still 4.50

The function changed its own copy and main never noticed. That is call by value, it is how every C function call works unless you go out of your way, and it is the subject of [Practical 7: Swapping Two Numbers, by Value and by Reference].

What beginners get wrong

Putting a semicolon after the definition's head. float area(float side); followed by a body is a declaration and then a stray block. The definition's head has no semicolon.

Forgetting the return type. In C17 a function with no stated return type does not compile.

Declaring the function inside main. It is legal but pointless and confusing. Declare at file scope, above main.

Writing return; in a function that promises a value, or return x; in a void function. Both are errors.

Expecting a changed parameter to reach the caller. It does not. The parameter is a copy.

Calling the function without using its value. area(s); on a line of its own computes the area and throws it away.

Quick revision

• Declaration: name, return type, parameter types, ends in a semicolon, no body.
• Definition: the same head with a body, and no semicolon after the head.
• Call: area(s), an expression with a value.
• Parameter is in the function; argument is at the call.
• return supplies the value and ends the function at once.
• void before the name means no value returned; void in the brackets means no parameters taken.
• Arguments are passed by value: the function works on a copy.

What goes in your journal

Aim, an algorithm that names the function as a step ("call area with s and store the result"), a flowchart, the program with the declaration, the definition and the call all visible, and the output. In the conclusion define parameter and argument in one sentence each; it is the viva question this practical always carries.

Test yourself

1. What is the difference between a parameter and an argument? The parameter is the variable named in the function definition; the argument is the value supplied at the call and copied into the parameter.

2. Why is a declaration needed when the definition comes after main? Because the compiler reads the file from the top, and in C17 a call to a function it has not yet seen is an error.

3. What does return do, apart from supplying a value? It ends the function immediately. Statements after it in the same block are never reached.

4. What does void mean in int main(void)? That main takes no parameters.

5. A function changed its parameter. Does the caller's variable change? No. The argument's value was copied into the parameter, so the function changed only its own copy.

6. Is area(3) legal when the parameter is a float? Yes. The declaration tells the compiler a float is expected, so the constant 3 is converted to 3.0 before the call.

Five frames exist at the deepest point, and each holds its own n. That is why fact(3) still knows its n is 3 when control comes back to it after a long detour.

No base case, and what happens

unsigned long long bad(int n)
{
    return n * bad(n - 1);      /* nothing stops this */
}

Called with 5, it calls itself with 4, 3, 2, 1, 0, minus 1, minus 2, forever. Each call adds a frame, the stack runs out of room, and the program is killed by the operating system with a message such as "segmentation fault" or "stack overflow".

This is not shown running, because a crash proves nothing a sentence cannot. What it is worth knowing is the diagnosis: a C program that dies immediately with a segmentation fault and has a recursive function in it has almost always lost its base case, or has a base case the recursion can step past. if (n == 0) is a weaker base case than if (n <= 0), because a call with minus 1 slips straight through it.

Recursion against iteration

Anything that can be written one way can be written the other. For factorial, the loop is the better program; the recursion is the better explanation. That is the honest answer in a viva, and it is better than "recursion is elegant".

Two more recursive functions worth knowing

#include <stdio.h>

int fib(int n);
int gcd(int a, int b);

int main(void)
{
    for (int i = 0; i < 8; i++)
        printf("%d ", fib(i));
    printf("\n");

    printf("gcd(48, 18) = %d\n", gcd(48, 18));
    return 0;
}

int fib(int n)
{
    if (n < 2)
        return n;
    return fib(n - 1) + fib(n - 2);
}

int gcd(int a, int b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}

0 1 1 2 3 5 8 13
gcd(48, 18) = 6

fib is the definition from [Practical 3(c): The Fibonacci Series] written directly as code, and it is also a warning: it recomputes the same values over and over, so fib(40) takes a noticeable time where the loop version is instant. gcd is Euclid's algorithm, and recursion suits it perfectly because each step really is the same problem on smaller numbers.

What beginners get wrong

No base case, or one the recursion steps over. Use <= rather than == where the argument might overshoot.

Forgetting that the function must make progress. fact(n) calling fact(n) is not recursion, it is a hang. Every call must be on a smaller problem.

Expecting a local variable to be shared. Each call has its own. That is the point of the stack frame.

Using recursion where a loop is plainly better, and then being unable to say why in the viva. Say: same result, more memory, slower, but closer to the definition.

Thinking a recursive function needs a loop inside it. It does not. The repetition is the calling.

Quick revision

• A recursive function calls itself on a smaller problem.
• It must have a base case, answered without recursion, and the recursive case must make progress towards it.
• n! = n * (n - 1)! with 0! = 1.
• Each call gets its own stack frame with its own parameters and locals.
• The calls go down to the base case, then unwind in reverse order.
• No base case means a stack overflow and a crash.
• Recursion costs memory and speed; it buys a definition that reads like the mathematics.

What goes in your journal

Aim, the two-line recursive definition as the algorithm, a flowchart with the decision for the base case and a box that says "call fact(n minus 1)", the program, and the output. Copy the trace, all eleven lines: it is the evidence that you know the order in which the calls return, which is the one thing about recursion a viva always tests.

Test yourself

1. What are the two parts every recursive function must have? A base case, which returns without recursing, and a recursive case, which calls the function on a smaller problem.

2. In what order do the calls of fact(5) finish? fact(1) first, then fact(2), fact(3), fact(4) and fact(5) last. They unwind in the reverse of the order they were made.

3. What is a stack frame? The area of memory given to one call of a function, holding its parameters and local variables. Each call has its own.

4. What happens when the base case is missing? The function calls itself forever, the stack runs out of memory, and the program crashes.

5. Give one problem where recursion is clearly the better choice. The greatest common divisor by Euclid's algorithm, or the Towers of Hanoi, where each step is genuinely the same problem on a smaller input.

6. Why is if (n == 0) a weaker base case than if (n <= 0)? Because a call made with a negative number steps straight past it and the recursion never stops.

The rule to remember: abs for whole numbers, fabs for anything with a decimal point. The f is for floating point, not for function.

Writing them yourself

MU's wording is "using function", and a fair reading is either the library's function or your own. Both are worth knowing, and writing your own is the better viva answer because it shows what the library one does.

#include <stdio.h>

int my_abs(int n);
double my_sqrt(double x);

int main(void)
{
    printf("my_abs(-17) = %d\n", my_abs(-17));
    printf("my_sqrt(2) = %.4f\n", my_sqrt(2.0));
    printf("my_sqrt(144) = %.4f\n", my_sqrt(144.0));

    return 0;
}

int my_abs(int n)
{
    return (n < 0) ? -n : n;
}

double my_sqrt(double x)
{
    double guess = x / 2.0;
    int i;

    if (x <= 0)
        return 0;

    for (i = 0; i < 30; i++)
        guess = (guess + x / guess) / 2.0;

    return guess;
}

my_abs(-17) = 17
my_sqrt(2) = 1.4142
my_sqrt(144) = 12.0000

my_abs is the conditional operator from [Practical 1(b): The Greatest of Three Numbers, with the Conditional Operator], doing the only thing absolute value ever does.

my_sqrt is the Babylonian method, which is about four thousand years old. Guess an answer; the true root lies between the guess and x divided by the guess, so the average of those two is a better guess; repeat. It doubles the number of correct digits each time, so thirty rounds is far more than enough for any double.

What beginners get wrong

Including only math.h and calling abs. It is in stdlib.h.

Calling abs on a double. The value is truncated to an int first.

Writing sqrt(-9). The result is nan, and every later calculation that touches it becomes nan too. Test the sign first.

Expecting sqrt to return an int. It returns a double, and printing it with %d prints rubbish.

Using pow(x, 2) for a square. It works, but x * x is faster and exact, where pow goes through floating point and can return 8.999999 for what should be 9.

Forgetting -lm on Linux. The code is right and the linker cannot find the library. See [Practical 2(a): The Roots of a Quadratic Equation].

Quick revision

• sqrt, pow and fabs are in math.h. abs and labs are in stdlib.h.
• abs is for whole numbers, fabs for floating point. The f is for float.
• sqrt takes and returns a double; print it with %f.
• sqrt of a negative number is nan.
• Absolute value is the distance from zero: (n < 0) ? -n : n.
• Prefer x * x to pow(x, 2).
• A header supplies declarations; the linker supplies the bodies.

What goes in your journal

Aim, the algorithm, the program, and the output. Write the two-header table into the conclusion, because "which header is abs in" is asked in more vivas than any other question about this practical. If you have room, add your own my_abs; it is three lines and it demonstrates that you know what the library is doing.

Test yourself

1. Which header declares abs, and which declares fabs? stdlib.h declares abs; math.h declares fabs.

2. What does abs(-4.7) give, and why?

1. The argument is converted to an int first, so the fractional part is lost before the function runs.

3. What does sqrt return for a negative argument? nan, which stands for not a number. Any later arithmetic involving it also gives nan.

4. Why is x * x better than pow(x, 2)? It is faster and exact, where pow computes through floating point and may return a value very slightly off.

5. What is in a header file? Declarations: names, return types and parameter types. The compiled bodies of the functions are elsewhere and are joined on by the linker.

6. Write a one-line absolute value without using any library. (n < 0) ? -n : n

The use that is not defensible

A goto that jumps backwards makes a loop, and this is what gave the statement its reputation.

#include <stdio.h>

int main(void)
{
    int i = 1;

again:
    printf("%d ", i);
    i++;
    if (i <= 5)
        goto again;

    printf("\n");
    return 0;
}

1 2 3 4 5

It works. It is also a for loop with its three parts scattered over four lines and no word anywhere saying that this is a loop at all. A reader has to find the label, find every goto that targets it, and reconstruct the loop in their head.

Now imagine that with three labels and seven jumps in a hundred-line function, which is what real programs looked like before structured programming. The code becomes a tangle that cannot be read top to bottom, and the name for it, from Edsger Dijkstra's 1968 letter to the editor of the Communications of the ACM, is spaghetti code. That letter is why goto is banned by almost every coding standard in use today.

What to say about it in a viva

Not "goto is bad". Say this:

Any program written with goto can be written without it, using only sequence, selection and repetition. This is the structured program theorem, proved by Corrado Bohm and Giuseppe Jacopini in 1966, and it is why the language does not need goto.

C keeps it for the cases where the alternatives are worse: leaving nested loops, and jumping to one block of cleanup code from several error checks inside one function. Both are jumps forward to a single exit.

A backward goto should always be a loop instead. while, do while and for say what they are; a label does not.

goto against break, continue and return

What beginners get wrong

Jumping into a loop from outside it. The loop's counter is then never initialised.

Jumping forward over a declaration. The variable exists but holds nothing meaningful.

Using goto to make a menu repeat. Use do while, as [Practical 2(b): A Menu Driven Calculator, with switch] does. It is one line shorter and says what it means.

Reusing one label for two purposes. A label is not a function; control never comes back.

Putting the label at the end with nothing after it. In C17 a label needs a statement; write end: ; if there is nothing to do.

Quick revision

• goto label; transfers control to label: in the same function.
• A label is a name and a colon, attached to a statement.
• It cannot jump between functions.
• Defensible use: breaking out of nested loops, and a single cleanup exit.
• A backward goto is a loop written badly; use while, do while or for.
• Bohm and Jacopini, 1966: sequence, selection and repetition are enough for any program.
• Dijkstra's 1968 letter is the origin of the objection, and of the phrase spaghetti code.

What goes in your journal

Aim, the algorithm, the program, and the output. Two programs if you have room: the nested loop search with goto and the same search with a flag, because the comparison is the practical's real content. In the conclusion write one sentence on why goto is permitted in C and avoided in practice.

Test yourself

1. What is a label? A name followed by a colon, placed before a statement, marking a destination for goto.

2. Can goto jump from one function into another? No. A label is visible only inside the function that contains it.

3. Give one use of goto that is generally accepted. Leaving two or more nested loops at once, because break leaves only the innermost.

4. What is the difference between break and goto? break leaves exactly one enclosing loop or switch and always lands just after it. goto can leave any number of them and lands wherever the label is.

5. What does the structured program theorem say? That any program can be written using only sequence, selection and repetition, so goto is never strictly necessary. Bohm and Jacopini proved it in 1966.

6. Why is a backward goto worse than a forward one? Because it creates a loop that is not announced as a loop, so a reader must reconstruct the control flow instead of reading it.

Four details in that program

&roll[i] has an ampersand, and name[i] does not. roll[i] is one int, so scanf needs its address, exactly as in [Practical 1(a): Simple Interest]. But name[i] is already an array of characters, and the name of an array is the address of its first element. Putting an & in front of it is a common mistake; leaving it off the integer is a worse one.

%19s and not %s. The number limits scanf to nineteen characters, leaving room for the terminating null in a space of twenty. Plain %s will happily read a fiftieth character into memory that belongs to something else, which is the defect behind a great many real security failures. Always give %s a width.

%s stops at the first space. Type "Asha Kulkarni" and scanf("%19s") reads "Asha" and leaves " Kulkarni" waiting, where the next scanf("%d") will trip over it. This practical therefore uses single-word names. Reading a name with a space in it needs a different call, and it is taught in [Practical 9: A Structure, and Two Records of It], where MU's own example requires it.

%-4d left-aligns in a field of four. The minus sign means align left; without it the column is right-aligned. It is how a table is made to line up, and it costs nothing.

Arrays are not bounds checked, and nothing warns you

int roll[10];

roll[10] = 999;        /* there is no roll[10] */
roll[-1] = 42;         /* nor a roll[-1] */

Both of those compile. C does not check that a subscript is inside the array, at compile time or at run time. The statements write over whatever bytes happen to sit next to the array, which might be another variable, might be nothing important, and might be part of the machinery that lets the function return.

The C standard calls it undefined behaviour, which means the program may print a wrong answer, may crash, or may appear to work for a year and then fail. So the safety is entirely yours:

Every loop over an array uses i < n, never i <= n. That one habit prevents most of them.

How many elements is it, really

An array does not remember how long it is, but the compiler knows, and sizeof asks it.

#include <stdio.h>

int main(void)
{
    int roll[10];
    char name[10][20];

    printf("one int is %zu bytes\n", sizeof(int));
    printf("roll is %zu bytes, so %zu elements\n",
           sizeof roll, sizeof roll / sizeof roll[0]);
    printf("name is %zu bytes: %zu names of %zu characters\n",
           sizeof name, sizeof name / sizeof name[0], sizeof name[0]);

    return 0;
}

one int is 4 bytes
roll is 40 bytes, so 10 elements
name is 200 bytes: 10 names of 20 characters

sizeof array / sizeof array[0] is the standard way of asking how many elements an array has: the total number of bytes divided by the bytes in one element. %zu is the format specifier for the type sizeof produces, and using %d for it is a warning with -Wall.

Two cautions. sizeof(int) is 4 on this machine and on almost every machine you will meet, but the C standard only requires an int to hold values from minus 32767 to 32767, so a very small system may use 2. Never write 4 where sizeof(int) belongs.

And this trick works only where the array itself is visible. Pass an array to a function and what arrives is an address, so sizeof inside the function gives the size of a pointer, not of the array. That is why every function in this book that takes an array also takes its length as a second parameter.

What beginners get wrong

Starting at 1 or ending at n. The subscripts are 0 to n minus 1.

Putting & before an array name in scanf. The array name is already an address.

Leaving & off a single variable in scanf. The value goes nowhere.

Using %s with no width. A long input writes past the end of the array.

Typing a name with a space. %s stops at the space and the rest of the line confuses the next read.

Declaring the array too small for the data. There is no error; the extra values land on something else.

Quick revision

• int roll[10]; gives ten ints, roll[0] to roll[9].
• The subscript is the distance from the start, so the first is 0 and the last is n minus 1.
• char name[10][20]; is ten strings of up to nineteen characters plus the terminating null.
• A string ends with '\0', and room must be left for it.
• An array name is the address of its first element, so scanf needs no & for it.
• %19s limits the read; plain %s does not and is dangerous.
• %s stops at whitespace.
• C does not check array bounds. i < n in every loop.
• sizeof a / sizeof a[0] is the number of elements.

What goes in your journal

Aim, an algorithm with two loops, one to read and one to print, a flowchart showing both, the program, and the output table with all ten students. In the conclusion write the two facts this practical exists to teach: that the subscripts run from 0 to n minus 1, and that an array name in scanf needs no ampersand.

Test yourself

1. int a[5]; Which subscripts are valid? 0, 1, 2, 3 and 4. a[5] is past the end.

2. Why does scanf("%d", &roll[i]) need an & when scanf("%19s", name[i]) does not? roll[i] is a single int, so its address must be given. name[i] is an array, and an array name already is the address of its first element.

3. What does char name[10][20]; declare? Ten strings, each with room for twenty characters, which is nineteen letters and the terminating null.

4. What happens if you write to a[10] in an array of ten? Nothing is checked. The write lands on whatever is next in memory, and the behaviour is undefined: the program may work, may print nonsense, or may crash.

5. Why i < n and not i <= n? Because the last valid subscript is n minus 1. i <= n runs one step past the end of the array.

6. How do you find the number of elements in an array? sizeof a / sizeof a[0], the total size divided by the size of one element.

5
5 1 4 2 8
1

How many elements? Element 1: Element 2: Element 3: Element 4: Element 5: 1 for ascending, 2 for descending: Sorted: 1 2 4 5 8

One line does both directions:

wrong_order = (choice == 1) ? (a[j] > a[j + 1]) : (a[j] < a[j + 1]);

Ascending means a pair is wrong when the left is bigger. Descending means it is wrong when the left is smaller. Everything else about the sort is identical, which is worth saying out loud in a viva: the direction of a sort is one comparison.

Every pass, printed

#include <stdio.h>

void show(const char *label, int a[], int n);

int main(void)
{
    int a[] = {5, 1, 4, 2, 8};
    int n = 5, i, j, temp, comparisons = 0, swaps = 0;

    show("start ", a, n);

    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            comparisons++;
            if (a[j] > a[j + 1]) {
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
                swaps++;
            }
        }
        printf("pass %d", i + 1);
        show("", a, n);
    }

    printf("%d comparisons, %d swaps\n", comparisons, swaps);
    return 0;
}

void show(const char *label, int a[], int n)
{
    printf("%s: ", label);
    for (int i = 0; i < n; i++)
        printf("%d ", a[i]);
    printf("\n");
}

start : 5 1 4 2 8
pass 1: 1 4 2 5 8
pass 2: 1 2 4 5 8
pass 3: 1 2 4 5 8
pass 4: 1 2 4 5 8
10 comparisons, 4 swaps

Two things to notice. The array was already sorted after pass 2, and passes 3 and 4 did nothing but compare. And the count is what the theory predicts.

How many comparisons

The outer loop runs n minus 1 times. The inner loop runs n minus 1 times, then n minus 2, and so on down to 1.

For n of 5 that is 5 times 4 divided by 2, which is 10, and the program counted 10. For n of 100 it is 4950, and for n of 1000 it is 499500. The work grows with the square of the number of elements, which is written O(n squared) and is the answer to "what is the time complexity of bubble sort".

That is why bubble sort is taught and not used. It is the easiest sort to write and to explain, and for anything past a few hundred elements it is far too slow.

The improvement worth knowing

If a whole pass makes no swap, the array is sorted and the remaining passes are wasted. One flag stops them:

for (i = 0; i < n - 1; i++) {
    int swapped = 0;
    for (j = 0; j < n - i - 1; j++)
        if (a[j] > a[j + 1]) { ...swap...; swapped = 1; }
    if (!swapped)
        break;
}

With that, an already sorted array costs one pass instead of n minus 1. It is a fair viva question and it is two lines.

What beginners get wrong

Swapping with two statements. The first value is lost. Use temp.

Writing j < n - 1 instead of j < n - i - 1. It still sorts, because the tail is already in order, but it compares pairs that are known to be right, so the count doubles for nothing.

Writing j <= n - i - 1. Then a[j + 1] is a[n - i], and on the first pass that is a[n], one past the end of the array.

Comparing a[i] with a[i + 1] in the inner loop. The inner loop's counter is j. Mixing them is the commonest typing error in this practical.

Sorting in the wrong direction and swapping the printing instead. Printing an ascending array backwards is not a descending sort, and an examiner will ask you to sort strings next, where the trick collapses.

Quick revision

• Bubble sort compares neighbours and swaps them when they are in the wrong order.
• After pass i, the last i elements are in their final places.
• Outer loop i < n - 1; inner loop j < n - i - 1.
• A swap needs three statements and a temp.
• Ascending: swap when a[j] > a[j + 1]. Descending: swap when a[j] < a[j + 1].
• Comparisons: n * (n - 1) / 2, which is O(n squared).
• A swapped flag lets an already sorted array finish in one pass.

What goes in your journal

Aim, the algorithm with both loops, a flowchart with the inner loop inside the outer, the program, and two outputs: the same data sorted ascending and sorted descending. Add the pass-by-pass table for five elements and the comparison count. The count is what the viva asks about, and a journal that shows it has answered the question before it is asked.

Test yourself

1. Why does the inner loop's limit shrink on each pass? Because after pass i the largest i elements have reached their final places at the end, so there is no need to compare them again.

2. How many comparisons does bubble sort make for 10 elements? 45, which is 10 times 9 divided by 2.

3. What is the time complexity of bubble sort? O(n squared): the work grows with the square of the number of elements.

4. Why does a swap need a third variable? Because assigning one element to the other destroys the value that the second assignment needs.

5. What single change sorts in descending order instead? Reverse the comparison: swap when a[j] < a[j + 1] instead of when a[j] > a[j + 1].

6. How can an already sorted array be detected? Set a flag when any swap happens in a pass. If a whole pass makes no swap, the array is sorted and the loop can stop.

The loop copies character by character. source[start + i] is the character i places past the starting point.

The condition has two halves. i < length stops when enough characters have been taken. source[start + i] != '\0' stops at the end of the source, which is what saves the program when the user asks for more characters than there are.

part[i] = '\0'; is the line students forget. Without it, part is a character array with no end marker, and printf("%s", part) prints the extracted text followed by whatever rubbish lies after it in memory. The loop leaves i holding the number of characters copied, which is exactly the subscript the null belongs in.

The same thing with the library

string.h has a function for it, and MU's reference list names the library, so it is worth knowing both.

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

int main(void)
{
    char source[] = "Mumbai University";
    char part[20];

    strncpy(part, source + 7, 10);
    part[10] = '\0';

    printf("Extracted: %s\n", part);
    printf("Its length is %zu\n", strlen(part));

    return 0;
}

Extracted: University
Its length is 10

source + 7 is the address of the eighth character. Adding a number to an array name moves along it, which is the same arithmetic the subscript was doing.

strncpy copies at most n characters. The n is a safety limit, and it is why strncpy is preferred to strcpy, which copies until it meets a null and will happily run past the end of the destination.

part[10] = '\0'; is still needed, and this is the trap. strncpy copies the terminating null only if it fits within the n characters. Here ten characters were asked for and ten were copied, so no null was copied with them, and without that line part has no end. It is the same forgotten line as in the loop version, wearing a library's clothes.

The rule: after strncpy, put the null in yourself. It costs one line and it removes a whole class of bug.

The functions this practical touches

All of them need #include <string.h>, and all of them are taught where MU sets them: strlen and strcmp in [Practical 6(c): strlen and strcmp].

What beginners get wrong

Forgetting the terminating null in the extracted part. The output has rubbish after it.

Using %s in scanf for a string with a space. It stops at the space. Use %99[^\n].

Counting positions from 1 in the program and from 0 in the head, or the other way round. Choose one, say which in the prompt, and keep to it.

Asking for more characters than the string has. Without the second half of the loop condition, the copy runs past the end of the source.

Thinking strlen counts the null. It does not. strlen("Mumbai") is 6, and the array needs 7.

Declaring the destination too small. char part[5] with ten characters copied into it writes over its neighbours, and nothing warns you.

Quick revision

• A string is a character array ending in '\0'.
• strlen counts characters before the null; the array needs one more.
• scanf("%99[^\n]", s) reads a whole line including spaces.
• Extract by hand: copy source[start + i] for i from 0, then set part[i] = '\0'.
• source + 7 is the address of the character at subscript 7.
• strncpy(d, s, n) copies at most n characters and may leave no null; add it yourself.
• The loop condition needs both i < length and a test for the end of the source.

What goes in your journal

Aim, the algorithm with the copy loop and the null written as its own step, a flowchart, the program, and the output for at least two runs: a portion from the middle, and a request for more characters than the string holds. In the conclusion write the one sentence this practical exists for: a string is a character array that ends in a null, and a copy that does not add one is not a string.

Test yourself

1. How many bytes does the string "Mumbai" occupy? Seven: six letters and the terminating null.

2. What does part[i] = '\0'; do, and what happens without it? It marks the end of the extracted string. Without it, printf("%s", part) keeps printing past the end until it meets a zero byte somewhere in memory.

3. Why is scanf("%s", s) wrong for reading a full name? It stops at the first whitespace character, so only the first word is read.

4. What is the danger in strncpy? It copies the terminating null only if the null falls within the n characters. Copying exactly n characters leaves the destination with no end marker.

5. What does source + 7 mean? The address of the character at subscript 7, that is, the eighth character of the string.

6. strlen("Mumbai University") gives what?

1. Sixteen letters and one space, and the null is not counted.

madam    palindrome
level    palindrome
abba     palindrome
mumbai   not a palindrome
a        palindrome
(empty)  palindrome

The last two rows are the edge cases an examiner reaches for, and both come out as palindromes.

A single character: i is 0 and j is 0, so i < j is false, the loop never runs, and the flag is still 1. That is the right answer, and the program gets it without a special case.

The empty string: strlen("") is 0, so j is minus 1, i < j is false at once, and the answer is again yes. This one is a convention rather than a discovery. A string with no characters reads the same in both directions because there is nothing to read, so it is a palindrome vacuously, in the same way that 0! is 1. If your examiner wants an empty input refused instead, that is one if before the loop; what matters is that you know which answer your program gives and why.

Spaces and capital letters: the decision this chapter makes

Is Madam a palindrome? Compared exactly, no: M and m are different characters, because a capital M is 77 and a small m is 109. Is nurses run a palindrome? Compared exactly, no, because of the space.

There is no single right answer, and a student who has not decided will be caught out.

This book compares exactly, as typed. That is what MU's wording asks for: the given string, as given. A program that silently strips spaces is answering a different question from the one it was asked.

But the other version is two if statements away, and it is worth knowing:

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

int main(void)
{
    char s[] = "Madam, I'm Adam";
    int i = 0, j = (int) strlen(s) - 1, flag = 1;

    while (i < j) {
        if (!isalpha((unsigned char) s[i])) { i++; continue; }
        if (!isalpha((unsigned char) s[j])) { j--; continue; }

        if (tolower((unsigned char) s[i]) != tolower((unsigned char) s[j])) {
            flag = 0;
            break;
        }
        i++;
        j--;
    }

    printf("\"%s\" is %sa palindrome when letters alone are compared\n",
           s, flag ? "" : "not ");

    return 0;
}

"Madam, I'm Adam" is a palindrome when letters alone are compared

isalpha and tolower come from ctype.h. The cast to unsigned char is not decoration: those functions are defined for values of an unsigned char and for the end-of-file marker, and passing a plain char that happens to be negative is undefined behaviour. It costs nothing and it is correct.

The number palindrome, which is a different program

An examiner may ask for a palindrome number rather than a string. That is not this program with %d: it is the reverse-digits loop from [Practical 3(a): Reversing the Digits of a Number] followed by one comparison.

reverse the digits of n into rev
if (rev == original) it is a palindrome

Both are worth having in the journal, because the two questions sound identical and the programs share nothing.

What beginners get wrong

Setting j to strlen(s). That subscript holds the null character, so the first comparison is against '\0' and every string comes out as not a palindrome.

Looping while i <= j. At the middle character of an odd-length word it compares that character with itself, which is harmless but wasteful, and on an even-length word it compares a pair that has already been compared.

Comparing the whole string with its reverse using ==. In C, == on two arrays compares addresses, not contents, and two different arrays never have the same address. Use strcmp, which is [Practical 6(c): strlen and strcmp].

Forgetting to reset the flag between two tests when the program checks several strings in one run.

Assuming Madam is a palindrome. Not when compared exactly. Decide, and say so.

Quick revision

• A palindrome reads the same forwards and backwards.
• Two subscripts: i from 0, j from strlen(s) - 1, loop while i < j.
• Compare s[i] with s[j], then i++ and j--.
• One mismatch settles it; leave the loop at once.
• strlen(s) - 1 is the last character; strlen(s) is the null.
• A single character is a palindrome.
• Capitals and spaces matter unless you deliberately ignore them with tolower and isalpha from ctype.h.
• A palindrome number is the reverse-digits loop plus one comparison, not this program.

What goes in your journal

Aim, the nine-step algorithm, a flowchart with the loop and the mismatch decision, the program, and two runs: one palindrome and one that is not. Write the walking table for your own word, three or four rows of i, j and the two characters. In the conclusion state what your program does about capitals and spaces; that is the question you will be asked.

Test yourself

1. Why is j set to strlen(s) - 1? Because strlen counts the characters and the subscripts start at 0, so the last character sits one place before the count. strlen(s) is the subscript of the terminating null.

2. Why i < j rather than i <= j? Because when i and j meet, that character is the middle one and comparing it with itself proves nothing. All the pairs have already been checked.

3. Is Madam a palindrome? Not when the characters are compared exactly, because a capital M and a small m are different characters. It is if the comparison is made case insensitive with tolower.

4. How many comparisons does a word of ten characters need? Five. Each comparison settles a pair, and ten characters make five pairs.

5. Why can you not test s == reverse with ==? Because == on arrays compares their addresses, which are always different for two separate arrays. Contents are compared with strcmp.

6. How would you check whether a number is a palindrome? Reverse its digits with the loop from the reversing practical, and compare the reversed value with a saved copy of the original.

apple against banana is negative, because at the first character a is 97 and b is 98.

Apple against apple is negative, because a capital A is 65 and a small a is 97. Every capital letter comes before every small letter in ASCII, which is why an ordinary alphabetical sort puts Zebra before apple.

app against apple is negative. The first three characters match; then app has its terminating null, which is 0, against l, which is 108. A string that is a prefix of another always comes first.

The standard promises only the sign of the value, not its size. This library returns minus 1 and 1; another may return the difference of the character codes, minus 1 and 1 or minus 25 and 25. Test the sign, never the value. A program that says if (strcmp(a, b) == -1) is relying on something no standard guarantees.

The trap: 0 means equal

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

int main(void)
{
    char a[] = "ravi", b[] = "ravi";

    if (strcmp(a, b))
        printf("WRONG: the program thinks they are different\n");
    else
        printf("RIGHT: they are the same\n");

    if (strcmp(a, b) == 0)
        printf("The correct test: they are the same\n");

    return 0;
}

RIGHT: they are the same
The correct test: they are the same

The first if gives the right answer here for the wrong reason, and that is why it is dangerous. In C, a condition is true when it is not zero. strcmp returns 0 for equal strings, so if (strcmp(a, b)) is true exactly when the strings are different. Writing it that way and reading it as "if a equals b" gets the answer backwards on every pair that differs, and right on every pair that matches, which is the worst possible failure pattern for testing.

Always write it out: if (strcmp(a, b) == 0) for equal, != 0 for different.

And the other half of the same lesson:

if (a == b)              /* WRONG for strings */

That compares two addresses. Two separate arrays are at two different addresses, so it is false even when the contents match. == works on numbers and characters; strings need strcmp.

Both functions, in one program that does something

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

int main(void)
{
    char first[50], second[50];
    int result;

    printf("Enter the first string: ");
    scanf("%49[^\n]", first);
    printf("Enter the second string: ");
    scanf(" %49[^\n]", second);

    printf("\"%s\" has %zu characters\n", first, strlen(first));
    printf("\"%s\" has %zu characters\n", second, strlen(second));

    result = strcmp(first, second);

    if (result == 0)
        printf("The two strings are equal\n");
    else if (result < 0)
        printf("\"%s\" comes before \"%s\"\n", first, second);
    else
        printf("\"%s\" comes after \"%s\"\n", first, second);

    return 0;
}

banana
apple

Enter the first string: Enter the second string: "banana" has 6 characters
"apple" has 5 characters
"banana" comes after "apple"

The space at the start of the second format string, " %49[^\n]", skips the newline left behind by the first read. Without it the second read sees that newline immediately, matches nothing, and leaves second untouched. This is the commonest reason a program that reads two lines appears to skip the second one.

The other comparison functions

strncmp is genuinely useful: strncmp(word, "com", 3) == 0 asks whether a word begins with those three letters. strcasecmp is not in the C standard, though nearly every system has it; if a program must be portable, lower both strings yourself with tolower from ctype.h.

What beginners get wrong

if (strcmp(a, b)) read as "if equal". It is true when they differ.

Testing strcmp(a, b) == -1. Only the sign is guaranteed.

Using == on two strings. That compares addresses.

Printing strlen with %d. It returns a size_t; use %zu.

Believing strlen counts the null. It does not; the array needs one more byte than strlen reports.

Calling strlen inside a loop condition. for (i = 0; i < strlen(s); i++) recounts the whole string on every single iteration. Count once into a variable before the loop.

Forgetting #include <string.h>.

Quick revision

• Both are in string.h.
• strlen(s) counts characters before the null and returns a size_t, printed with %zu.
• sizeof is the size of the array; strlen is the length of the string in it.
• strcmp(a, b) returns 0 if equal, negative if a comes first, positive if b does.
• Only the sign is guaranteed, never the value.
• Equal is strcmp(a, b) == 0. A bare if (strcmp(a, b)) means different.
• == on strings compares addresses and is always the wrong test.
• A leading space in a scanf format skips the leftover newline.

What goes in your journal

Aim, the algorithm, the program using both functions, and the output for two pairs: two equal strings and two that differ. Write the three return values of strcmp into the conclusion as a small table. If there is room, add the sizeof against strlen line with its two numbers; both are asked in vivas and both fit on one line.

Test yourself

1. What does strcmp return when the strings are identical? 0.

2. char a[20] = "Mumbai"; What are sizeof a and strlen(a)? 20 and 6. sizeof is the size of the array, strlen the length of the string in it.

3. Why is if (strcmp(a, b)) the wrong way to test for equality? Because a non-zero value is true in C, and strcmp returns non-zero exactly when the strings are different. The test means "if they differ".

4. Is strcmp("Apple", "apple") negative or positive, and why? Negative. A capital A is 65 and a small a is 97, so the capital comes first.

5. Why should you not test strcmp(a, b) == -1? Because the standard guarantees only the sign of the result. A different library may return minus 25 for the same pair.

6. Why is for (i = 0; i < strlen(s); i++) a poor loop? Because strlen is called on every iteration and walks the whole string each time. Store the length in a variable before the loop.

Those five lines are the whole practical, and line 2 against line 3 is the point.

Inside swap_by_value the swap worked. x became 20 and y became 10. The function did its job perfectly, on its own two copies.

Back in main, nothing had changed. a was still 10. The copies were destroyed when the function returned, and they were the only things that were swapped.

Inside swap_by_reference the swap also worked, and this time x and y were not copies: they were other names for main's own a and b.

Back in main, a and b had exchanged values. The function reached through the addresses it was given.

Why the copies are genuinely separate

#include <stdio.h>

void examine(int x, int *p);

int main(void)
{
    int a = 10;

    examine(a, &a);
    return 0;
}

void examine(int x, int *p)
{
    printf("the copy holds %d, and the pointer points at %d\n", x, *p);

    x = 99;
    printf("after changing the copy, the original is still %d\n", *p);

    *p = 77;
    printf("after changing through the pointer, the original is %d\n", *p);
    printf("but the copy is still %d\n", x);
}

the copy holds 10, and the pointer points at 10
after changing the copy, the original is still 10
after changing through the pointer, the original is 77
but the copy is still 99

One function, one variable in main, and two routes to it. Changing x moved nothing but x. Changing *p moved the original, and the copy did not notice.

The three lines of a swap, in both forms

Every x has become *x, and the call has gained two ampersands. Nothing else changed.

Call by value against call by reference

Neither is better. A function that only reads its input should take it by value, because then a reader of the call knows nothing can change. A function that must change something has no choice.

Where you have already met both

printf("%d", a) is call by value. It only reads.

scanf("%d", &a) is call by reference. It must change a, so it is given the address.

An array passed to a function is always by reference, in effect, because an array name is the address of its first element. That is why the sorting function in a larger program can sort the caller's array, and why char * parameters in [Practical 6(b): Is This String a Palindrome?] could read the caller's string.

What beginners get wrong

Calling swap(a, b) on the pointer version. The compiler refuses: an int is not an int *.

Calling swap(&a, &b) on the value version. The compiler refuses the other way round.

Writing x = y instead of x = y inside the pointer version. That swaps the two pointers, which are themselves copies, so nothing happens in the caller. It compiles and it looks right, and it is the classic wrong answer to this practical.

Forgetting temp. Two statements lose a value, as in [Practical 5(b): Sorting an Array].

Declaring int x, y; and expecting two pointers. The attaches to the name, not to the type, so that declares one pointer and one plain int. Write int x, y;.

Saying "C supports call by reference". Say instead: C passes everything by value, and call by reference is achieved by passing an address by value.

Quick revision

• Call by value copies the argument; the function cannot change the caller's variable.
• Call by reference passes an address; the function changes the original through it.
• int p; declares a pointer. &a is the address of a. p is what p points at.
• In a declaration says "pointer"; in an expression says "fetch what is there".
• Swap by reference: temp = x; x = y; y = temp; called as swap(&a, &b).
• int x, y; declares two pointers. int* x, y; does not.
• scanf is call by reference and always has been; that is what its & is for.
• Strictly, C has only call by value. Passing an address by value is how call by reference is done.

What goes in your journal

Aim, an algorithm for each of the two functions, a flowchart, one program containing both functions, and the full output with all five lines. The output is the whole demonstration: the "inside the function" line of the value version proves that the swap worked, and the line after it proves that it did not reach main. In the conclusion write one sentence saying why, in terms of copies and addresses.

Test yourself

1. What is passed in call by value, and what in call by reference? A copy of the value, and the address of the variable.

2. In int p;, what does the mean, and what does it mean in *p = 7;? In the declaration it says p is a pointer. In the statement it fetches the thing p points at, so 7 is stored in that variable.

3. Why does the call by value swap fail? Because the function swaps its own two copies, which are destroyed when it returns. The caller's variables were never touched.

4. Which of printf and scanf uses call by reference, and why? scanf, because it must store a value into the caller's variable, and to do that it needs the address.

5. What does int x, y; declare? One pointer to int, called x, and one ordinary int called y. The binds to the name.

6. Does C support call by reference? Not directly. Every argument is passed by value. Call by reference is obtained by passing an address by value and dereferencing it inside the function.

2 3
1 2 3
4 5 6

Enter the number of rows and columns: Element [0][0]: Element [0][1]: Element [0][2]: Element [1][0]: Element [1][1]: Element [1][2]:
The 2 by 3 matrix:
    1    2    3
    4    5    6

Three things in that program

The array is declared 10 by 10 and only m by n of it is used. That is the ordinary way this practical is written, and the reason is in the next section.

The size check is not optional. With m of 20 the reading loop writes past the end of the array, which is undefined behaviour and may corrupt anything. Two comparisons prevent it.

%5d prints in a field five wide, which is what makes the columns line up. Without it, 5 and 100 take different amounts of room and the matrix comes out ragged. This is the same field width idea as %-4d in the students practical, without the minus because numbers look right when they are right aligned.

Why not declare the array after reading m and n

C99 added variable length arrays, which allow exactly that:

int m, n;
scanf("%d %d", &m, &n);
int a[m][n];           /* a variable length array */

It compiles in C17 and it works. There are two reasons this book does not use it.

It is optional. C11 made variable length arrays a feature a compiler may choose not to support, and the macro __STDC_NO_VLA__ exists to say so. Microsoft's compiler, which many college laboratories use behind an IDE, does not support them.

There is nowhere to report a failure. A fixed array of 10 by 10 that is asked for 20 by 20 can print a message. A variable length array asked for 100000 by 100000 simply fails, usually by crashing, and there is no way to test for it.

So: declare generously, check the input, and use the part you need. If your college teaches the variable length form, use it and say in your journal that you know why the fixed form is the safer one.

Reading in the other order

The program above reads row by row, which is how a matrix is written on paper. Reading column by column takes one change, the loops swapped:

for (j = 0; j < n; j++)
    for (i = 0; i < m; i++)
        scanf("%d", &a[i][j]);

The subscripts stay a[i][j], because that is still row i column j. Only the order in which the elements are visited has changed. Examiners ask for this to see whether a student understands that the loops and the subscripts are separate decisions.

What beginners get wrong

Writing a[i, j]. In C the comma is an operator; a[i, j] means a[j], which is a whole row. Two sets of brackets, always.

Mixing up the subscripts. a[j][i] is the transpose, and it is a different matrix.

Declaring int a[m][n] before m and n have been read. At that point they hold rubbish.

Not checking m and n against the declared size. The reading loop then writes outside the array.

Printing without a field width. The matrix comes out ragged and the journal looks careless.

Forgetting printf("\n") after each row. The whole matrix prints on one line.

Quick revision

• int a[3][4]; is three rows of four columns, twelve ints.
• a[i][j] is row i, column j. Both subscripts start at 0.
• C stores a matrix in row major order: all of row 0, then all of row 1.
• a[0] is itself an array, so a matrix is an array of arrays.
• Declare generously, read m and n, check them, and use the part you need.
• Variable length arrays exist in C99 and are optional since C11; not every compiler has them.
• %5d aligns the columns; printf("\n") ends each row.

What goes in your journal

Aim, the algorithm with both nested loops, a flowchart showing the inner loop inside the outer, the program, and the output for at least a 2 by 3 matrix so that the difference between rows and columns is visible. A 3 by 3 example hides a subscript mix-up, because the transpose of a square matrix is the same shape; a rectangular one exposes it immediately.

Test yourself

1. int a[3][4]; How many ints, and what is the last valid element? Twelve, and the last is a[2][3].

2. What is row major order? Storing a two dimensional array one whole row after another in memory. C uses it.

3. Why is a[i, j] wrong? Because the comma is an operator, so the expression evaluates to j and a[j] is a whole row, not an element. Use a[i][j].

4. Why declare int a[10][10] and read smaller sizes into it? Because the size must be known where the array is declared unless variable length arrays are used, and those are optional in C11 and absent from some compilers. A fixed size also allows the program to reject an input that is too large.

5. What does %5d do? Prints the integer right aligned in a field five characters wide, so columns line up.

6. How do you read the matrix column by column instead? Swap the two loops so that j is the outer one. The subscripts stay a[i][j].

Look at the subscripts in the innermost line. a[i][k] walks along row i of A as k grows; b[k][j] walks down column j of B. They move together, which is exactly the pairing the formula asks for. Getting a[k][i] or b[j][k] there is the commonest error in this practical, and the result is the product of transposes, which is a different matrix.

c[i][j] = 0; before the innermost loop is not optional. The element is an accumulator and it must start empty, for the reason given in [Practical 3(b): The Factorial of a Number].

Passing a matrix to a function

A one dimensional array is passed as an address and the function does not need to know how long it is. A two dimensional array is different: to work out where a[i][j] lives, the compiler must know how many columns there are in a row, because the rows are laid end to end.

So the parameter is written with the first size left out and every later size given:

void multiply(int a[][10], int b[][10], int c[][10], int m, int n, int q);

int a[][10] means "an array of rows, each row being ten ints". The number of rows may be left blank because it is never needed for the address arithmetic; the 10 may not.

That is why every matrix in this program is declared [10][10] and the used part is m by n: the second dimension must be a fixed number that the function and the caller agree on. Passing a 10 by 10 array to a function expecting int a[][20] does not compile, and it should not.

The program

#include <stdio.h>

void read_matrix(int a[][10], int rows, int cols, const char *name);
void print_matrix(int a[][10], int rows, int cols, const char *name);
void multiply(int a[][10], int b[][10], int c[][10], int m, int n, int q);

int main(void)
{
    int a[10][10], b[10][10], c[10][10];
    int m, n, p, q;

    printf("Rows and columns of the first matrix: ");
    scanf("%d %d", &m, &n);
    printf("Rows and columns of the second matrix: ");
    scanf("%d %d", &p, &q);

    if (n != p) {
        printf("Cannot multiply: the first has %d columns "
               "and the second has %d rows\n", n, p);
        return 0;
    }

    read_matrix(a, m, n, "A");
    read_matrix(b, p, q, "B");

    multiply(a, b, c, m, n, q);

    print_matrix(a, m, n, "A");
    print_matrix(b, p, q, "B");
    print_matrix(c, m, q, "A times B");

    return 0;
}

void read_matrix(int a[][10], int rows, int cols, const char *name)
{
    int i, j;

    printf("Enter %d values for matrix %s: ", rows * cols, name);

    for (i = 0; i < rows; i++)
        for (j = 0; j < cols; j++)
            scanf("%d", &a[i][j]);
}

void print_matrix(int a[][10], int rows, int cols, const char *name)
{
    int i, j;

    printf("\nMatrix %s (%d by %d)\n", name, rows, cols);

    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++)
            printf("%6d", a[i][j]);
        printf("\n");
    }
}

void multiply(int a[][10], int b[][10], int c[][10], int m, int n, int q)
{
    int i, j, k;

    for (i = 0; i < m; i++)
        for (j = 0; j < q; j++) {
            c[i][j] = 0;
            for (k = 0; k < n; k++)
                c[i][j] += a[i][k] * b[k][j];
        }
}

2 3
3 2
1 2 3 4 5 6
7 8 9 10 11 12

Rows and columns of the first matrix: Rows and columns of the second matrix: Enter 6 values for matrix A: Enter 6 values for matrix B:
Matrix A (2 by 3)
     1     2     3
     4     5     6

Matrix B (3 by 2)
     7     8
     9    10
    11    12

Matrix A times B (2 by 2)
    58    64
   139   154

The four numbers are the four worked out by hand above.

The mismatched case, refused

#include <stdio.h>

int main(void)
{
    int n = 3, p = 2;

    if (n != p)
        printf("Cannot multiply: first has %d columns, second has %d rows\n",
               n, p);
    else
        printf("The product is defined\n");

    return 0;
}

Cannot multiply: first has 3 columns, second has 2 rows

That is the whole guard, and a program that has it is a complete answer where one that does not is half of one.

Two facts about matrix multiplication worth a viva mark

It is not commutative. A times B is not generally B times A, and very often B times A does not even exist: with A of 2 by 3 and B of 3 by 2, A times B is 2 by 2 and B times A is 3 by 3. Two different matrices, from the same pair.

It is associative. (A times B) times C equals A times (B times C), whenever the sizes allow.

What beginners get wrong

Not testing that the columns of A match the rows of B.

Writing a[k][i] or b[j][k] in the innermost line. The subscripts are a[i][k] * b[k][j], in that order.

Forgetting c[i][j] = 0;. The element starts with whatever was in that memory and every answer is wrong by a random amount.

Putting c[i][j] = 0; in the wrong place. Inside the k loop it wipes the running total on every step and leaves only the last term.

Declaring the function parameter as int a[][]. Both dimensions blank does not compile: the column count is needed.

Assuming the answer has the same shape as the inputs. A of m by n times B of n by q gives m by q.

Quick revision

• A of m by n times B of p by q exists only when n equals p, and the answer is m by q.
• C[i][j] is row i of A against column j of B, multiplied term by term and added.
• Three loops: i over the answer's rows, j over its columns, k along the row and down the column.
• c[i][j] = 0; goes between the j loop and the k loop.
• The inner statement is c[i][j] += a[i][k] * b[k][j];.
• A function parameter is int a[][10]: the first size may be blank, the rest may not.
• Matrix multiplication is associative but not commutative.

What goes in your journal

Aim, the algorithm with all three loops, a flowchart, the program with the three functions, and the output showing both input matrices and the product. Work one element out by hand beside the output, the way C[0][0] is worked out in this chapter: it is the proof that you know where the numbers came from, and it is two lines of arithmetic.

Test yourself

1. When can two matrices be multiplied? When the number of columns of the first equals the number of rows of the second.

2. A is 3 by 5 and B is 5 by 2. What size is the product? 3 by 2.

3. What are the three loops for? The outer two visit each element of the answer, by row and by column. The innermost adds up the products of one row of A with one column of B.

4. Where does c[i][j] = 0; go, and why? Immediately inside the j loop and before the k loop, because the element is an accumulator and must be empty before the summing begins, but only once per element.

5. Why must a function parameter be int a[][10] rather than int a[][]? Because the compiler works out the address of a[i][j] from the number of columns in a row. The row count is never needed; the column count always is.

6. Is A times B the same as B times A? No. Matrix multiplication is not commutative, and for non square matrices the second product often does not exist at all.

Details of two books
--------------------
Book ID : 101
Title   : The C Language
Author  : Dennis Ritchie
Subject : Programming

Book ID : 102
Title   : Database Systems
Author  : Ramez Elmasri
Subject : Databases

One structure occupies 96 bytes

Both ways of filling a structure are shown: b1 with an initialiser list at the point of declaration, and b2 member by member with strcpy afterwards.

The size is worth a second look, because it is not what the members add up to. 40 plus 30 plus 20 plus 4 is 94, and the program reported 96.

The two extra bytes are padding. The three character arrays end at byte 90, and an int on this machine is happiest starting at an address that is a multiple of 4, so the compiler leaves bytes 90 and 91 unused and puts book_id at byte 92. That takes the structure to 96.

So never add the members up by hand and call it the size. Ask sizeof, which is what it is for, and remember that the answer may differ between compilers and between machines.

The students reading, with two records read from the user

#include <stdio.h>

struct student {
    int  roll;
    char name[30];
    char course[15];
    float marks;
};

int main(void)
{
    struct student s[2];
    int i;

    for (i = 0; i < 2; i++) {
        printf("Student %d roll number: ", i + 1);
        scanf("%d", &s[i].roll);

        printf("Student %d name: ", i + 1);
        scanf(" %29[^\n]", s[i].name);

        printf("Student %d course: ", i + 1);
        scanf(" %14[^\n]", s[i].course);

        printf("Student %d marks: ", i + 1);
        scanf("%f", &s[i].marks);
    }

    printf("\nRoll  Name             Course      Marks\n");
    printf("----  ---------------  ----------  -----\n");

    for (i = 0; i < 2; i++)
        printf("%-4d  %-15s  %-10s  %5.2f\n",
               s[i].roll, s[i].name, s[i].course, s[i].marks);

    return 0;
}

101
Asha Kulkarni
BSc IT
78.5
102
Ravi Deshmukh
BSc IT
65.25

Student 1 roll number: Student 1 name: Student 1 course: Student 1 marks: Student 2 roll number: Student 2 name: Student 2 course: Student 2 marks:
Roll  Name             Course      Marks
----  ---------------  ----------  -----
101   Asha Kulkarni    BSc IT      78.50
102   Ravi Deshmukh    BSc IT      65.25

struct student s[2]; is an array of structures, which is how any real record keeping program is built: s[0] and s[1] are whole students, and s[i].name is one member of one of them.

Reading a name that has a space in it

scanf(" %29[^\n]", s[i].name) is the call that [Practical 5(a): Ten Students' Roll Numbers and Names] promised. Three parts, and all three are needed.

%[^\n] is a scan set meaning "every character except a newline", so the read stops at the end of the line rather than at the first space. That is what lets "Asha Kulkarni" arrive whole.

The 29 limits it to twenty-nine characters, leaving the thirtieth for the terminating null.

The leading space skips whatever whitespace is waiting, and there is always some: the Enter you pressed after the roll number is still in the buffer. Without that space the scan set sees the newline at once, matches nothing, and the name is left empty. This is the single commonest defect in a first-semester program that mixes numbers and names.

Structure against array

The fourth row is worth dwelling on. b2 = b1; is legal and copies all four members including the character arrays, where copying two plain arrays needs strcpy or a loop. Structures may be assigned; arrays may not.

typedef, so you can stop writing struct

typedef struct {
    char title[40];
    int  book_id;
} Book;

Book b1, b2;                 /* no `struct` keyword needed */

typedef gives a type a second, shorter name. It is common in real code and costs nothing to know.

What beginners get wrong

Forgetting the semicolon after the closing brace of the structure.

Writing b1.title = "something";. An array cannot be assigned. Use strcpy.

Using -> on a structure variable. The arrow is for a pointer to a structure: p->title means (*p).title. With a plain variable it is the dot.

Declaring the structure inside main and then using it in a function. Declare the structure at file scope, above main, so every function can see it.

Reading a name with %s. It stops at the first space, so "Asha Kulkarni" becomes "Asha".

Leaving out the leading space in " %29[^\n]". The name comes out empty.

Adding the member sizes up by hand and expecting sizeof to agree. Padding may make the structure larger.

Quick revision

• A structure groups items of different types under one name; an array groups items of one type.
• struct book { ... }; and the semicolon after the brace is required.
• b1.title is the dot operator; p->title is for a pointer to a structure.
• Initialise with struct book b1 = {...}; or fill members later with strcpy and assignment.
• A character array member cannot be assigned with =; use strcpy.
• A whole structure can be assigned: b2 = b1; copies every member.
• struct student s[2]; is an array of structures; s[i].name is one member of one record.
• scanf(" %29[^\n]", name) reads a line with spaces; the leading space skips the waiting newline.
• sizeof may exceed the sum of the members because of padding.

What goes in your journal

Aim, the algorithm, the program, and the output showing two complete records. Write the structure declaration out separately in the journal with each member labelled with its type; that declaration is what the viva is about. In the conclusion give the one sentence distinction between a structure and an array.

Test yourself

1. What is the difference between an array and a structure? An array holds many items of the same type, named by a subscript. A structure holds several items of possibly different types, named by member names.

2. What is wrong with b1.title = "The C Language";? title is an array, and an array cannot be assigned to. Use strcpy(b1.title, "The C Language").

3. When is -> used instead of .? When the variable on the left is a pointer to a structure. p->title is short for (*p).title.

4. Can one structure be assigned to another? Yes. b2 = b1; copies all the members, including the character arrays.

5. Why does scanf(" %29[^\n]", name) need the leading space? Because the newline left behind by the previous read is still waiting, and without the space the scan set would stop on it at once and read nothing.

6. Why might sizeof(struct book) be larger than the sum of its members? Because the compiler may insert padding bytes so that members begin at addresses the machine handles efficiently.

Six rules and six messages. Write them down before writing the program, because each one is an if and a return, and they are much harder to insert afterwards.

Notice that every rule says what the program does as well as what it forbids. "Refuses" is not enough: the user must be told why, or they will try the same thing again.

Step 4: how the parts fit together

main
  the menu loop
      switch on the choice
          create_account
          deposit        \
          withdraw        >  each of these first calls find_account
          enquiry        /
          display_all

One function is shared by three others. find_account(number) searches the array and returns the subscript of the account, or minus 1 if there is none.

int find_account(int number)
{
    for (i = 0; i < count; i++)
        if (bank[i].number == number)
            return i;
    return -1;
}

Minus 1 is chosen as the "not found" answer because it is not a valid subscript, so it can never be mistaken for one. Deposit, withdraw and enquiry all begin the same way: find the account, and if the answer is minus 1, print a message and return.

Writing that search once instead of three times is the whole argument for functions from [Practical 4(a): The Area of a Square, Using a Function], appearing in a program large enough for it to matter.

The algorithm for the whole program

1. Start

2. Set count to 0 and the next account number to 1001

3. Display the menu and read the choice

4. If the choice is 1, create an account: read the name and the opening deposit, refuse if it is below 500, otherwise store the record and increase count

5. If the choice is 2, deposit: read the number, find the account, refuse if not found or if the amount is not positive, otherwise add it to the balance

6. If the choice is 3, withdraw: read the number, find the account, refuse if not found, if the amount is not positive, or if the balance would fall below 500, otherwise subtract it

7. If the choice is 4, find the account and print it

8. If the choice is 5, print every account from 0 to count minus 1

9. If the choice is not between 1 and 6, print that the choice is not valid

10. If the choice is not 6, go back to step 3

11. Stop

What this design leaves out, and why saying so is worth marks

The accounts disappear when the program ends. They are in memory, not in a file. Saving them would need file handling, which MU does not set in Semester 1, so it is out of scope. Say this in your conclusion: it shows you know the limit of your own program rather than having failed to notice it.

There is no password and no date. A real system has both. This one is a mini project, and adding them without being asked makes the program longer without making it better.

float loses fractions of a paisa. A float keeps about seven significant digits, so a balance in the crores is no longer exact to the paisa. Real banking software uses integer paise, or a decimal type, for exactly this reason. In a mini project a float is the right choice and knowing why it would not be in a real one is a very good viva answer.

What beginners get wrong

Writing the program first and the design afterwards. The journal then shows a design that describes the code instead of a design the code came from, and it always shows.

Looping to 100 instead of to count. The program then reads accounts that do not exist.

Letting find_account return the account number instead of the subscript. Then the caller cannot reach the record, and returning 0 for "not found" collides with the first real subscript.

Putting the validation in main. Each rule belongs in the function that owns the operation, so that the rule and the change are never separated.

Forgetting to increase count. Every new account then overwrites the last one.

Quick revision

• One account is a structure: number, name, balance. The bank is an array of them plus a count.
• count is how many accounts exist; loops run to count, not to the array's size.
• Six menu items: create, deposit, withdraw, enquiry, display all, exit.
• One shared function, find_account, returns a subscript or minus 1.
• Minus 1 cannot be a subscript, which is why it is the "not found" answer.
• Six rules to enforce, each with its own message to the user.
• The data is lost when the program ends; say so rather than leaving it unsaid.

What goes in your journal

This chapter is the front half of the Practical 10 write-up, and it is unusual in that almost all of it is writing rather than code. Include the aim, the structure definition with each member's type and purpose, the menu table, the table of rules, the diagram of which function calls which, and the eleven-step algorithm. The program itself goes in the next entry.

An examiner who reads that design before reading your program already knows you understood the task. That is worth more than a longer program.

Test yourself

1. Why is an account a structure rather than three arrays? Because the three values describe one thing and are of different types. Keeping them in one record means they cannot be accidentally separated.

2. What does count hold, and why not use the array's size? The number of accounts that actually exist. The array is declared large enough for the most the program will hold, and most of it is unused.

3. Why does find_account return minus 1 when there is no such account? Because minus 1 is not a valid subscript, so the caller can never confuse it with a real one. Returning 0 would collide with the first account.

4. Name three things the program must refuse. An opening deposit below the minimum, a withdrawal that would take the balance below the minimum, and an operation on an account number that does not exist.

5. What happens to the accounts when the program ends? They are lost. They are held in memory only, and saving them would require file handling.

6. Why is float acceptable here but not in a real bank? Because a float keeps only about seven significant digits, so large balances stop being exact to the paisa. Real systems store money as whole paise or in a decimal type.

1
Asha Kulkarni
5000
1
Ravi Deshmukh
2000
2
1001
1500
3
1002
1800
3
1001
1000
4
1001
5
7
6

BANK MANAGEMENT SYSTEM
1 Create account   2 Deposit   3 Withdraw
4 Balance enquiry  5 Display all   6 Exit
Enter your choice: Name of the account holder: Opening deposit: Account 1001 opened for Asha Kulkarni with a balance of 5000.00

BANK MANAGEMENT SYSTEM
1 Create account   2 Deposit   3 Withdraw
4 Balance enquiry  5 Display all   6 Exit
Enter your choice: Name of the account holder: Opening deposit: Account 1002 opened for Ravi Deshmukh with a balance of 2000.00

BANK MANAGEMENT SYSTEM
1 Create account   2 Deposit   3 Withdraw
4 Balance enquiry  5 Display all   6 Exit
Enter your choice: Account number: Amount to deposit: Deposited 1500.00. The balance of account 1001 is now 6500.00

BANK MANAGEMENT SYSTEM
1 Create account   2 Deposit   3 Withdraw
4 Balance enquiry  5 Display all   6 Exit
Enter your choice: Account number: Amount to withdraw: Refused. The balance of 2000.00 would fall below the minimum of 500.00

BANK MANAGEMENT SYSTEM
1 Create account   2 Deposit   3 Withdraw
4 Balance enquiry  5 Display all   6 Exit
Enter your choice: Account number: Amount to withdraw: Withdrew 1000.00. The balance of account 1001 is now 5500.00

BANK MANAGEMENT SYSTEM
1 Create account   2 Deposit   3 Withdraw
4 Balance enquiry  5 Display all   6 Exit
Enter your choice: Account number: Account 1001  Asha Kulkarni  balance 5500.00

BANK MANAGEMENT SYSTEM
1 Create account   2 Deposit   3 Withdraw
4 Balance enquiry  5 Display all   6 Exit
Enter your choice:
Number  Name                     Balance
------  -----------------------  ----------
1001    Asha Kulkarni               5500.00
1002    Ravi Deshmukh               2000.00

BANK MANAGEMENT SYSTEM
1 Create account   2 Deposit   3 Withdraw
4 Balance enquiry  5 Display all   6 Exit
Enter your choice: Please choose a number between 1 and 6

BANK MANAGEMENT SYSTEM
1 Create account   2 Deposit   3 Withdraw
4 Balance enquiry  5 Display all   6 Exit
Enter your choice: Thank you for banking with us

What that session shows

Nine passes through the menu, and each one was chosen to exercise a different part of the design.

The fourth pass is the important one. Account 1002 holds 2000 and 1800 was asked for, which would leave 200, below the minimum of 500. The program refused and said what the balance was. A run that shows only successful operations has not demonstrated that the rules exist.

Everything from Module 1, in one program

This is why MU sets the mini project last.

Nothing in it is new. That is the point: a project is the existing tools put together, not a new subject.

Three details worth defending in a viva

static on the global variables. static struct account bank[100]; at file scope means the name is visible in this file only. In a one file program it changes nothing you can see, and it is the right habit: a name that does not need to be visible elsewhere should not be.

if (scanf("%d", &choice) != 1) break; guards against the input running out or the user typing letters. scanf returns the number of items it successfully read, and testing that return value is the difference between a program that ends cleanly and one that loops forever printing its menu. Most first-semester programs ignore it; this is a good thing to be asked about.

bank[count - 1] in the success message of create_account. count has already been increased by then, so the record just written is at count - 1. Writing the message before the increase would be simpler; it is written this way here deliberately, because the order of those two lines is exactly the kind of thing an examiner points at and asks you to explain.

How to extend it, if you have time

None of these is required, and adding them badly is worse than not adding them. If you do add one, say in the journal why.

Save to a file. fopen, fwrite of the array, fclose, and read it back at the start. This makes the accounts survive the program ending, and it is the natural next step; MU sets file handling in the second semester.

A transaction list. A second structure holding the account number, the date, the type and the amount, in its own array, appended to by deposit and withdraw.

Search by name. strcmp in a loop, from [Practical 6(c): strlen and strcmp].

Close an account. Move the last record into the gap and reduce count by one, which is the standard way of deleting from an array when the order does not matter.

What beginners get wrong

Writing the whole thing in main. It will be two hundred lines with no shape, and a viva question about any part of it means reading the whole thing.

Testing only the happy path. Every refusal in the design must appear in the output you write up.

Using count and the array size interchangeably.

Reading the name with %s. "Asha Kulkarni" becomes "Asha".

Leaving out the default in the switch. An invalid choice then does nothing at all and the user cannot tell whether the program is working.

Changing the balance before the checks. Every validation must come before the assignment, so that a refused operation leaves the record exactly as it was.

Quick revision

• One structure for an account, one array of them, one count of how many are in use.
• do while around the menu; switch with a default inside it.
• One shared find_account returning a subscript or minus 1.
• Validate first, change afterwards. A refused operation must leave the data untouched.
• scanf returns how many items it read; test it.
• Field widths in printf are what make the account table line up.
• The data lives in memory only and is lost when the program ends.

What goes in your journal

Aim, the program in full, and the complete session, both the successful operations and the refused ones. The design went in the previous entry; refer to it rather than repeating it.

Write a short conclusion of three or four lines: what the project demonstrates, which Module 1 techniques it uses, and the one limitation you know about, which is that the accounts are not saved. A conclusion that names its own limitation is the mark of somebody who understands their program.

Test yourself

1. Why is the menu loop a do while? Because the menu must be displayed before the user can have made a choice, so the body has to run at least once before the condition is tested.

2. What does find_account return, and what does minus 1 mean? The subscript of the matching account, or minus 1 when there is none. Minus 1 is safe because it is not a valid subscript.

3. Why must the validation come before the balance is changed? So that a refused operation leaves the record exactly as it was. Changing first and checking afterwards would need the change undone.

4. What does scanf return, and why test it? The number of input items it read successfully. Testing it catches the input ending or the user typing something that is not a number, which would otherwise leave the program looping.

5. Why is the new account printed as bank[count - 1]? Because count has already been increased, so the record just written is one place below the new value.

6. How would you make the accounts survive the program ending? By writing the array to a file with fopen and fwrite before exit, and reading it back at the start.

7. Which single change would let the bank hold more than a hundred accounts? Raising the constant the array is declared with. Every loop already runs to count rather than to a fixed number, so nothing else has to change.

Once in, the prompt reads mysql> and it is waiting.

The one rule about semicolons

Every statement ends with a semicolon. The client does not send a statement until it sees one.

This is the first thing that goes wrong for everybody. You type SELECT * FROM book and press Enter, and the prompt changes to -> and nothing happens. The client is not stuck; it is waiting for the rest of the statement. Type a semicolon and press Enter, and it runs.

To abandon a half typed statement, type \c and press Enter.

Which server is this

SELECT VERSION() AS server_version;

+----------------+
| server_version |
+----------------+
| 9.6.0          |
+----------------+

That is the version this book was written and checked on. Yours will print its own number, and nothing in this module depends on the difference. Where a chapter does turn on a version, it says so in its own words.

Making the database this book uses

Everything in Module 2 works on one small library: authors, the books they wrote, the members of the library, and the loans. It is the same library whose book record MU's own Module 1 Practical 9 asked for, with the members Title, Author, Subject and Book ID.

First, check that the name is free. SHOW DATABASES lists every database on the server, and LIKE narrows the list:

SHOW DATABASES LIKE 'library%';

Nothing came back at all: not a table with no rows in it, just nothing. So no database whose name begins with library exists yet, and the name is free. An empty result is not an error; it is an answer.

CREATE DATABASE librarydb;

Nothing is printed because nothing was asked for. Silence after a statement that changes something is normal, and it means it worked.

Creating a database does not put you inside it. USE does that:

USE librarydb;
SELECT DATABASE() AS now_using;

+-----------+
| now_using |
+-----------+
| librarydb |
+-----------+

From here until the end of this session, every table you name is looked for in librarydb. SELECT DATABASE() is how you ask which one you are in, and it is worth typing whenever a statement complains that a table does not exist: half the time you are in the wrong database.

What is in it so far

SHOW TABLES;

Nothing again, which is correct: a new database has no tables. Filling it is [Practical 2: Viewing Databases, Creating One and Listing Its Tables] onward.

How the chapters from here on work

Every chapter of Module 2 after the three ER chapters begins with the library already built and its rows already in place, and says so in its own opening. You do not rebuild it for each practical. If you want to start again from scratch at any point:

DROP DATABASE librarydb;
CREATE DATABASE librarydb;
USE librarydb;

and then run the table creation of [Practical 2: Creating a Table, and Choosing Its Data Types] again.

Upper case, lower case, and layout

SQL keywords may be written in any case: select, SELECT and SeLeCt are the same word. Table and column names are case sensitive on Linux and not on Windows, which is a real source of confusion when a program written in a laboratory is run at home.

The convention this book follows, and which every examiner recognises:

• Keywords in capitals: SELECT, FROM, WHERE, ORDER BY.
• Names in small letters: book, member_name.
• One clause per line when a query is longer than a line.

It is a convention, not a rule, and it exists so that a long query can be read.

What beginners get wrong

Forgetting the semicolon. The prompt turns into -> and waits.

Thinking CREATE DATABASE also selects it. It does not; USE does.

Working in the wrong database. SELECT DATABASE(); tells you which one.

Expecting output from a statement that changes something. Silence means success.

Typing a query into the shell instead of into mysql. The shell has never heard of SELECT.

Writing the password on the command line after -p. It is visible to everyone on the machine. Let it ask.

Quick revision

• A database is organised related data; a DBMS manages it; SQL is the language.
• Advantages over files: no duplication, programs do not know the layout, constraints, concurrency, security, recovery.
• Table equals relation; row equals record equals tuple; column equals field equals attribute.
• A primary key identifies a row; a foreign key points at another table's primary key.
• Every statement ends with a semicolon; \c abandons one.
• SHOW DATABASES;, CREATE DATABASE name;, USE name;, SELECT DATABASE();, SHOW TABLES;.
• Keywords are not case sensitive; table names may be, depending on the operating system.

What goes in your journal

This chapter is not one of MU's ten practicals, so it has no entry of its own. Write the connection command, the database name, and the semicolon rule on the inside cover with the compile command from Module 1. You will need all three every week.

Test yourself

1. What is the difference between a database and a DBMS? The database is the data. The DBMS is the software that stores, protects and gives access to it.

2. Give three advantages of a DBMS over keeping data in ordinary files. Data is not duplicated and cannot disagree with itself; constraints refuse invalid values; access can be granted per user and per table. Concurrency and recovery are two more.

3. What are the three names for one row of a table? Row, record and tuple.

4. You typed a SELECT and the prompt changed to ->. What happened? The semicolon was missing, so the client is still waiting for the end of the statement.

5. What does USE librarydb; do that CREATE DATABASE librarydb; does not? It makes that database the current one, so that later statements find its tables. Creating a database does not select it.

6. A statement printed nothing at all. Did it fail? No. A statement that changes something rather than asking something prints nothing when it succeeds. An error would have printed an error.

Worked on the library's members. Suppose each member has member_id, an email address, a name and a city.

• {member_id} is a candidate key: no two members share one.
• {email} is another candidate key, if the library insists on different addresses.
• {member_id, name} is a super key but not a candidate key, because name is spare.
• {name} is not a key at all: two members may both be called Asha Kulkarni.
• Choose member_id as the primary key; email is then an alternate key.

Choose a primary key that is short, never changes, and is never unknown. That is why member_id beats email: a member may change their email, and the value would then have to be changed everywhere it has been used.

The four-step method

This is what to do in an examination when handed a paragraph of English.

Step 1: underline every noun. Each is a candidate for an entity set or an attribute. It is an entity set if it has properties of its own, or if there can be many of them for one owner, or if more than one other thing refers to it. Otherwise it is an attribute.

Step 2: underline every verb that joins two nouns. Each is a candidate relationship set.

Step 3: for every entity set, find a key. If there is none, it is a weak entity set, which is covered in [Practical 1: Relationships and Cardinality].

Step 4: for every relationship, ask how many on each side. That is the cardinality, and it is the next chapter.

Worked example: the library, from a paragraph

The library keeps books. Each book has a number, a title, a subject, a price and the date it was added, and is written by one author. An author has a name and a country and may have written several books, or none yet. Members join the library on a date and have a name, a course and a city. A member may borrow many books and a book may be borrowed by many members over time, and for each borrowing the library records the date it was issued and the date it came back.

Step 1: the nouns.

author is the interesting decision. If a book simply carried an author's name as text, author would be an attribute. It is an entity set here because the paragraph gives it a property of its own, the country, and because one author may have several books: storing the country beside every book would repeat it, and two rows could then disagree about where the same author is from. That repetition is the signal that a noun should be an entity set of its own.

Step 2: the verbs.

Step 3: the keys. BOOK is identified by its number, so book_id is the primary key. AUTHOR gets author_id and MEMBER gets member_id. None of the three has a natural key that is short, unchanging and always known, which is why each is given a number of its own.

Step 4: where do issued_on and returned_on go? Not on BOOK, because a book is borrowed many times and would need many dates. Not on MEMBER, for the same reason. They belong to the borrowing itself, so they are attributes of the relationship, drawn as ellipses hanging off the diamond.

Figure 29.2 The whole library: three entity sets, two relationships, and two attributes that belong to a relationship rather than to either entity set

That last point is the one most often got wrong and most often asked about. An attribute that needs two entities named before it means anything belongs to the relationship between them. A mark in a marks database is the same: it needs a student and a subject.

What it does NOT mean

A rectangle is not a table. It becomes one later, usually, but the diagram is deliberately free of tables so that it can be discussed with people who do not know SQL.

A rectangle is not one thing. It is the whole set of them. One rectangle marked BOOK stands for every book in the library.

An ellipse is not a column. Multivalued and composite attributes do not become single columns at all; what happens to them is [Practical 8: Turning the ER Model Into Tables].

What beginners get wrong

Drawing one rectangle per entity instead of per entity set.

Making everything an entity set. A price has no properties of its own and nothing else refers to it, so it is an attribute.

Making everything an attribute. Then the same author's country is written beside every one of their books, and two of them can disagree.

Storing a derived value. Age instead of date of birth is wrong by tomorrow.

Choosing a primary key that can change. An email or a phone number is a poor primary key for that reason.

Hanging a relationship's attribute off an entity set. issued_on on BOOK cannot work, because a book is borrowed more than once.

Quick revision

• ER diagram: rectangle is an entity set, ellipse an attribute, diamond a relationship set, underline the key.
• Entity is one thing; entity set is all of them.
• Attributes: simple, composite, single valued, multivalued, derived, key.
• Derived attributes are not stored; a dashed ellipse marks them.
• Super key has spares; candidate key has none; primary key is the chosen candidate; the rest are alternate keys.
• A primary key should be short, unchanging and never unknown.
• Nouns become entity sets or attributes; verbs become relationships.
• An attribute needing two entities named belongs to the relationship between them.

What goes in your journal

Aim, the problem statement as you were given it, the four steps with your own noun and verb tables, the list of entity sets with their attributes and their keys underlined, and the diagram drawn with a ruler. Write one line under the diagram justifying one decision, such as why AUTHOR is an entity set and not an attribute. That single line is what a viva asks about.

Test yourself

1. What is the difference between an entity and an entity set? An entity is one particular thing; an entity set is the whole collection of things of that kind. The rectangle stands for the set.

2. What shape is used for a relationship, and what for an attribute? A diamond for a relationship set, an ellipse for an attribute.

3. Distinguish a super key, a candidate key and a primary key. A super key identifies a row uniquely but may contain spare attributes. A candidate key is a super key with nothing spare. The primary key is the candidate key chosen for use; the others become alternate keys.

4. Why is age a derived attribute? Because it can be worked out from the date of birth. Storing it would make it wrong as soon as the person's birthday passes.

5. Where do issued_on and returned_on belong, and why? To the borrows relationship, because they mean nothing until both a member and a book are named, and one book is borrowed many times.

6. When should a noun be made an entity set rather than an attribute? When it has properties of its own, when there can be several of it for one owner, or when putting it inside another entity set would repeat it and let two copies disagree.

borrows, between MEMBER and BOOK.

• For one member, how many books? Many, over time.
• For one book, how many members? Many, over time, though only one at a time.
• So it is M:N.

Notice what decided the second one: the phrase over time. If the question had been "how many members hold this book right now", the answer would be one and the relationship would be 1:N. A cardinality is only meaningful once you have said at what moment you are counting, and saying so is worth a mark.

Participation: must every entity take part

Cardinality says how many. Participation says whether an entity may sit out.

In the library: every book must have an author, so BOOK's participation in writes is total and gets a double line. An author need not have written any book yet, so AUTHOR's participation is partial and gets a single line.

Total participation is also called an existence dependency, and it is what becomes a NOT NULL on a foreign key when the diagram is turned into tables.

Weak entity sets

Some things cannot be identified on their own.

A weak entity set has no key of its own. Its entities are identified only in combination with another entity set, called the owner or identifying entity set, and the relationship between them is the identifying relationship.

The library's example: if the library recorded each physical copy of a book as copy 1, copy 2, copy 3, then copy number 2 means nothing on its own, because every book has a copy 2. A copy is identified only as "copy 2 of book 1001". COPY is a weak entity set, book_id plus copy_no identifies it, and copy_no alone is its discriminator.

A weak entity set is always totally participating in its identifying relationship, because a copy cannot exist without a book.

What beginners get wrong

Putting the letters on the wrong lines. Cover one side and read the other.

Deciding a cardinality without saying at what moment. A book is borrowed by many members over time and by one at a time.

Confusing cardinality with participation. Cardinality is how many; participation is whether any at all. A relationship can be 1:N with total participation on both sides, or on neither.

Drawing an arrow the wrong way. Where arrows are used instead of letters, the arrow points at the side that has one. That is the opposite of many students' guess.

Calling a relationship with an attribute a weak entity set. A weak entity set has no key. A relationship with an attribute simply has an attribute.

Forgetting that a relationship may have attributes at all.

Quick revision

• Degree: binary joins two entity sets, ternary three, unary one to itself.
• Cardinality ratios: 1:1, 1:N and M:N.
• Two questions: for one on the left how many on the right, and for one on the right how many on the left.
• The letter sits beside the entity set it counts.
• Participation: total is a double line and means every entity must take part; partial is a single line.
• Weak entity set: no key of its own, double rectangle, identifying relationship a double diamond, discriminator dashed underlined, participation always total.
• A cardinality is only meaningful once the moment of counting is stated.

What goes in your journal

Aim, the list of relationships you found, and for each of them the two questions written out with their answers and the ratio that follows. The two questions are the working, and a journal that shows only the final letters has left out what the practical is teaching. Then the diagram with every line labelled and every total participation drawn double.

Test yourself

1. What are the three cardinality ratios? One to one, one to many and many to many, written 1:1, 1:N and M:N.

2. Which two questions decide the ratio? For one entity on the left, how many on the right, and for one entity on the right, how many on the left.

3. What is the difference between cardinality and participation? Cardinality says how many entities of one set may join to one of the other. Participation says whether an entity may take part in none at all.

4. How is total participation drawn, and what does it become in a table? A double line, and it becomes a NOT NULL on the foreign key.

5. What is a weak entity set, and how is it identified? An entity set with no key of its own. It is identified by its owner's key together with its own discriminator, and it is drawn as a double rectangle joined by a double diamond.

6. Is the relationship between a member and a book one to many or many to many? Many to many over time, because a member borrows many books and a book is borrowed by many members. It is one to many only if the question is about who holds it at this moment.

Total or partial. Must every entity of the superclass belong to some subclass?

• Total: yes, drawn with a double line into the triangle. Every member is either a student or staff, and there is no third kind.
• Partial: no, a single line. There may be members who are neither, such as an alumnus.

The two constraints are independent, so there are four combinations, and a complete answer names one from each pair: "disjoint and total", "overlapping and partial", and so on.

Aggregation, the other thing the triangle is confused with

Aggregation treats a whole relationship as though it were an entity set, so that another relationship can be attached to it. It is drawn as a box round the diamond and the two rectangles it joins.

The library's example: a member borrows a book, and the library wants to record which member of staff approved a particular borrowing. approved_by connects a member of staff to the borrowing, not to the member and not to the book separately, so the borrows relationship is boxed and the new diamond is attached to the box.

It is not generalization and it is not a weak entity set. Examiners ask students to tell the three apart, and the answer is:

Where this goes next

A superclass and its subclasses can be turned into tables in three ways, and choosing between them is part of [Practical 8: Turning the ER Model Into Tables]:

One table per entity set. MEMBER, STUDENT and STAFF, with the subclass tables holding the key and their own attributes only. This is the general answer and works for every combination of constraints.

One table per subclass only. STUDENT and STAFF each hold all the inherited attributes as well. This works only when the specialization is total and disjoint; otherwise an entity belonging to no subclass has nowhere to live.

One table for everything. A single MEMBER table with course and department both in it, and one of them null for each row, plus a column saying which kind it is. Simple, and it fills the table with nulls.

What beginners get wrong

Looking for a difference between the two diagrams. There is none. The difference is in how you got there.

Repeating the inherited attributes beside the subclasses. They are inherited; drawing them again is a mistake, not extra detail.

Confusing disjoint with total. Disjoint is about belonging to two subclasses at once; total is about belonging to none.

Using an ISA triangle for a relationship. A student is a member; a member borrows a book. The first is ISA, the second is a diamond. "Is a" against "does something to" is the test.

Specialising on a value that changes every day. If the subclass a row belongs to changes often, a column holding the kind is simpler than two tables.

Quick revision

• Generalization is bottom up: pull shared attributes into a new superclass.
• Specialization is top down: split a superclass into subclasses.
• The diagram is the same for both: an ISA triangle.
• Subclasses inherit every attribute and every relationship of the superclass.
• Disjoint means an entity is in at most one subclass; overlapping means it may be in several.
• Total means every superclass entity is in some subclass; partial means it need not be.
• Aggregation boxes a relationship so another relationship can attach to it.
• Three ways to make tables from it: one per entity set, one per subclass, or one for everything.

What goes in your journal

Aim, the two subclasses with the attributes they share listed separately from the attributes that are their own, the diagram with the ISA triangle, and a line naming both constraints, such as "disjoint and total". In the conclusion write the one sentence distinguishing generalization from specialization, because that sentence is the viva question for this half of the practical.

Test yourself

1. What is the difference between generalization and specialization? The direction of thinking. Generalization starts with specific entity sets and pulls out what they share into a new superclass. Specialization starts with one general entity set and divides it. The resulting diagram is the same.

2. What does the ISA triangle mean? That each subclass is a kind of the superclass: a student is a member.

3. What does a subclass inherit? Every attribute of its superclass and every relationship the superclass takes part in.

4. What is the difference between a disjoint and an overlapping specialization? Disjoint means an entity may belong to at most one subclass. Overlapping means it may belong to more than one at the same time.

5. What does total specialization mean? That every entity of the superclass must belong to at least one subclass. It is drawn with a double line into the triangle.

6. How is aggregation different from generalization? Aggregation treats a whole relationship as an entity set so that another relationship can be joined to it, and is drawn as a box. Generalization arranges entity sets into a kind-of hierarchy with a triangle.

SHOW CREATE DATABASE librarydb; prints the same two facts as one long line, in the form of the statement that would recreate the database. It is the quicker thing to type and the harder thing to read.

To choose them yourself rather than take what you are given:

CREATE DATABASE librarydb
  CHARACTER SET utf8mb4
  COLLATE utf8mb4_0900_ai_ci;

Selecting it, and confirming which one you are in

USE librarydb;
SELECT DATABASE() AS now_using;

+-----------+
| now_using |
+-----------+
| librarydb |
+-----------+

USE is one of the few statements the interactive client accepts without a semicolon. Write the semicolon anyway, so that the same line also works inside a script. SELECT DATABASE() is the question "where am I", and it is the first thing to type when a statement says a table does not exist.

Viewing all the tables in it

SHOW TABLES;

Nothing, because the database is new. Once tables exist, the same statement lists them, and [Practical 2: Creating a Table, and Choosing Its Data Types] makes some.

You can look inside another database without leaving this one:

SHOW TABLES FROM othername;

And you can narrow the list exactly as with databases:

SHOW TABLES LIKE 'b%';

The same question asked of information_schema

Everything SHOW tells you is also stored as ordinary rows in information_schema, and it can be queried like any table.

SELECT schema_name AS found
FROM information_schema.schemata
WHERE schema_name = 'librarydb';

+-----------+
| found     |
+-----------+
| librarydb |
+-----------+

That matters for two reasons. It is how a program asks the question, because a program can put a WHERE on a query and cannot put one on SHOW. And it is a fair viva question: SHOW is a convenience for a person; information_schema is the same information as data.

Removing a database

DROP DATABASE librarydb;

There is no confirmation and no undo. Every table and every row in it is gone. On a shared college server, check twice which database you are naming, and never type it with a wildcard or from memory. DROP DATABASE IF EXISTS name; is the form that does not complain when there is nothing to drop.

The statements in this practical

What beginners get wrong

Expecting CREATE DATABASE to select the database. It does not; USE does.

Running SHOW TABLES with no database selected. The server answers ERROR 1046 (3D000): No database selected.

Being surprised that a second CREATE DATABASE fails. Use IF NOT EXISTS when you do not care.

Typing DROP DATABASE on a shared server without checking the name.

Assuming table names behave the same everywhere. On Linux they are case sensitive; on Windows they are not, so a query that works in the laboratory may fail at home.

Treating information_schema, mysql, performance_schema or sys as spare space. They belong to the server.

Quick revision

• SHOW DATABASES; lists them; four system databases are always there.
• CREATE DATABASE name; makes one, and IF NOT EXISTS stops the error on a second run.
• SHOW CREATE DATABASE name; shows the character set and collation it was given.
• utf8mb4 holds every Unicode character; the collation ending ai_ci compares without regard to accents or case.
• USE name; selects; SELECT DATABASE(); asks which is selected.
• SHOW TABLES; lists the current database's tables; SHOW TABLES FROM other; lists another's.
• information_schema holds the same information as queryable rows.
• DROP DATABASE has no undo.

What goes in your journal

Aim, every statement with the server's reply written underneath it exactly as it appeared, including the error from the second CREATE DATABASE. That error is the evidence that you tried it rather than copied it, and an examiner notices.

Test yourself

1. Which four databases exist on every MySQL server? information_schema, mysql, performance_schema and sys.

2. What does CREATE DATABASE print when it succeeds? Nothing. Silence after a statement that changes something means it worked.

3. What is the difference between CREATE DATABASE x; and CREATE DATABASE IF NOT EXISTS x;? The first is an error if x already exists. The second does nothing and carries on.

4. What is a collation? The set of rules for comparing and sorting the characters of a character set. A collation ending ai_ci ignores accents and case, so Mumbai and mumbai compare equal.

5. How do you list the tables of a database you are not currently in? SHOW TABLES FROM thatdatabase;

6. Why would a program query information_schema instead of using SHOW? Because information_schema holds the same information as ordinary rows, so a query can filter, join and sort it. SHOW cannot take a WHERE.

Dates and times

The format is YYYY-MM-DD, always, whatever your country writes on paper. '21-07-2025' is not a date to MySQL, and the effort of writing them her way is repaid the moment you want the difference between two of them in [Practical 5: Date Functions].

The tables, created

CREATE TABLE author (
    author_id    INT,
    author_name  VARCHAR(18),
    country      VARCHAR(10)
);

CREATE TABLE book (
    book_id    INT,
    title      VARCHAR(20),
    subject    VARCHAR(12),
    price      DECIMAL(7,2),
    added_on   DATE,
    author_id  INT
);

Nothing printed, so both were created. Not one constraint anywhere: any column may be left empty, two books may have the same book_id, and author_id may hold 999 when no such author exists. That is what "without constraints" means, and it is why the next chapter exists.

Looking at what was made

DESCRIBE book;

+-----------+--------------+------+-----+---------+-------+
| Field     | Type         | Null | Key | Default | Extra |
+-----------+--------------+------+-----+---------+-------+
| book_id   | int          | YES  |     | NULL    |       |
| title     | varchar(20)  | YES  |     | NULL    |       |
| subject   | varchar(12)  | YES  |     | NULL    |       |
| price     | decimal(7,2) | YES  |     | NULL    |       |
| added_on  | date         | YES  |     | NULL    |       |
| author_id | int          | YES  |     | NULL    |       |
+-----------+--------------+------+-----+---------+-------+

DESCRIBE, which may be shortened to DESC, lists the columns with their types. Read the six columns of its answer:

Four of those six are about constraints, and all four are empty or permissive in this table. Come back to this output after the next chapter and every one of them will have something in it.

SHOW TABLES;

It printed the two names under a heading reading Tables_in_librarydb, which is why the heading is not reproduced here: it carries whatever your database is called. The same list, asked for as ordinary data, is:

SELECT table_name AS tables_here
FROM information_schema.tables
WHERE table_schema = DATABASE()
ORDER BY table_name;

+-------------+
| tables_here |
+-------------+
| author      |
| book        |
+-------------+

Two tables, where [Practical 2: Viewing Databases, Creating One and Listing Its Tables] found none.

The types the server really gave the columns

SELECT column_name AS col, data_type AS type,
       character_maximum_length AS max_len, is_nullable AS nullable
FROM information_schema.columns
WHERE table_name = 'book' AND table_schema = DATABASE()
ORDER BY ordinal_position;

+-----------+---------+---------+----------+
| col       | type    | max_len | nullable |
+-----------+---------+---------+----------+
| book_id   | int     |    NULL | YES      |
| title     | varchar |      20 | YES      |
| subject   | varchar |      12 | YES      |
| price     | decimal |    NULL | YES      |
| added_on  | date    |    NULL | YES      |
| author_id | int     |    NULL | YES      |
+-----------+---------+---------+----------+

Every column is nullable, which is the default and which the next chapter changes.

What beginners get wrong

CHAR where VARCHAR belongs. Names and titles vary in length.

FLOAT for money. Use DECIMAL.

A date stored as VARCHAR. It then cannot be compared, subtracted or sorted properly, and '09-01-2025' sorts before '10-12-2024'.

Writing INT(11). The bracketed number was only a display width and is deprecated.

A comma after the last column. The server answers with a syntax error pointing at the closing bracket.

Making every text column VARCHAR(255) without thinking. It works, and it means the table no longer documents what it holds.

Using a keyword as a column name, such as order or desc. It has to be written in backticks everywhere afterwards; choose a different name.

Quick revision

• CREATE TABLE name (column type, column type, ...); with no comma after the last.
• Whole numbers: TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT, and UNSIGNED to move the range.
• Exact fractions: DECIMAL(p, s). Money always.
• Approximate: FLOAT and DOUBLE, never for money.
• CHAR(n) is fixed length and padded; VARCHAR(n) is up to n and is not.
• Dates are YYYY-MM-DD, always.
• DESCRIBE table; lists the columns, their types, and whether each may be null.
• Without constraints, every column may be empty and every value may repeat.

What goes in your journal

Aim, a table of the columns you chose with the type of each and one line saying why, then the CREATE TABLE statements, then the DESCRIBE output. The column of reasons is what is being marked: an examiner wants to see that price is DECIMAL because it is money and title is VARCHAR because titles vary in length.

Test yourself

1. What is the difference between CHAR(10) and VARCHAR(10)? CHAR(10) always occupies ten characters and pads short values with spaces. VARCHAR(10) occupies only what the value needs, up to ten, plus a byte for the length.

2. Which type should a price use, and why not FLOAT? DECIMAL, because it stores digits exactly. FLOAT stores an approximation in binary, so sums of money can come out a paisa wrong.

3. In what format must a DATE literal be written? 'YYYY-MM-DD', for example '2025-07-21'.

4. What does DESCRIBE book; tell you? The name and type of every column, whether it may be null, what key it takes part in, its default value, and anything extra such as auto increment.

5. What does INT(11) mean? Only a display width, never a limit on the value. It is deprecated; write INT.

6. What can go wrong in a table created with no constraints? Any column may be left empty, values that should be unique may repeat, and a column that should refer to another table may hold a value that is not there.

INSERT INTO book (book_id, title, subject, price, author_id)
VALUES (1, 'Another Book', 'Programming', 250.00, 1);

ERROR 1062 (23000): Duplicate entry '1' for key 'book.PRIMARY'

Error 1062, and it names the value it refused, 1, and the key it broke, PRIMARY.

UNIQUE

UNIQUE refuses a duplicate but permits NULL, and permits more than one NULL, because two unknown values are not known to be the same.

INSERT INTO author (author_name, email)
VALUES ('Another Writer', 'dmr@example.com');

ERROR 1062 (23000): Duplicate entry 'dmr@example.com' for key 'author.email'

The same error number as a duplicate primary key, 1062, but the key it names is email rather than PRIMARY. Read the key name in a 1062: it tells you which rule you broke.

DEFAULT

DEFAULT supplies a value when the statement does not.

INSERT INTO author (author_name, email) VALUES ('New Writer', 'nw@example.com');

SELECT author_name, country FROM author WHERE author_name = 'New Writer';

+-------------+---------+
| author_name | country |
+-------------+---------+
| New Writer  | India   |
+-------------+---------+

country was never mentioned and came out as India, because that is what the column's DEFAULT says.

DEFAULT (CURRENT_DATE) on book.added_on does the same with today's date, which is why this book cannot print that particular result: it would be different tomorrow. A default that is an expression rather than a constant goes in round brackets, which MySQL has allowed since 8.0.13.

CHECK

CHECK refuses any row for which its condition is false.

INSERT INTO book (title, subject, price, author_id)
VALUES ('Free Book', 'Programming', -50.00, 1);

ERROR 3819 (HY000): Check constraint 'book_chk_1' is violated.

Error 3819, and it names the constraint. MySQL invented the name book_chk_1 because none was given; naming it yourself makes the error readable:

price DECIMAL(7,2) CONSTRAINT price_must_be_positive CHECK (price > 0)

A version warning that matters in a college laboratory. CHECK was accepted and silently ignored by MySQL until 8.0.16. On an older server the row above is inserted with a price of minus 50 and nothing is said. If your laboratory's server is older than that, the constraint has to be written as a trigger or enforced in the program, and saying so in your journal is worth more than pretending it worked.

FOREIGN KEY

A FOREIGN KEY says that a value in this column must exist as a primary key in another table. It is what stops a book pointing at an author who does not exist, and it is the constraint that makes a database more than a heap of tables.

INSERT INTO book (title, subject, price, author_id)
VALUES ('Orphan Book', 'Databases', 300.00, 99);

ERROR 1452 (23000): Cannot add or update a child row: a foreign key constraint fails (`librarydb`.`book`, CONSTRAINT `book_ibfk_1` FOREIGN KEY (`author_id`) REFERENCES `author` (`author_id`))

Error 1452. There is no author 99, so there can be no book by author 99.

It works in the other direction too. An author who has books cannot be deleted, because that would leave those books pointing at nothing:

DELETE FROM author WHERE author_id = 1;

ERROR 1451 (23000): Cannot delete or update a parent row: a foreign key constraint fails (`librarydb`.`book`, CONSTRAINT `book_ibfk_1` FOREIGN KEY (`author_id`) REFERENCES `author` (`author_id`))

Error 1451, the other half of the same rule. Notice that the two errors are different numbers: 1452 is a child row with no parent, 1451 is a parent row with children.

The technical name for what these two errors protect is referential integrity: every foreign key value either is NULL or matches an existing primary key.

What to do instead of refusing

You can tell the server what should happen to the children when a parent goes:

ON UPDATE takes the same three, for when the parent's key value changes.

Choose deliberately. CASCADE on a library's authors would delete every book by an author you removed, which is almost certainly not what a librarian wants; SET NULL leaves the books and forgets who wrote them, which may be exactly right.

AUTO_INCREMENT

AUTO_INCREMENT fills a column with the next number when none is given. A table may have one such column and it must be a key.

INSERT INTO author (author_name, email) VALUES ('Fourth Writer', 'f@example.com');

SELECT author_id, author_name FROM author ORDER BY author_id;

+-----------+----------------+
| author_id | author_name    |
+-----------+----------------+
|         1 | Dennis Ritchie |
|         2 | Vikram Vaswani |
|         4 | New Writer     |
|         5 | Fourth Writer  |
+-----------+----------------+

Nobody supplied any author_id after the first two, and the numbers went on by themselves.

Now look for 3. There is no author 3, and no author was ever deleted. The number was used up by the insert that broke the UNIQUE on email earlier in this chapter: MySQL allotted the next value before it checked the constraint, the row was refused, and the number went with it.

That is the first of two facts about AUTO_INCREMENT that are asked and that surprise people. The numbers are not reused. A failed insert, a rolled back transaction or a deleted row leaves a gap, and the counter never goes back, because a number that has been handed out may already have been written down somewhere else.

And the numbers are not a count. The largest id is 5 and there are four authors. Never answer "how many rows are there" by looking at the last id; ask COUNT(*), which is [Practical 4: Aggregate Functions, GROUP BY and HAVING].

Adding a constraint to a table that already exists

Constraints do not have to be decided at creation.

ALTER TABLE book ADD CONSTRAINT price_positive CHECK (price > 0);
ALTER TABLE book DROP CHECK price_positive;

That is [Practical 3: Altering a Table That Already Holds Data], and it is why naming a constraint when you create it is worth the extra words: an unnamed one is book_chk_1, and dropping it means looking that name up first.

The error numbers, collected

Write that table into your journal. Every one of the five appears in this chapter's output, and being able to say what a number means is exactly the kind of thing a viva asks.

What beginners get wrong

Thinking NULL is zero or an empty string. It is the absence of a value.

Expecting UNIQUE to refuse NULLs. It does not, and it allows several of them.

Declaring two PRIMARY KEY columns separately. A table has one primary key; if it must be made of two columns, declare it once as PRIMARY KEY (a, b).

Relying on CHECK on a server older than 8.0.16. It is accepted and ignored there.

Creating the child table before the parent. The REFERENCES has nothing to point at and the statement fails.

A foreign key whose type does not match the key it references. INT must reference INT, and an UNSIGNED mismatch is refused too.

Assuming AUTO_INCREMENT values are consecutive. They are unique, not gapless.

Quick revision

• A constraint is enforced by the server, so no program can bypass it.
• NOT NULL: the column must have a value. Error 1048.
• PRIMARY KEY: unique and not null, one per table. Error 1062.
• UNIQUE: no duplicates, but NULLs are allowed and may repeat. Error 1062, naming the column.
• DEFAULT: supplies a value when none is given; an expression goes in brackets.
• CHECK: refuses rows where the condition is false. Error 3819. Ignored before MySQL 8.0.16.
• FOREIGN KEY: the value must exist in the referenced table. Error 1452 inserting, 1451 deleting the parent.
• ON DELETE CASCADE or SET NULL change what happens to the children.
• AUTO_INCREMENT fills in the next number, never reuses one, and needs a key column.

What goes in your journal

Aim, the two CREATE TABLE statements with every constraint, and then one failed statement per constraint with the server's error copied exactly, error number and all. This is the practical where the failures are the answer. A journal showing only successful inserts has demonstrated that the tables exist, not that the constraints work.

Test yourself

1. What two rules does a PRIMARY KEY enforce? The value must be unique, and it may not be NULL.

2. How does UNIQUE differ from PRIMARY KEY? UNIQUE allows NULL, and allows more than one NULL. A table may have many UNIQUE columns and only one primary key.

3. What is referential integrity? The rule that every foreign key value either is NULL or matches an existing primary key in the referenced table, so no row can point at something that does not exist.

4. What happens when you delete an author who has books, and how could that be changed? The delete is refused with error 1451. Declaring the foreign key ON DELETE CASCADE would delete the books too, and ON DELETE SET NULL would leave them with a NULL author.

5. On which versions of MySQL is CHECK enforced? From 8.0.16 onward. Before that it was parsed and ignored.

6. An insert was refused by a constraint. What happens to the AUTO_INCREMENT number it was allotted? It is lost, and the next successful insert takes the following number. The counter never goes back, so gaps are normal and mean nothing is wrong.

7. Why enforce a rule with a constraint rather than in the program? Because the constraint travels with the data and cannot be bypassed by another program, or by somebody typing a statement at the prompt.

+---------+----------------+--------+
| book_id | title          | price  |
+---------+----------------+--------+
|       1 | The C Language | 425.00 |
+---------+----------------+--------+

Several columns at once, separated by commas:

UPDATE member
SET city = 'Dombivli', course = 'BSc IT'
WHERE member_id = 5;

SELECT member_id, member_name, course, city FROM member WHERE member_id = 5;

+-----------+-------------+--------+----------+
| member_id | member_name | course | city     |
+-----------+-------------+--------+----------+
|         5 | Neha Patil  | BSc IT | Dombivli |
+-----------+-------------+--------+----------+

The new value may be worked out from the old one, which is how a percentage rise is applied:

UPDATE book SET price = price * 1.10 WHERE subject = 'Databases';

SELECT book_id, title, price FROM book WHERE subject = 'Databases';

+---------+------------------+--------+
| book_id | title            | price  |
+---------+------------------+--------+
|       2 | Database Systems | 792.55 |
|       3 | MySQL Reference  | 548.90 |
|       6 | Learn SQL        | 308.00 |
+---------+------------------+--------+

price = price * 1.10 reads oddly to a programmer and is ordinary in SQL: on the right of the = the column means its current value, and on the left it means where the new value goes. It is applied to every row the WHERE matches, each using its own old price.

The mistake this chapter exists to prevent

CREATE TABLE book_copy AS SELECT * FROM book;

CREATE TABLE ... AS SELECT makes a table with the same columns and the same rows. Now the damage can be done where it does not matter:

UPDATE book_copy SET price = 100.00;

SELECT book_id, title, price FROM book_copy ORDER BY book_id;

+---------+-------------------+--------+
| book_id | title             | price  |
+---------+-------------------+--------+
|       1 | The C Language    | 100.00 |
|       2 | Database Systems  | 100.00 |
|       3 | MySQL Reference   | 100.00 |
|       4 | Data Structures   | 100.00 |
|       5 | Computer Networks | 100.00 |
|       6 | Learn SQL         | 100.00 |
|       7 | Operating Systems | 100.00 |
|       8 | Discrete Maths    | 100.00 |
+---------+-------------------+--------+

Every book now costs 100. There was no WHERE, so every row matched, and MySQL did exactly as it was told without a question or a warning.

There is no undo for that outside a transaction. [Practical 10: COMMIT and ROLLBACK] is the chapter that gives you one, and it is the reason transactions exist.

Three habits, and they cost nothing:

Write the WHERE first. Type WHERE book_id = 1 before you type the SET.

Run it as a SELECT first. SELECT * FROM book WHERE ... with the same condition shows you exactly which rows are about to change. If it returns forty rows and you expected one, you have just saved yourself.

On a real database, START TRANSACTION first. Then a wrong answer is one ROLLBACK away.