From problem
to C program.

LESSON 01

Think before you write code.

A computer follows instructions precisely. Problem solving means turning a requirement into a sequence of unambiguous operations, then checking that the result is correct. Code is the final expression of that plan.

What makes a good algorithm?

An algorithm is a finite sequence of clearly defined steps for solving a problem. It may take zero or more inputs and must produce a result. Its operations must be definite, feasible to carry out, and terminate for valid inputs. A program implements an algorithm in a programming language.

A dry run executes the steps by hand, recording variable values. It checks your reasoning before you rely on a compiler. A compiler can reject invalid syntax; it cannot guarantee that your algorithm solves the intended problem.

LESSON 02

Make the logic visible.

A flowchart represents an algorithm with connected symbols. Follow arrows in the direction of execution, and label the outcomes of a decision. The chart and algorithm should describe the same computation.

Drawing rules

• Use a clear entry and explicit exit; place the main path from top to bottom where practical.
• Write a short action inside each symbol. Put calculations in process boxes, not decision diamonds.
• Give every decision its possible outgoing paths. Make repetition return to a condition that can eventually become false.
• Use connectors to avoid confusing crossings. Dry-run the finished chart with sample inputs.

#include <stdio.h>
#define PI 3.141592653589793

int main(void)
{
    double radius, area;
    /* STDIN: enter one non-negative radius, for example 3. */
    if (scanf("%lf", &radius) != 1 || radius < 0) {
        printf("Enter a non-negative radius.\n");
        return 1;
    }
    area = PI * radius * radius;
    printf("Area = %.2f\n", area);
    return 0;
}

#include <stdio.h>

int main(void)
{
    double a, b, c, largest;
    /* STDIN: three numbers separated by spaces. */
    if (scanf("%lf %lf %lf", &a, &b, &c) != 3) {
        printf("Enter three numbers.\n");
        return 1;
    }
    largest = a;
    if (b > largest) {
        largest = b;
    }
    if (c > largest) {
        largest = c;
    }
    printf("Largest = %.2f\n", largest);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int n, i;
    double number, sum = 0;
    /* STDIN: count N (1 to 100), followed by N numbers. */
    if (scanf("%d", &n) != 1 || n < 1 || n > 100) {
        printf("Enter a count from 1 to 100.\n");
        return 1;
    }
    for (i = 1; i <= n; i++) {
        if (scanf("%lf", &number) != 1) {
            printf("A number is missing or invalid.\n");
            return 1;
        }
        sum = sum + number;
    }
    printf("Sum = %.2f\n", sum);
    return 0;
}

The C examples preview if and for so that you can see your algorithms become programs. Selection and repetition are studied in more detail in the later units.

LESSON 03

Meet C.

C is a general-purpose, procedural programming language. Dennis Ritchie developed it at Bell Labs in the early 1970s as Unix was evolving. Its roots run through BCPL and B. The name C followed B; it is not an abbreviation.

Features and what they mean

The informal term “middle-level language” describes C’s mix of high-level control structures and low-level operations; it is not a formal standards category. C is case-sensitive: total and Total are different identifiers.

LESSON 04

Read your first C program.

A textbook often divides a program into documentation, header inclusion, symbolic definitions, global declarations, the main function and other functions. These are useful organizational sections, not a requirement to fill every section in every program.

#include <stdio.h>

int main(void)
{
    printf("Hello, BCA!\n");
    return 0;
}

Create, compile, execute

1. Use a plain-text editor to save the source with a .c extension.
2. The preprocessor handles directives such as #include and #define.
3. The compiler translates the source and diagnoses problems. The assembler produces object code in a typical native toolchain.
4. The linker combines object code and needed library code into an executable.
5. Run the executable, supply any input, and inspect the output.

gcc -std=c90 -Wall -Wextra main.c -o main
# Linux / macOS: ./main
# Windows terminal: .\main.exe

Three kinds of failure

LESSON 05

Characters become tokens.

The basic source character set includes letters A–Z and a–z, digits 0–9, whitespace and punctuation such as + - * / = ; , ( ) { } [ ] #. Letters form names; digits form numbers; symbols express operations and structure. A token is a lexical unit recognized from the source.

For introductory study, group tokens as keywords, identifiers, constants, string literals, operators and punctuators (special symbols). Formally, C groups operators such as + with punctuators. Whitespace and comments help separate source text but are not ordinary program tokens.

Keywords

A keyword has a reserved meaning and cannot be used as an ordinary variable name. ANSI C / C90 has the following 32 keywords. Later C editions add more.

Identifiers

An identifier names an object, function or other program entity. A simple identifier starts with a letter or underscore, followed by letters, digits or underscores. Keywords cannot be identifiers. For your own names, begin with a letter and avoid leading underscores because many underscore forms are reserved.

Constants and strings

Useful escape sequences

\n means newline, \t horizontal tab, \\ a backslash, and \" a double quote inside a string. For example, printf("Name\tMarks\n"); prints two headings separated by a tab and then starts a new line.

LESSON 06

Choose a type, then a name.

A data type determines the values an object can represent and the operations that apply. A declaration introduces the name and type; a definition reserves storage; initialization supplies an initial value as the object is created. Most simple local declarations below are also definitions.

short and long modify integer types; signed and unsigned select signedness where allowed. long double is another floating type. Do not assume int is always two or four bytes: exact sizes and ranges depend on the implementation. Use sizeof to inspect object sizes, and limits.h / float.h for limits. In later study, you will meet derived types such as arrays and pointers and user-defined structures, unions and enumerations.

#include <stdio.h>

int main(void)
{
    int count = 4;
    float price = 12.5f;
    char grade = 'A';
    double radius = 3.25;
    printf("Count = %d\n", count);
    printf("Price = %.2f\n", price);
    printf("Grade = %c\n", grade);
    printf("Radius = %.2f\n", radius);
    return 0;
}

Declaration, initialization and assignment

int count;           /* declaration and definition */
count = 4;           /* assignment after creation */
double rate = 2.5;   /* definition with initialization */
int x = 0, y = 0;    /* initialize each variable */

An uninitialized automatic local variable has an indeterminate value; do not read it before setting it. Objects with static storage duration are zero-initialized if no initializer is supplied. In int x, y = 0;, only y is explicitly initialized.

Match input and output formats

The input example scanf("%lf", &radius) passes the address of radius so scanf can store the value. Check scanf’s return value: 1 means one successful conversion here. %.2f in printf displays two digits after the decimal point; it does not change the stored value.

Symbolic constants

#define PI 3.141592653589793
const int MAX_STUDENTS = 60;

A #define object-like macro gives a name to replacement text before compilation. It has no declared type or trailing semicolon. A const-qualified object has a type and cannot be modified through that declaration. They are related tools, but are not interchangeable in every C context. Parenthesize compound macro replacements, for example #define LIMIT (10 + 5).

LESSON 07

Know your library headers.

A header supplies declarations, types or macros that your program needs. Standard headers are included with angle brackets, such as #include <stdio.h>. Including a header does not paste the compiled library implementation into your executable; linking resolves needed library definitions.

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

int main(void)
{
    char word[] = "BCA";
    char letter = 'b';
    double value = 9.0;
    printf("Word length = %lu\n", (unsigned long)strlen(word));
    printf("Uppercase = %c\n", toupper((unsigned char)letter));
    printf("Square root = %.1f\n", sqrt(value));
    return 0;
}

LESSON 08

Edit it. Run it. Understand it.

Choose an example, load it into the embedded C compiler, then change the code and run it. Inside the compiler, select I/O before pressing Run. The sample STDIN is loaded with each example; change it to test your own inputs.

No input needed.

Hello, BCA!

#include <stdio.h>

int main(void)
{
    printf("Hello, BCA!\n");
    return 0;
}

Try these experiments

• Circle: try radius 0, 3.5 and −1. Explain each result.
• Largest: try −8 −2 −11 and 7 7 7. Why does initializing largest to zero fail for an all-negative input?
• Sum: try 4 followed by 1.5 −2 3 0. The expected sum is 2.50.
• Hello: remove the semicolon after printf. Run it, read the compiler diagnostic, then repair the code.
• Types: change the displayed precision from %.2f to %.1f. Compare display rounding with the stored value.

CHECK YOUR UNDERSTANDING

Finish with a self-check.

Written exam practice

1. Define an algorithm. Explain its characteristics and distinguish it from a program.
2. Draw the standard flowchart symbols and explain their purposes.
3. Write an algorithm and draw a flowchart for circle area, largest of three numbers, and summing N values.
4. Describe the history and features of C, and explain the sections of a simple C program.
5. Explain the translation steps from source file to executable and distinguish compile-time, runtime and logic errors.
6. Define a token. Explain keywords, identifiers, constants, variables and string literals with examples.
7. Explain declaration, initialization, symbolic constants and the basic data types.
8. State the uses of stdio.h, conio.h, math.h, string.h and ctype.h, and identify the portability issue.