Learn to Code C++: The Ultimate Beginner's Guide

Learn To Code C++ with learns.edu.vn, a comprehensive guide designed to take you from novice to proficient. This article simplifies complex concepts, offers practical examples, and provides a clear pathway to mastering C++ programming. Unlock your potential and embark on an exciting journey into the world of software development.

1. Introduction to C++ Programming

C++ is a versatile and powerful programming language used in a wide range of applications, from game development to operating systems. Let’s explore what makes C++ a valuable skill to acquire and how it stands out from other programming languages.

1.1. What is C++?

C++ is a high-level, general-purpose programming language that extends the C language with object-oriented features. It’s renowned for its performance, efficiency, and control over hardware resources. C++ allows programmers to create sophisticated applications, manage memory effectively, and write code that runs close to the metal, making it ideal for performance-critical tasks.

1.2. Why Learn C++?

Learning C++ opens up numerous opportunities across various industries. Here’s why it’s a valuable skill:

Performance: C++ allows for fine-grained control over hardware, making it ideal for applications where performance is critical, such as game development, high-frequency trading, and operating systems.
Versatility: C++ is used in a wide range of applications, from embedded systems to enterprise-level software.
Career Opportunities: C++ developers are in high demand in industries ranging from gaming to finance.
Foundation for Other Languages: Understanding C++ provides a solid foundation for learning other programming languages like Java and C#.
Legacy Systems: Many existing systems are written in C++, so knowledge of the language is essential for maintenance and updates.

1.3. C++ vs. Other Programming Languages

Compared to languages like Python or JavaScript, C++ offers a different set of advantages and trade-offs.

Feature	C++	Python	JavaScript
Performance	High performance; close to hardware.	Lower performance; interpreted language.	Moderate performance; depends on the JavaScript engine.
Complexity	More complex; requires manual memory management.	Simpler syntax; automatic memory management.	Relatively simple; primarily used for web development.
Use Cases	Game development, operating systems, high-performance applications.	Data science, machine learning, scripting.	Web development (front-end and back-end).
Memory Management	Manual memory management (prone to memory leaks).	Automatic memory management (garbage collection).	Automatic memory management (garbage collection).
Control	Fine-grained control over hardware.	Limited control over hardware.	Limited control over hardware.
Learning Curve	Steeper learning curve.	Easier to learn.	Relatively easy to learn, especially for front-end development.

C++ is ideal for projects where performance and control are paramount, while Python and JavaScript are often preferred for rapid development and ease of use.

2. Setting Up Your C++ Development Environment

Before you can start coding, you’ll need to set up your development environment. This includes installing a compiler, an Integrated Development Environment (IDE), and configuring them for C++ development.

2.1. Choosing a Compiler

A compiler translates your C++ code into machine-executable code. Here are some popular choices:

GNU Compiler Collection (GCC): A free and open-source compiler available for multiple platforms, including Windows, macOS, and Linux.
Clang: Another free and open-source compiler known for its excellent diagnostics and support for modern C++ standards.
Microsoft Visual C++ (MSVC): Part of the Visual Studio IDE, MSVC is a robust compiler for Windows.

For beginners, GCC and Clang are excellent choices due to their availability and community support.

2.2. Installing an Integrated Development Environment (IDE)

An IDE provides a comprehensive environment for writing, compiling, and debugging code. Here are some popular IDEs for C++:

Visual Studio Code (VS Code): A lightweight but powerful editor with extensive C++ support through extensions.
Code::Blocks: A free, open-source IDE specifically designed for C++ development.
Visual Studio: A full-featured IDE (commercial, but with a free Community edition) with advanced debugging and project management tools.
CLion: A cross-platform IDE from JetBrains designed specifically for C and C++.

Step-by-Step Guide to Setting Up VS Code with C++:

Install VS Code: Download and install Visual Studio Code from the official website.
Install a C++ Compiler: If you’re on Windows, consider installing MinGW (Minimalist GNU for Windows) to get GCC. On macOS and Linux, GCC or Clang are usually pre-installed or easily installable via package managers.
Install the C/C++ Extension: Open VS Code, go to the Extensions view (Ctrl+Shift+X), and search for “C/C++” by Microsoft. Install this extension.
Configure VS Code: Create a new folder for your C++ projects. Inside this folder, create a file named hello.cpp and add some basic C++ code.
Create a tasks.json File: This file tells VS Code how to build your project. Go to Terminal > Configure Default Build Task. VS Code will prompt you to select a compiler; choose your C++ compiler (e.g., “C/C++: g++.exe build active file”). This creates a .vscode folder with a tasks.json file.
Create a launch.json File: This file configures the debugger. Go to Run > Add Configuration. Choose “C++ (GDB/LLDB)” and then select your compiler. This creates a launch.json file in the .vscode folder.
Build and Run: Press Ctrl+Shift+B to build your project, then press F5 to run it in the debugger.

2.3. Configuring Your Compiler

Configuring your compiler involves setting up build configurations, compiler extensions, and warning levels to ensure your code is robust and follows best practices.

Build Configurations: Set up different build configurations (e.g., Debug, Release) to optimize for development and deployment. Debug builds include debugging information, while Release builds are optimized for performance.
Compiler Extensions: Enable or disable compiler extensions based on your project requirements. Extensions can provide additional features but might not be portable across different compilers.
Warning and Error Levels: Configure your compiler to treat warnings as errors to catch potential issues early. Use high warning levels during development to enforce code quality.
Choosing a Language Standard: Specify the C++ standard (e.g., C++11, C++14, C++17, C++20) to ensure compatibility and access to the latest features.

3. C++ Basics: Syntax and Structure

Understanding the basic syntax and structure of C++ is essential for writing any program. Let’s explore the fundamental elements of C++ code.

3.1. Statements and the Structure of a Program

A C++ program consists of statements, which are instructions executed by the computer. A typical C++ program includes:

Include Directives: These lines tell the compiler to include header files, which contain declarations for functions and classes. For example, #include <iostream> includes the iostream library for input and output operations.
Main Function: The main() function is the entry point of every C++ program. Execution begins here.
Statements: Instructions that perform actions. These can be declarations, assignments, function calls, or control flow statements.
Comments: Explanations in the code that are ignored by the compiler. They are crucial for code readability and maintainability.

Here’s a basic C++ program structure:

#include <iostream>

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

3.2. Comments

Comments are used to explain code and are ignored by the compiler. C++ supports two types of comments:

Single-Line Comments: Start with // and continue to the end of the line.
Multi-Line Comments: Start with /* and end with */.

Example:

// This is a single-line comment
/*
   This is a
   multi-line comment
*/

Using comments effectively can greatly improve code readability and make it easier for others (and yourself) to understand your code.

3.3. Objects and Variables

In C++, an object is a region of storage that can hold a value. A variable is a named object. You must declare a variable before you can use it. Declaration involves specifying the variable’s type and name.

int age;        // Declaration of an integer variable named 'age'
double salary;  // Declaration of a double variable named 'salary'

3.4. Variable Assignment and Initialization

Assignment: Assigning a value to a variable after it has been declared.
Initialization: Assigning a value to a variable at the time of declaration.

int age;        // Declaration
age = 30;       // Assignment

double salary = 50000.0; // Declaration and initialization

Always initialize variables when you declare them to avoid undefined behavior.

3.5. Introduction to iostream: cout, cin, and endl

The iostream library provides input and output functionalities.

cout: Used for output to the console.
cin: Used for input from the console.
endl: Inserts a newline character and flushes the output stream.

#include <iostream>

int main() {
    std::cout << "Enter your age: ";
    int age;
    std::cin >> age;
    std::cout << "You are " << age << " years old." << std::endl;
    return 0;
}

3.6. Uninitialized Variables and Undefined Behavior

Using an uninitialized variable leads to undefined behavior, which can result in unpredictable program behavior or crashes. Always initialize your variables.

int x; // Uninitialized variable
std::cout << x << std::endl; // Undefined behavior

3.7. Keywords and Naming Identifiers

Keywords: Reserved words that have special meanings in C++ (e.g., int, double, class, return).
Identifiers: Names given to variables, functions, and classes.

Naming Rules:

Identifiers must start with a letter or underscore.
They can contain letters, numbers, and underscores.
C++ is case-sensitive (e.g., age and Age are different variables).

3.8. Whitespace and Basic Formatting

Whitespace (spaces, tabs, newlines) is largely ignored by the C++ compiler, but it’s crucial for code readability. Use whitespace to:

Separate operators and operands.
Indent code blocks within functions and control structures.
Add blank lines to group related statements.

3.9. Introduction to Literals and Operators

Literals: Constant values that appear directly in the code (e.g., 42, 3.14, "Hello").
Operators: Symbols that perform operations on operands (e.g., +, -, *, /).

int x = 10;      // 10 is an integer literal
double pi = 3.14; // 3.14 is a floating-point literal
std::string message = "Hello"; // "Hello" is a string literal

3.10. Introduction to Expressions

An expression is a combination of literals, variables, and operators that can be evaluated to produce a value.

int a = 5;
int b = 10;
int sum = a + b; // a + b is an expression that evaluates to 15

3.11. Developing Your First Program

Let’s create a simple program that adds two numbers:

#include <iostream>

int main() {
    int num1, num2, sum;

    std::cout << "Enter the first number: ";
    std::cin >> num1;

    std::cout << "Enter the second number: ";
    std::cin >> num2;

    sum = num1 + num2;

    std::cout << "The sum is: " << sum << std::endl;

    return 0;
}

This program demonstrates basic input, processing, and output in C++.

4. C++ Basics: Functions and Files

Functions are reusable blocks of code that perform specific tasks. Understanding functions and how to organize code into multiple files is crucial for larger projects.

4.1. Introduction to Functions

A function is a block of code that performs a specific task. Functions help break down complex problems into smaller, manageable pieces.

// Function declaration
int add(int a, int b);

int main() {
    int result = add(5, 3); // Function call
    std::cout << "Result: " << result << std::endl;
    return 0;
}

// Function definition
int add(int a, int b) {
    return a + b;
}

4.2. Function Return Values (Value-Returning Functions)

Functions can return values using the return statement. The return type must match the function’s declared return type.

int multiply(int a, int b) {
    return a * b; // Returns an integer value
}

4.3. Void Functions (Non-Value Returning Functions)

Void functions do not return a value. They perform actions without producing a result.

void printMessage(std::string message) {
    std::cout << message << std::endl;
}

4.4. Introduction to Function Parameters and Arguments

Parameters: Variables declared in the function definition that receive values.
Arguments: Actual values passed to the function when it is called.

int power(int base, int exponent) { // base and exponent are parameters
    int result = 1;
    for (int i = 0; i < exponent; ++i) {
        result *= base;
    }
    return result;
}

int main() {
    int result = power(2, 3); // 2 and 3 are arguments
    std::cout << "2^3 = " << result << std::endl;
    return 0;
}

4.5. Introduction to Local Scope

Variables declared inside a function have local scope, meaning they are only accessible within that function.

void myFunction() {
    int x = 10; // x is only accessible within myFunction
    std::cout << x << std::endl;
}

int main() {
    // std::cout << x << std::endl; // Error: x is not defined in this scope
    myFunction();
    return 0;
}

4.6. Why Functions Are Useful, and How to Use Them Effectively

Functions provide several benefits:

Modularity: Break down complex tasks into smaller, manageable units.
Reusability: Use the same code in multiple places.
Readability: Make code easier to understand and maintain.

Effective use of functions involves:

Clear Naming: Give functions descriptive names.
Single Responsibility: Each function should perform one well-defined task.
Documentation: Use comments to explain what the function does, its parameters, and its return value.

4.7. Forward Declarations and Definitions

A forward declaration tells the compiler about the existence of a function before its actual definition. This is necessary when functions call each other.

// Forward declaration
int add(int a, int b);

int main() {
    int result = add(5, 3);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

// Function definition
int add(int a, int b) {
    return a + b;
}

4.8. Programs with Multiple Code Files

Large programs are often divided into multiple files to improve organization and maintainability.

Header Files (.h): Contain declarations of functions, classes, and variables.
Source Files (.cpp): Contain the actual implementations of functions and classes.

Example:

mymath.h

#ifndef MYMATH_H
#define MYMATH_H

int add(int a, int b);

#endif

mymath.cpp

#include "mymath.h"

int add(int a, int b) {
    return a + b;
}

main.cpp

#include <iostream>
#include "mymath.h"

int main() {
    int result = add(5, 3);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

4.9. Naming Collisions and an Introduction to Namespaces

Naming collisions occur when two identifiers have the same name. Namespaces help prevent this by providing a scope for names.

namespace MyMath {
    int add(int a, int b) {
        return a + b;
    }
}

int main() {
    int result = MyMath::add(5, 3);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

4.10. Introduction to the Preprocessor

The preprocessor is a tool that modifies the source code before compilation. Common preprocessor directives include:

#include: Includes header files.
#define: Defines macros.
#ifdef, #ifndef, #endif: Conditional compilation.

4.11. Header Files

Header files contain declarations that are shared across multiple source files. They help ensure consistency and avoid duplication.

4.12. Header Guards

Header guards prevent multiple inclusions of the same header file, which can lead to compilation errors.

#ifndef MYHEADER_H
#define MYHEADER_H

// Header content

#endif

4.13. How to Design Your First Programs

Designing a program involves:

Understanding the Problem: Clearly define what the program should do.
Planning: Break the problem into smaller tasks.
Coding: Write the code, using functions to organize your program.
Testing: Test the program thoroughly to ensure it works correctly.
Refactoring: Improve the code’s structure and readability.

5. Debugging C++ Programs

Debugging is a crucial skill for any programmer. It involves identifying and fixing errors in your code.

5.1. Syntax and Semantic Errors

Syntax Errors: Occur when the code violates the rules of the C++ language (e.g., missing semicolons, incorrect syntax).
Semantic Errors: Occur when the code is syntactically correct but does not do what the programmer intended (e.g., incorrect logic, using the wrong operator).

5.2. The Debugging Process

The debugging process typically involves:

Identifying the Problem: Recognizing that the program is not behaving as expected.
Locating the Error: Finding the specific line(s) of code causing the problem.
Understanding the Error: Determining why the code is not working as intended.
Fixing the Error: Modifying the code to correct the problem.
Testing the Solution: Ensuring that the fix resolves the issue and does not introduce new problems.

5.3. A Strategy for Debugging

A systematic approach to debugging can save time and frustration.

Reproduce the Error: Make sure the error occurs consistently.
Simplify the Problem: Try to isolate the error by removing unrelated code.
Read the Error Message: Compiler error messages often provide clues about the problem.
Use Debugging Tools: Use an IDE’s debugger to step through the code and inspect variables.
Test Frequently: Test small changes to ensure they don’t introduce new errors.

5.4. Basic Debugging Tactics

Print Statements: Insert std::cout statements to display the values of variables and track the flow of execution.
Code Review: Ask a colleague to review your code and look for errors.
Rubber Duck Debugging: Explain your code to an inanimate object (like a rubber duck) to clarify your thinking and identify errors.

5.5. More Debugging Tactics

Divide and Conquer: Comment out sections of code to isolate the error.
Use a Debugger: Step through the code line by line, inspect variables, and set breakpoints.
Check Assumptions: Verify that your assumptions about the code and its behavior are correct.

5.6. Using an Integrated Debugger: Stepping

Stepping allows you to execute code one line at a time.

Step Over: Execute the current line and move to the next line in the same function.
Step Into: If the current line is a function call, enter the function and execute its first line.
Step Out: Finish executing the current function and return to the calling function.

5.7. Using an Integrated Debugger: Running and Breakpoints

Breakpoints: Markers in the code where the debugger will pause execution.
Running: Start the program and run until a breakpoint is hit or the program terminates.

5.8. Using an Integrated Debugger: Watching Variables

Watching variables allows you to monitor their values as the program executes. This helps you understand how variables change over time and identify unexpected behavior.

5.9. Using an Integrated Debugger: The Call Stack

The call stack shows the sequence of function calls that led to the current point in the program. This is useful for understanding the flow of execution and identifying the source of errors.

5.10. Finding Issues Before They Become Problems

Code Analysis Tools: Use static analysis tools to detect potential issues like memory leaks, null pointer dereferences, and unused variables.
Unit Testing: Write unit tests to verify that individual functions and classes work correctly.
Code Reviews: Have your code reviewed by others to catch errors and improve code quality.

6. Fundamental Data Types in C++

Understanding fundamental data types is essential for working with variables and performing operations in C++.

6.1. Introduction to Fundamental Data Types

C++ provides several fundamental data types for storing different kinds of values. These include:

int: Integer numbers.
double: Floating-point numbers.
bool: Boolean values (true or false).
char: Characters.

6.2. Void

The void type represents the absence of a value. It’s used as the return type for functions that do not return a value and as a generic pointer type.

6.3. Object Sizes and the sizeof Operator

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

#include <iostream>

int main() {
    int x;
    std::cout << "Size of int: " << sizeof(int) << " bytes" << std::endl;
    std::cout << "Size of x: " << sizeof(x) << " bytes" << std::endl;
    return 0;
}

6.4. Signed Integers

Signed integers can represent both positive and negative numbers. Common signed integer types include int, short, and long.

6.5. Unsigned Integers, and Why to Avoid Them

Unsigned integers can only represent non-negative numbers. They are useful for specific cases like bit manipulation but should be avoided in general-purpose arithmetic to prevent unexpected behavior.

6.6. Fixed-Width Integers and size_t

Fixed-width integers (e.g., int32_t, int64_t) guarantee a specific size, regardless of the platform. size_t is an unsigned integer type used to represent the size of objects in memory.

6.7. Introduction to Scientific Notation

Scientific notation is a way of representing very large or very small numbers using a coefficient and an exponent.

double x = 1.23e6;  // 1.23 * 10^6 = 1230000
double y = 4.56e-3; // 4.56 * 10^-3 = 0.00456

6.8. Floating Point Numbers

Floating-point numbers represent real numbers with fractional parts. Common floating-point types include float and double.

6.9. Boolean Values

Boolean values represent truth values: true or false. They are used in logical expressions and control structures.

6.10. Introduction to if Statements

if statements allow you to execute code conditionally based on a boolean expression.

int age = 20;
if (age >= 18) {
    std::cout << "You are an adult." << std::endl;
} else {
    std::cout << "You are a minor." << std::endl;
}

6.11. Chars

The char type represents a single character. Characters are enclosed in single quotes.

char initial = 'J';
std::cout << "Initial: " << initial << std::endl;

6.12. Introduction to Type Conversion and static_cast

Type conversion allows you to convert a value from one data type to another. static_cast is a safe and explicit way to perform type conversions.

int x = 10;
double y = static_cast<double>(x); // Convert int to double
std::cout << "y: " << y << std::endl;

7. Constants and Strings in C++

Constants are values that cannot be changed after initialization. Strings are sequences of characters. Understanding how to use constants and strings is essential for writing robust and readable C++ code.

7.1. Constant Variables (Named Constants)

Constant variables are declared using the const keyword. Their values cannot be changed after initialization.

const double PI = 3.14159;
// PI = 3.14; // Error: assignment of read-only variable 'PI'

7.2. Literals

Literals are constant values that appear directly in the code.

Integer Literals: 10, -5, 0.
Floating-Point Literals: 3.14, 2.5e-3.
Character Literals: 'A', 'z', '9'.
String Literals: "Hello", "World".

7.3. Numeral Systems (Decimal, Binary, Hexadecimal, and Octal)

C++ supports different numeral systems:

Decimal: Base 10 (e.g., 123).
Binary: Base 2 (e.g., 0b1100100).
Hexadecimal: Base 16 (e.g., 0x7B).
Octal: Base 8 (e.g., 0173).

int decimal = 123;
int binary = 0b1111011;
int hexadecimal = 0x7B;
int octal = 0173;

std::cout << "Decimal: " << decimal << std::endl;
std::cout << "Binary: " << binary << std::endl;
std::cout << "Hexadecimal: " << hexadecimal << std::endl;
std::cout << "Octal: " << octal << std::endl;

7.4. The as-if Rule and Compile-Time Optimization

The “as-if” rule allows the compiler to optimize code as long as the observable behavior of the program remains the same. This means the compiler can perform various optimizations at compile time, such as constant folding and inlining.

7.5. Constant Expressions

Constant expressions are expressions that can be evaluated at compile time. They are used to initialize constant variables and improve performance.

7.6. Constexpr Variables

constexpr variables are variables whose values are known at compile time. They must be initialized with a constant expression.

constexpr int square(int x) {
    return x * x;
}

constexpr int result = square(5); // Evaluated at compile time

7.7. Introduction to std::string

std::string is a class in the C++ Standard Library for working with strings. It provides many useful methods for manipulating strings.

#include <iostream>
#include <string>

int main() {
    std::string message = "Hello, World!";
    std::cout << message << std::endl;
    return 0;
}

7.8. Introduction to std::string_view

std::string_view provides a non-owning reference to a string. It’s more efficient than std::string for read-only operations because it avoids copying the string data.

#include <iostream>
#include <string_view>

void printString(std::string_view str) {
    std::cout << str << std::endl;
}

int main() {
    std::string message = "Hello, World!";
    printString(message);
    return 0;
}

7.9. std::string_view (part 2)

std::string_view can be used with any contiguous sequence of characters, including C-style strings and std::string. It provides methods for accessing and manipulating the string without modifying the original data.

8. Operators in C++

Operators are symbols that perform operations on one or more operands. Understanding operator precedence, associativity, and the different types of operators is crucial for writing correct and efficient C++ code.

8.1. Operator Precedence and Associativity

Operator precedence determines the order in which operators are evaluated in an expression. Associativity determines the order in which operators of the same precedence are evaluated (left-to-right or right-to-left).

int x = 2 + 3 * 4; // Multiplication has higher precedence than addition
// Evaluated as: 2 + (3 * 4) = 14

int y = 10 - 5 - 2; // Subtraction is left-associative
// Evaluated as: (10 - 5) - 2 = 3

8.2. Arithmetic Operators

Arithmetic operators perform basic arithmetic operations.

+: Addition
-: Subtraction
*: Multiplication
/: Division
%: Modulus (remainder)

int a = 10;
int b = 3;
int sum = a + b;       // 13
int difference = a - b;  // 7
int product = a * b;     // 30
int quotient = a / b;    // 3
int remainder = a % b;   // 1

8.3. Remainder and Exponentiation

The modulus operator (%) returns the remainder of a division. C++ does not have a built-in exponentiation operator, but you can use the pow() function from the <cmath> library.

#include <iostream>
#include <cmath>

int main() {
    int a = 10;
    int b = 3;
    int remainder = a % b; // 1

    double base = 2.0;
    double exponent = 3.0;
    double result = pow(base, exponent); // 8.0

    std::cout << "Remainder: " << remainder << std::endl;
    std::cout << "2^3 = " << result << std::endl;

    return 0;
}

8.4. Increment/Decrement Operators, and Side Effects

++: Increment (adds 1 to the operand)
--: Decrement (subtracts 1 from the operand)

These operators can be used in prefix or postfix form.

int x = 5;
int y = ++x; // Prefix: x is incremented first, then assigned to y (x = 6, y = 6)
int z = x++; // Postfix: x is assigned to z first, then incremented (z = 6, x = 7)

8.5. The Comma Operator

The comma operator evaluates two expressions and returns the value of the second expression. It’s often used in for loops.

int a, b;
a = (b = 3, b + 2); // b is assigned 3, then b + 2 is evaluated and assigned to a (a = 5, b = 3)

8.6. The Conditional Operator

The conditional operator (? :) is a shorthand for an if-else statement.

int age = 20;
std::string message = (age >= 18) ? "Adult" : "Minor";
std::cout << message << std::endl;

8.7. Relational Operators and Floating Point Comparisons

Relational operators compare two values.

==: Equal to
!=: Not equal to
>: Greater than
<: Less than
>=: Greater than or equal to
<=: Less than or equal to

Comparing floating-point numbers directly with == or != can be problematic due to precision issues. Use a small tolerance value to check for approximate equality.

#include <cmath>

bool approximatelyEqual(double a, double b, double tolerance = 1e-5) {
    return std::fabs(a - b) < tolerance;
}

8.8. Logical Operators

Logical operators combine boolean expressions.

&&: Logical AND (true if both operands are true)
||: Logical OR (true if either operand is true)
!: Logical NOT (true if the operand is false)

int age = 20;
bool hasLicense = true;
if (age >= 18 && hasLicense) {
    std::cout << "You can drive." << std::endl;
}

9. Scope, Duration, and Linkage in C++

Understanding scope, duration, and linkage is crucial for managing variables and functions in C++.

9.1. Compound Statements (Blocks)

A compound statement (or block) is a group of statements enclosed in curly braces {}. Blocks create a new scope.


{
    int x = 10; // x is only