Learn C++ - Basic Syntax & Program Structure

#Introduction

After understanding the architecture behind C++, it's time to write code that actually compiles. Episode 3 builds your basic syntax: how a C++ program is structured, how variables and constants are declared, and how functions work with scope and return values.

C++ syntax combines C's concise heritage with modern features. You'll see std::cin and std::cout for the first time — a type-safe input-output interface that will accompany you throughout this series.

#The Anatomy of a C++ Program

#A Minimal Valid Program

Every C++ program has at least one main function. Execution always starts from this function, and its return value determines the program's exit status. Take a look at the following structure:

cat > struktur.cpp <<'EOF'
#include <iostream>
 
int main() {
    std::cout << "Struktur program C++\n";
    return 0;
}
EOF
g++ -std=c++20 -Wall -Wextra struktur.cpp -o struktur
./struktur

The line #include <iostream> loads the input-output stream declarations. The main function returns an int: the value 0 signals success, and any other value signals an error. You can check the exit status with echo $? after running the program.

#Statements, Code Blocks, and Comments

A program consists of statements terminated by semicolons. A group of statements wrapped in curly braces forms a code block. Comments explain the intent of the code and are ignored by the compiler — use // for a single line and /* ... */ for multiple lines.

Comments aren't decoration. In complex C++, comments that explain why a decision was made are far more valuable than ones that explain what the code does.

#Variables, Constants, and Fundamental Types

#Fundamental Data Types

C++ provides basic types: int for whole numbers, double and float for fractions, char for a single character, bool for true-false values, and void for no value. Since C++11, auto can deduce the type from the initializer.

Declare variables by including the type or using auto:

cat > variabel.cpp <<'EOF'
#include <iostream>
 
int main() {
    int umur = 25;
    double harga = 19.99;
    char inisial = 'A';
    bool aktif = true;
    auto jumlah = 42;
 
    const double pajak = 0.11;
    constexpr int kuota = 100;
 
    std::cout << umur << " " << harga << " " << inisial << " "
              << aktif << " " << jumlah << "\n";
    std::cout << "Pajak: " << pajak << " Kuota: " << kuota << "\n";
}
EOF
g++ -std=c++20 variabel.cpp -o variabel
./variabel

const double pajak = 0.11 creates a constant that can't be changed, while constexpr int kuota = 100 is computed at compile time. Use auto when the type is clear from the initializer, and name an explicit type when clarity matters more.

#Literals and Initialization

Literal suffixes like 19.99 (double) or 19.99f (float) determine the type of a value. Since C++11, brace initialization int x{42} is safer than the older form because it rejects unintended type narrowing — for example, putting 3.7 into an int triggers a warning or error.

#Functions, Scope, and Return Values

#Defining Functions

Functions wrap logic so it can be called repeatedly. A function consists of a return type, a name, parameters, and a function body:

cat > fungsi.cpp <<'EOF'
#include <iostream>
 
int kuadrat(int x) {
    return x * x;
}
 
int main() {
    int hasil = kuadrat(7);
    std::cout << "Kuadrat 7 = " << hasil << "\n";
}
EOF
g++ -std=c++20 fungsi.cpp -o fungsi
./fungsi

The kuadrat function takes one parameter int x and returns x * x. If a function doesn't return a value, its return type is void.

#Scope and Lifetime

Scope determines where a name can be accessed. Variables declared inside a block are only visible within that block and its child blocks. Global variables are declared outside functions and are visible everywhere, but use them sparingly because they're hard to track.

Local variables declared inside a block are destroyed when the block ends — the timing is determined by scope, not by a garbage collector. This is the foundation of RAII that you'll get to know in episode 7.

#Input and Output with std::cin and std::cout

#Your First Interactive Program

std::cout sends data to the screen, std::cin reads data from the keyboard. The << operator streams values to output, and >> streams input into a variable. Combine both for a program that interacts with the user:

cat > sapa.cpp <<'EOF'
#include <iostream>
#include <string>
 
int main() {
    std::string nama;
    std::cout << "Siapa nama kalian? ";
    std::cin >> nama;
    std::cout << "Halo, " << nama << "!\n";
}
EOF
g++ -std=c++20 sapa.cpp -o sapa
./sapa

std::cin >> nama reads one word from the input and stores it in a std::string. To read a full line including spaces, use std::getline(std::cin, nama). Note that std::string — not the C-style char[] — is the safe, modern string type.

#Conclusion

Here's what to take away:

• A C++ program always starts from the main function, which returns an int.
• Fundamental types: int, double, float, char, bool, and auto.
• const for runtime constants, constexpr for compile-time constants.
• Scope determines a variable's visibility and lifetime.
• std::cout for output, std::cin for input, std::getline for a full line.
• Brace initialization is safer than the older form.

In the next episode, episode 4, we'll discuss control flow and operators — arithmetic, logical, bitwise, and incremental operators, the if, switch, and ternary conditional statements, all kinds of loops including range-based for, as well as break and continue. These are the tools that make your programs make decisions.