C++ Programming Fundamentals: Complete Chapter 3 Notes for Exam

3.1 Structure of C++ Programs

Hello there! Welcome to Chapter 3. Now that we have learned about algorithms and data structures, it is time to get our hands dirty with actual C++ programming. I know you might be a little nervous, but trust me — by the end of this chapter, you will feel much more confident. Let us start from the very beginning: what does a C++ program look like?

Every C++ program has a specific structure. Think of it like building a house — you need a foundation, walls, and a roof. In C++, the structure is made up of several parts that work together. Let me walk you through each part one by one.

The Basic Structure of a C++ Program

Here is a simple C++ program. Do not worry if you do not understand every line yet. We will break it down completely.

#include <iostream>
using namespace std;

int main()
{
    cout << "Hello, World!" << endl;
    return 0;
}

Now, let me explain each part of this program step by step. This is very important for your exam, so pay close attention!

1. The #include Directive (Header Files)

The very first line #include <iostream> is called a preprocessor directive. What does that mean? Well, before your C++ code is actually compiled, a program called the preprocessor runs first. It looks for lines that start with # and handles them.

The word include tells the preprocessor: “Go find the file called iostream and bring all its content right here, at the top of my program.” The iostream file stands for Input Output Stream. It contains the definitions we need to use cout (for output) and cin (for input). Without this line, the compiler would not know what cout means!

2. The using namespace std; Line

This line tells the compiler that we are using the standard namespace. But wait — what is a namespace? Think of a namespace as a container for names. The C++ standard library puts many things (like cout, cin, endl) inside a namespace called std.

If we did NOT write this line, we would have to write std::cout instead of just cout every single time. That gets very tedious! So this line saves us typing. It is like saying: “Hey compiler, whenever I say cout, I mean std::cout.”

3. The main() Function

int main() is the heart of every C++ program. Every C++ program MUST have a main() function. This is where the execution begins. When you run your program, the computer looks for main() and starts executing code from the first line inside it.

The word int before main() means this function returns an integer value. The return 0; at the end sends 0 back to the operating system, which means “the program ended successfully.” If you return a non-zero value, it typically signals an error.

Quick question for you: Can a C++ program have two main() functions? Think about it… No! There can only be ONE main() function. The compiler would get confused otherwise.

4. The Curly Braces { }

The opening brace { marks the beginning of the function body, and the closing brace } marks the end. Everything between these braces is part of the main() function. This is a rule in C++ — every function must have its body enclosed in braces.

5. The Statement cout << "Hello, World!" << endl;

This is the actual instruction that prints text on the screen. Let us break it down:

• cout — pronounced “see-out” — is the standard output object. It sends data to the screen.
• << — this is the insertion operator. Think of it as an arrow pointing left, pushing data toward cout.
• "Hello, World!" — this is a string literal. The text inside double quotes gets printed exactly as written.
• endl — this stands for end line. It moves the cursor to the next line (like pressing Enter).
• ; — the semicolon marks the END of a statement. Every C++ statement MUST end with a semicolon. Forgetting it is the most common beginner mistake!

3.2 Compilation Process of C++

Great job so far! Now let me ask you something: You write C++ code in English-like text, but the computer only understands binary (0s and 1s). So how does your code actually become something the computer can run?

This is where the compilation process comes in. It is a multi-step process that transforms your human-readable source code into machine-executable code. Understanding this process is extremely important for exams. Let me walk you through each step carefully.

Step 1: Writing the Source Code

You write your C++ program in a text editor or IDE (like Code::Blocks, Dev-C++, or Visual Studio). The file is saved with a .cpp extension. This is your source code — it is in human-readable form.

Step 2: Preprocessing

The preprocessor is the first program that processes your code. It does NOT understand C++ syntax. Instead, it looks for lines starting with # and performs these tasks:

• Includes header files — replaces #include <iostream> with the actual content of the iostream file.
• Removes comments — all // and /* */ comments are stripped out because the compiler does not need them.
• Processes macros — handles #define directives (we will learn about this later).

After preprocessing, you get what is called expanded source code or translation unit.

Step 3: Compilation

Now the compiler takes the expanded source code and translates it into object code (also called machine code). The object code is in binary form, but it is not yet a complete program. It is saved with a .obj (Windows) or .o (Linux) extension.

During this step, the compiler checks your code for syntax errors. If it finds any, it stops and shows error messages. If there are no errors, it produces the object file.

Step 4: Linking

The linker is the final step. It takes your object file and links it with any library files that your program needs. For example, when you use cout, the actual implementation is in a library file. The linker connects your code to that library code.

The output of the linker is the executable file — a .exe file on Windows. This is the file you can actually run!

Step 5: Execution

When you run the executable, the operating system loads it into RAM and the CPU begins executing the instructions starting from main().

Important: What About Interpreters?

Remember from Chapter 1 that compilers translate the ENTIRE program before execution, while interpreters translate one line at a time. C++ uses a compiler, not an interpreter. This makes C++ programs faster at runtime, but the compilation step takes time. Languages like Python use interpreters.

3.3 Error Types in Programming

Alright class, let us talk about something every programmer deals with: errors. No matter how careful you are, you will make mistakes. That is completely normal! The key is understanding what type of error you made so you can fix it quickly. For your exam, you must know the three main types of errors.

1. Syntax Errors

Syntax errors are like grammar mistakes in English. Just like a sentence must follow grammar rules, your C++ code must follow the syntax rules of the language. The compiler catches these errors during the compilation phase.

Common causes of syntax errors:

• Missing semicolon ; at the end of a statement
• Mismatched braces { } or parentheses ( )
• Misspelled keywords (writing inhlude instead of #include)
• Using undeclared variables
• Missing double quotes around strings

// Example of syntax error:
int main()
{
    cout << "Hello"  // Missing semicolon here!
    return 0;
}
// Compiler error: expected ';' before 'return'

2. Logical Errors (Semantic Errors)

Logical errors are the trickiest type. Your program compiles successfully and runs without crashing, but it produces the wrong result. The compiler cannot catch these because the syntax is perfectly valid.

// Example of logical error:
int a = 10, b = 5;
int sum = a - b;  // Should be a + b for sum!
cout << "Sum: " << sum;  // Prints 5, but correct answer is 15
// No error message! Program runs fine but gives wrong output.

Other examples: using > instead of < in a condition, wrong formula in a calculation, off-by-one errors in loops. You must test your program with known inputs and check if the output is correct to find logical errors.

3. Runtime Errors

Runtime errors occur while the program is running. The program compiles fine, but when it executes, something goes wrong and the program crashes or behaves unexpectedly.

// Example of runtime error:
int a = 10, b = 0;
int result = a / b;  // Division by zero!
cout << result;      // Program crashes here

Common runtime errors include: division by zero, accessing an invalid array index, running out of memory, stack overflow from infinite recursion. These errors are detected by the operating system or runtime environment, not the compiler.

3.4 Basic Elements of C++ Programming

Now we are getting to the core of C++! These are the building blocks you will use in every single program you write. Pay very close attention to each concept because they are all heavily tested in exams.

3.4.1 Identifiers

Identifiers are the names you give to things in your program — variables, functions, constants, and so on. When you write int age;, the word age is an identifier. Simple, right? But there are rules you must follow when naming things.

Rules for Identifiers (Must Memorize!)

1. Must begin with a letter (a-z, A-Z) or underscore (_). It CANNOT start with a digit.
2. Can contain letters, digits (0-9), and underscores only. No spaces, no special characters like @, #, $, %.
3. Cannot be a reserved keyword. You cannot name a variable int, return, if, etc.
4. C++ is case-sensitive. Age, age, and AGE are THREE different identifiers.
5. No length limit (practically), but keep names meaningful and reasonable.

// VALID identifiers:
int age;
int _count;
int studentName;
int marks1;
int total_marks;

// INVALID identifiers:
int 1stMark;    // Error: starts with a digit
int my age;     // Error: contains a space
int student@;   // Error: contains special character @
int int;        // Error: 'int' is a reserved keyword
int float;      // Error: 'float' is a reserved keyword

3.4.2 Variables

Now, what exactly is a variable? Think of a variable as a container or a box in the computer’s memory. You put a value in it, and you can change (vary) that value later — that is why it is called a “variable”!

Before you use a variable in C++, you must declare it. Declaration tells the compiler: “I need a box of this size (data type) with this name.”

// Declaring variables
int age;          // A box named 'age' that holds integers
float salary;     // A box named 'salary' that holds decimal numbers
char grade;       // A box named 'grade' that holds a single character

// Declaring AND initializing at the same time
int age = 20;
float salary = 3500.50;
char grade = 'A';

I want you to notice something important: when we store a character, we use single quotes like 'A'. But when we print a string of text with cout, we use double quotes like "Hello". Do not mix these up in the exam!

3.4.3 Data Types

Data types tell the compiler what kind of data a variable will hold. This is crucial because different types of data need different amounts of memory. C++ has several built-in data types. Let me explain each one clearly.

Fundamental (Primitive) Data Types

Let me explain the important details about each type:

Integer Type (int)

This is the most commonly used data type. It stores whole numbers — positive, negative, and zero. It does NOT store decimal numbers. If you write int x = 3.7;, the compiler will truncate (cut off) the decimal part and store only 3.

Floating-Point Types (float and double)

These store numbers with decimal points. The word “float” means the decimal point can “float” to any position. float gives about 6-7 digits of precision, while double (double precision) gives about 15-16 digits. When you write a float literal, it is good practice to add f at the end: 19.99f. Without the f, C++ treats it as a double by default.

Character Type (char)

A char stores exactly one character. Internally, it stores the ASCII code of that character as a number. For example, 'A' is stored as 65, '0' is stored as 48. This is why you can do math with characters!

char ch = 'A';
cout << ch;        // Prints: A
cout << (int)ch;   // Prints: 65 (ASCII value)

Boolean Type (bool)

A bool can only hold one of two values: true (which equals 1) or false (which equals 0). This is used for conditions and flags.

bool isStudent = true;
bool hasPassed = false;
cout << isStudent;   // Prints: 1
cout << hasPassed;   // Prints: 0

Modifiers: signed, unsigned, short, long

You can modify the basic integer types to change their range:

• unsigned int — only non-negative values (0 and positive). Doubles the positive range.
• long int — larger range (typically 8 bytes).
• short int — smaller range (typically 2 bytes), saves memory.

3.4.4 Keywords (Reserved Words)

Keywords are words that C++ has reserved for special purposes. You cannot use them as identifiers (variable names, function names, etc.). Think of them as the vocabulary that belongs to C++ itself — you are not allowed to repurpose them.

3.4.5 Working on Variables — Declaration, Initialization, Assignment

There are three key operations you perform on variables. Let me explain the difference clearly because students often confuse them.

1. Declaration

Declaring a variable means telling the compiler its name and data type. Memory is allocated, but the variable has a garbage value (whatever was previously in that memory location).

int age;       // Declaration only — age has garbage value
float salary;  // Declaration only — salary has garbage value

2. Initialization

Initialization means giving a variable its first value at the same time you declare it. This is the best practice!

int age = 20;         // Declaration + Initialization
float salary = 5000.0; // Declaration + Initialization

3. Assignment

Assignment means giving a new value to a variable that was already declared. You use the assignment operator =.

int age;
age = 25;       // Assignment (age was already declared)
age = 26;       // Reassignment

Type Casting (Important for Exam!)

Sometimes you need to convert one data type to another. C++ supports two types of casting:

Implicit casting — the compiler automatically converts types (usually when assigning a smaller type to a larger type):

int a = 10;
double b = a;    // int 10 is automatically converted to double 10.0

Explicit casting — you manually tell the compiler to convert:

double pi = 3.14159;
int intPi = (int)pi;     // Old C-style cast — intPi = 3
int intPi2 = int(pi);    // C++ function-style cast — intPi2 = 3

int x;
int y = x + 5;

3.4.6 Constants

Sometimes you have a value that should never change throughout the program. For example, the value of pi (3.14159…), or the number of days in a week (7). For such values, you use constants instead of variables.

There are two ways to create constants in C++:

Method 1: Using the const Keyword

const double PI = 3.14159;
const int DAYS_IN_WEEK = 7;
// PI = 3.14;  // ERROR! Cannot modify a constant

Method 2: Using #define (Preprocessor Macro)

#define PI 3.14159
#define DAYS_IN_WEEK 7
// This replaces PI with 3.14159 before compilation

Let me ask you: why use constants at all? Why not just use regular variables and remember not to change them? Well, humans make mistakes! If you accidentally change a “constant” variable, the program might produce wrong results silently. Using const makes the compiler enforce the rule — if you try to change it, you get a clear error message. Smart, right?

3.4.7 Comments in Programming

Comments are notes you write in your code that the compiler completely ignores. They are meant for humans — for you, your teammates, or anyone who reads your code later. Good comments explain WHY something is done, not just WHAT is done.

C++ supports two types of comments:

// This is a single-line comment
// It extends from // to the end of the line
int age = 20; // You can also place comments after code

/* This is a multi-line comment.
   It can span multiple lines.
   Everything between /* and */ is ignored.
   Useful for longer explanations. */
int salary = 5000;

3.4.8 Operators and Expressions

This is one of the most important and most tested topics in C++ fundamentals. An operator is a symbol that performs an operation on one or more operands. An expression is a combination of operators and operands that produces a value.

For example, in a + b, the + is the operator, and a and b are operands. The whole thing a + b is an expression.

1. Arithmetic Operators

// Integer division examples
cout << 7 / 2;     // Output: 3 (not 3.5!)
cout << 7.0 / 2;   // Output: 3.5
cout << 7 / 2.0;   // Output: 3.5
cout << (double)7 / 2; // Output: 3.5

// Modulus examples
cout << 17 % 5;    // Output: 2 (17 = 3*5 + 2)
cout << 20 % 5;    // Output: 0 (20 is exactly divisible by 5)
cout << 3 % 5;     // Output: 3 (3 = 0*5 + 3)

2. Relational (Comparison) Operators

These operators compare two values and return a boolean result: true (1) or false (0).

3. Logical Operators

These operators combine or reverse boolean expressions. They are essential for complex conditions.

4. Assignment Operators

These are just shorthand notations. x += 3 is exactly the same as x = x + 3. They make code shorter and easier to read.

5. Increment and Decrement Operators

These are special operators that increase or decrease a variable’s value by 1. They come in two forms:

int x = 5;

// PREFIX — increment/decrement FIRST, then use the value
++x;   // x becomes 6, and the expression value is 6
--x;   // x becomes 5, and the expression value is 5

// POSTFIX — use the value FIRST, then increment/decrement
x++;   // expression value is 5 (current value), THEN x becomes 6
x--;   // expression value is 6 (current value), THEN x becomes 5

int a = 5;
int b;

b = a++;   // POSTFIX: b gets the CURRENT value of a (5), THEN a becomes 6
// Now: b = 5, a = 6

int c = 5;
int d;

d = ++c;   // PREFIX: c becomes 6 FIRST, THEN d gets the NEW value (6)
// Now: d = 6, c = 6

6. sizeof Operator

The sizeof operator returns the size (in bytes) of a data type or variable.

cout << sizeof(int);     // Output: 4 (typically)
cout << sizeof(double);  // Output: 8
cout << sizeof(char);    // Output: 1
cout << sizeof(bool);    // Output: 1

7. Operator Precedence and Associativity

When an expression has multiple operators, precedence determines which operator is evaluated first (like BODMAS in math). Associativity determines the order when operators have the same precedence.

int x = 5;
cout << x++ << " " << x;

3.4.9 Special Printing Characters (Escape Sequences)

Sometimes you need to print special characters that cannot be typed directly in a string. For example, how do you print a newline? Or a tab? Or a double quote inside a string? C++ uses escape sequences for this — they always start with a backslash \.

// Examples
cout << "Name:\tAge:\tCity\n";    // Tab-separated header
cout << "Abebe\t25\tAddis\n";    // Data row
cout << "File path: C:\\Users\\doc\\";  // Prints: C:\Users\doc\
cout << "She said, \"Hello!\"";  // Prints: She said, "Hello!"

3.4.10 Input/Output Statements

We have already used cout for output. Now let us learn how to get input from the user. In C++, we use cin (pronounced “see-in”) for input.

The cin Object (Input)

cin reads data from the keyboard. It uses the extraction operator >> (which points FROM the input TOWARD the variable).

#include <iostream>
using namespace std;

int main()
{
    int age;
    cout << "Enter your age: ";
    cin >> age;              // Reads an integer from keyboard
    cout << "You are " << age << " years old." << endl;
    return 0;
}

You can read multiple values in a single cin statement:

int a, b, c;
cout << "Enter three numbers: ";
cin >> a >> b >> c;    // Reads three integers separated by spaces

The cout Object (Output)

cout sends data to the screen using the insertion operator <<. You can chain multiple outputs:

cout << "Name: " << name << ", Age: " << age << endl;

Reading Different Data Types

int num;
float price;
char grade;
string name;

cout << "Enter an integer: ";
cin >> num;

cout << "Enter a price: ";
cin >> price;

cout << "Enter your grade: ";
cin >> grade;

cout << "Enter your name: ";
cin >> name;       // Note: cin with >> only reads one word!

Complete Worked Example

Let me put everything together in a complete program. This is exactly the kind of program you might be asked to write in an exam.

#include <iostream>
using namespace std;

int main()
{
    // Declare variables
    float exam1, exam2, exam3;
    float average;

    // Get input from user
    cout << "Enter marks for Exam 1: ";
    cin >> exam1;
    cout << "Enter marks for Exam 2: ";
    cin >> exam2;
    cout << "Enter marks for Exam 3: ";
    cin >> exam3;

    // Calculate average
    average = (exam1 + exam2 + exam3) / 3.0;

    // Display result
    cout << "\n--- Result ---\n";
    cout << "Exam 1: " << exam1 << endl;
    cout << "Exam 2: " << exam2 << endl;
    cout << "Exam 3: " << exam3 << endl;
    cout << "Average: " << average << endl;

    return 0;
}

Notice that I wrote / 3.0 instead of / 3. Why? Because if all three exam variables are floats, the division would produce a float anyway. But writing 3.0 makes it explicit and safe — it guarantees floating-point division even if someone changes the variable types later. This is a good programming habit!

#include <iostream>
using namespace std;

int main()
{
    const double PI = 3.14159;
    double radius, area, circumference;

    cout << "Enter the radius of the circle: ";
    cin >> radius;

    area = PI * radius * radius;
    circumference = 2 * PI * radius;

    cout << "\nArea of circle: " << area << endl;
    cout << "Circumference of circle: " << circumference << endl;

    return 0;
}

Chapter Summary — Key Points to Remember

Quick Revision Notes — Exam Focus

Challenge Exam Questions — Test Yourself!

These questions are at university exam level. Try each one before clicking “Show Answer.” Good luck!

int a = 5, b = 3;
int c = a++ + ++b - a % b;
cout << a << " " << b << " " << c;

#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
    float celsius, fahrenheit;

    cout << "Enter temperature in Celsius: ";
    cin >> celsius;

    fahrenheit = (celsius * 9.0 / 5.0) + 32.0;

    cout << fixed << setprecision(2);
    cout << "Temperature in Fahrenheit: " << fahrenheit << endl;

    return 0;
}

int a = 5, b = 5;
if (a = b) {
    cout << "Result: " << a + b;
}

int a = 10, b = 3, c = 2;
int result = a / b + a % b * c - ++c;

int x = 3;
int y = x++ + x++ + x++;
cout << y << " " << x;

#include <iostream>
using namespace std;

int main()
{
    int a, b;

    cout << "Enter first number: ";
    cin >> a;
    cout << "Enter second number: ";
    cin >> b;

    cout << "\nBefore swap: a = " << a << ", b = " << b << endl;

    // Swap without temporary variable (using arithmetic)
    a = a + b;   // a now holds the sum
    b = a - b;   // b gets the original value of a
    a = a - b;   // a gets the original value of b

    cout << "After swap:  a = " << a << ", b = " << b << endl;

    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    int num, hundreds, tens, ones;

    cout << "Enter a three-digit number: ";
    cin >> num;

    ones = num % 10;           // Get last digit
    num = num / 10;            // Remove last digit
    tens = num % 10;           // Get next digit (now last)
    hundreds = num / 10;       // Get first digit

    cout << "Hundreds: " << hundreds << endl;
    cout << "Tens: " << tens << endl;
    cout << "Ones: " << ones << endl;

    return 0;
}