01 C++ Fundamentals and Program Structure

Program anatomy and entry point

A C++ program is built from declarations and definitions stored in source files and, commonly, header files. A minimal program has an entry point named main:

#include <iostream> makes standard input/output declarations available. int main() defines the function where execution begins, and return 0; reports successful completion. Braces delimit a block, while semicolons commonly terminate expression statements.

The prefix std:: qualifies names from the standard library's std namespace. For example, std::cout writes output, and std::cin reads input.

Takeaway: Identify the entry point, included facilities, blocks, statements, and standard-library qualifications before tracing what a program does.

Files, translation, and building

A larger project can divide declarations and shared definitions between header files and implementations in .cpp source files. For example, a header may declare void say_hello();, while a source file defines that function and includes the header.

The #include directive is handled before ordinary compilation. Conceptually, the included contents become part of the source being processed. The resulting source is a translation unit, which can be compiled independently from other translation units.

A typical build follows this progression:

1. Preprocessing handles directives such as #include and conditional compilation.

2. Compilation checks syntax and meaning and commonly produces an object file.

3. Linking combines object files and libraries into an executable.

4. Execution loads and runs that executable.

With GCC, a complete single-file build can use g++ -std=c++17 -Wall -Wextra main.cpp -o main. The -c option stops after compilation, allowing separate object files to be linked later.

Takeaway: Separate source files are compiled independently, then linking connects their definitions and library dependencies.

Comments, tokens, and names

Comments explain intent and are ignored during translation. A line comment begins with // and continues to the line's end. A block comment begins with /* and ends with */, so it may span multiple lines.

Whitespace includes spaces, tabs, and line breaks. It generally separates tokens but does not change the meaning of valid code. For example, int total = 3 + 4; and int total=3+4; have the same meaning, although the first form is easier to read.

A token is a meaningful lexical unit. Common categories include identifiers, keywords, literals, operators, and punctuators.

An identifier names an entity such as item_count, calculate_area, or Rectangle. Ordinary identifiers begin with a letter or underscore, may contain digits after the first character, and are case-sensitive. Avoid implementation-reserved underscore forms and prefer descriptive names.

Keywords have predefined language meanings and normally cannot be used as identifiers. For example, class is a keyword, so int class; is invalid.

Takeaway: Formatting supports human readers, while tokens and their language rules determine whether the compiler can interpret the program.

Values, expressions, and statements

A literal writes a value directly in source code. Examples include the integer literal 42, floating-point literal 3.14, character literal 'A', string literal "C++", Boolean literal true, and null pointer literal nullptr. Integer literals may use decimal, hexadecimal such as 0x2A, or binary such as 0b101010 notation. Suffixes such as L, f, and u communicate type or representation preferences.

An expression produces a value, performs an operation, or does both. Examples include 2 + 3, width * height, and number = 10. Operators combine or transform operands: + adds, = assigns, and > compares. Parentheses can make grouping explicit, as in (a + b) * c.

A statement specifies an action or control operation. int count = 0; is a declaration statement, std::cout << count; is an expression statement, and return 0; is a jump statement. Braces create compound statements that contain other statements. Selection statements such as if and iteration statements such as while control which statements execute.

A character literal represents one character, whereas a string literal represents a sequence of characters. Escape sequences such as \n represent special characters inside character and string literals.

Takeaway: Distinguish values written directly in code, value-producing expressions, and statements that organize execution.

Console streams and input handling

The <iostream> header provides standard console streams. std::cout sends formatted output, std::cin reads formatted input, std::cerr is commonly used for diagnostics, and std::clog is intended for logging.

Output uses the insertion operator <<:

• std::cout << "Apples: " << apples << '\\n'; inserts text, a variable, and a newline.

• \n moves output to the next line.

• std::endl inserts a newline and flushes the stream, so \n is often preferable when an immediate flush is unnecessary.

Input uses the extraction operator >>. If age is an integer, std::cin >> age; attempts to read an integer and stores it in age. Extraction skips leading whitespace and interprets input according to the destination type.

For a line that may contain spaces, use std::getline(std::cin, name). After formatted extraction, a newline may remain in the input buffer. A common remedy is std::getline(std::cin >> std::ws, line), where std::ws consumes leading whitespace first.

Stream operations can fail. Testing if (std::cin >> value) lets a program distinguish successful integer input from invalid input and report a diagnostic through std::cerr.

Takeaway: Use << for output, >> for formatted input, and std::getline for complete lines; check stream state when input may be invalid.

Putting the fundamentals together

A small complete program can combine the concepts in a predictable sequence:

1. Include the facilities it needs, such as <iostream> and <string>.

2. Enter through main.

3. Declare and initialize variables.

4. Read values with std::cin or std::getline.

5. Evaluate expressions and assign results.

6. Write results with std::cout.

7. Return from main.

For example, a program can declare std::string name; and int year{};, read a name with std::getline(std::cin, name), read a year with std::cin >> year, and calculate an approximate age with const int approximate_age = current_year - year;. It can then insert the name and result into output using std::cout.

At runtime, main normally executes statements in order unless a control-flow statement changes that order. Before runtime, the build process has already processed included headers, performed compilation, and completed linking.

Takeaway: When debugging a beginner C++ program, trace both dimensions: how the build creates the executable and how main executes its statements.