Beginner's Guide to C++

March 18, 2025 · 20 min read

Setting up your Environment #

Installing a Compiler (g++, Clang) #

To compile and run C++ code, you need a compiler. A compiler translates your human-readable code into machine-readable instructions that your computer can execute. Two popular and free compilers are g++ and Clang.

g++: G++ is the GNU Compiler Collection’s C++ compiler. It’s widely available and a good default choice. Installation methods vary depending on your operating system:

Linux (e.g., Ubuntu): Open a terminal and use your distribution’s package manager. For Ubuntu/Debian, use: sudo apt-get update && sudo apt-get install g++
macOS: Install Xcode from the Mac App Store. This includes the Clang compiler (which can also compile C++), but you can also install g++ using Homebrew (brew install gcc).
Windows: Download and install MinGW (Minimalist GNU for Windows), which includes g++. Cygwin is another option providing a Linux-like environment on Windows.

Clang: Clang is another powerful compiler known for its helpful error messages. Its installation is similar to g++:

Linux: Use your distribution’s package manager (e.g., sudo apt-get install clang++ on Ubuntu/Debian).
macOS: Xcode includes Clang.
Windows: You can install Clang through vcpkg or by using a pre-built binary from the LLVM project website.

After installation, verify your compiler is working correctly by opening your terminal or command prompt and typing g++ --version (for g++) or clang++ --version (for Clang). You should see version information printed to the console.

Choosing an IDE (VS Code, Code::Blocks, CLion) #

An Integrated Development Environment (IDE) provides tools to make coding easier. Popular choices for C++ include:

VS Code (Visual Studio Code): A free, lightweight, and versatile editor with excellent C++ support through extensions (like the C/C++ extension from Microsoft). It’s highly customizable and works across multiple operating systems.
Code::Blocks: A free, open-source IDE specifically designed for C++. It’s relatively simple to use and a good choice for beginners.
CLion: A powerful, commercial IDE from JetBrains. It offers advanced features like code completion, debugging, and refactoring, but it requires a license. It’s a good option if you need professional-grade tools.

The best IDE for you depends on your preferences and project complexity. VS Code is an excellent starting point due to its flexibility and large community support.

Writing your first C++ program #

Let’s create a simple “Hello, world!” program. Create a new file named hello.cpp and paste the following code:

#include <iostream>

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

This program includes the iostream library (for input/output), defines a main function (where the program starts), prints “Hello, world!” to the console using std::cout, and returns 0 to indicate successful execution.

Understanding the compilation process #

To compile and run your C++ code:

Compilation: Use your compiler to translate the .cpp file into an executable. For g++, the command is typically: g++ hello.cpp -o hello (this creates an executable named hello). For Clang, use: clang++ hello.cpp -o hello
Linking: The compiler links necessary libraries (like iostream in our example).
Execution: Run the executable by typing its name in the terminal: ./hello (on Linux/macOS) or hello.exe (on Windows).

The compilation process transforms your source code into a format the computer can understand and execute. Errors during compilation will be reported by the compiler, helping you identify and fix problems in your code. If the compilation is successful, you’ll see the output (“Hello, world!”) printed to the console.

Basic Syntax and Data Types #

Hello, World! program explained #

Let’s revisit the “Hello, world!” program and break down its components:

#include <iostream>

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

#include <iostream>: This line is a preprocessor directive. It includes the iostream library, which provides input/output functionalities (like printing to the console).
int main() { ... }: This is the main function, the entry point of your program. Execution begins here. int indicates that the function will return an integer value.
std::cout << "Hello, world!" << std::endl;: This line prints “Hello, world!” to the console. std::cout is the standard output stream (usually your console). << is the insertion operator, sending the string “Hello, world!” to std::cout. std::endl inserts a newline character, moving the cursor to the next line.
return 0;: This line returns the value 0 to the operating system, indicating that the program executed successfully. A non-zero return value usually signifies an error.

Variables and Data Types (int, float, double, char, bool) #

Variables are named storage locations that hold data. Data types specify the kind of data a variable can store:

int: Stores integers (whole numbers), e.g., 10, -5, 0.
float: Stores single-precision floating-point numbers (numbers with decimal points), e.g., 3.14, -2.5.
double: Stores double-precision floating-point numbers (higher precision than float), e.g., 3.14159265359.
char: Stores a single character, e.g., 'A', 'b', '%'. Characters are enclosed in single quotes.
bool: Stores a Boolean value, either true or false.

Example:

int age = 30;
float price = 99.99;
double pi = 3.14159265359;
char initial = 'J';
bool isAdult = true;

Constants and Literals #

Constants are values that cannot be changed during program execution. Literals are the values you directly write in your code.

const int MAX_VALUE = 100; // MAX_VALUE is a constant
int x = 10; // 10 is an integer literal
float y = 3.14; // 3.14 is a floating-point literal

The const keyword makes a variable a constant.

Operators (Arithmetic, Assignment, Comparison) #

C++ supports various operators:

Arithmetic Operators: + (addition), - (subtraction), * (multiplication), / (division), % (modulo – remainder of a division).
Assignment Operators: = (assignment), +=, -=, *=, /=, %=, etc. (compound assignment operators).
Comparison Operators: == (equal to), != (not equal to), > (greater than), < (less than), >= (greater than or equal to), <= (less than or equal to).

Example:

int a = 10;
int b = 5;
int sum = a + b;       // sum = 15
int difference = a - b; // difference = 5
int product = a * b;    // product = 50
int quotient = a / b;   // quotient = 2
int remainder = a % b;  // remainder = 0
bool isEqual = (a == b); // isEqual = false

Basic Input/Output (cin, cout) #

std::cout sends output to the console, as shown in the “Hello, world!” example. std::cin reads input from the console.

#include <iostream>
#include <string> //Needed for using strings

int main() {
  std::string name;
  int age;

  std::cout << "Enter your name: ";
  std::cin >> name; //Reads input into the name variable

  std::cout << "Enter your age: ";
  std::cin >> age; //Reads input into the age variable


  std::cout << "Hello, " << name << "! You are " << age << " years old." << std::endl;
  return 0;
}

std::cin extracts data from the input stream and stores it in the variables. Note the use of std::string for handling text input. Remember to include the <string> header when using strings.

Control Flow #

Control flow statements determine the order in which statements are executed in a program. They allow you to create programs that make decisions and repeat actions.

if, else if, else statements #

if, else if, and else statements allow you to execute different blocks of code based on conditions.

int age = 20;

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

The code within an if block is executed only if the condition is true. else if allows you to check multiple conditions sequentially. else provides a default block executed if none of the preceding conditions are true. Note the use of && (logical AND) to combine conditions.

switch statements #

switch statements provide a more concise way to handle multiple conditions based on the value of an integer or character expression.

char grade = 'B';

switch (grade) {
  case 'A':
    std::cout << "Excellent!" << std::endl;
    break;
  case 'B':
    std::cout << "Good!" << std::endl;
    break;
  case 'C':
    std::cout << "Fair." << std::endl;
    break;
  default:
    std::cout << "Needs improvement." << std::endl;
}

The switch expression is evaluated, and the code corresponding to the matching case label is executed. The break statement is crucial; it prevents the code from “falling through” to the next case. default handles cases not explicitly covered.

for loops #

for loops are used to repeat a block of code a specific number of times.

for (int i = 0; i < 10; i++) {
  std::cout << i << " ";
}
std::cout << std::endl;

The loop initializes a counter variable (i), specifies a condition for the loop to continue (i < 10), and defines an increment/decrement for the counter (i++).

while loops #

while loops repeat a block of code as long as a condition is true.

int count = 0;
while (count < 5) {
  std::cout << count << " ";
  count++;
}
std::cout << std::endl;

The condition is checked at the beginning of each iteration. If it’s initially false, the loop body won’t execute at all.

do-while loops #

do-while loops are similar to while loops, but the condition is checked at the end of each iteration. This guarantees that the loop body executes at least once.

int count = 0;
do {
  std::cout << count << " ";
  count++;
} while (count < 5);
std::cout << std::endl;

The loop body executes, then the condition is checked. If true, the loop continues; otherwise, it terminates.

break and continue statements #

break and continue statements modify the flow of loops:

break: Immediately exits the loop (or switch statement).
continue: Skips the rest of the current iteration and proceeds to the next iteration.

for (int i = 0; i < 10; i++) {
  if (i == 5) {
    continue; // Skip i=5
  }
  if (i == 8) {
    break; // Exit the loop at i=8
  }
  std::cout << i << " ";
}
std::cout << std::endl;

This example will print 0 1 2 3 4 6 7. The iteration for i=5 is skipped, and the loop terminates when i reaches 8.

Functions #

Functions are reusable blocks of code that perform specific tasks. They improve code organization, readability, and reusability.

Defining and calling functions #

A function is defined by its return type, name, parameters (inputs), and body (code).

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

int main() {
  int sum = add(5, 3); // Function call
  std::cout << "Sum: " << sum << std::endl; // Output: Sum: 8
  return 0;
}

The add function takes two integer parameters (a and b), adds them, and returns the result. The main function calls add and stores the returned value in sum.

Function parameters and return values #

Parameters are values passed to a function. Return values are the results sent back by a function. A function can have multiple parameters but only one return value (although you can return a composite type like a struct or class). If a function doesn’t return a value, its return type is void.

void greet(std::string name) {
  std::cout << "Hello, " << name << "!" << std::endl;
}

int main() {
  greet("Alice"); // Function call with a string parameter. No return value.
  return 0;
}

Function overloading #

Function overloading allows you to define multiple functions with the same name but different parameter lists. The compiler determines which function to call based on the arguments provided.

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

int main() {
  int sumInt = add(5, 3);       // Calls int add(int, int)
  double sumDouble = add(2.5, 1.7); // Calls double add(double, double)
  return 0;
}

Pass by value vs. Pass by reference #

Pass by value: A copy of the argument’s value is passed to the function. Changes made to the parameter within the function do not affect the original variable.
Pass by reference: The function receives a reference to the original variable. Changes made to the parameter affect the original variable. References are declared using &.

void passByValue(int x) { x = 100; } // Changes x only within the function.

void passByReference(int &x) { x = 100; } // Changes the original x.

int main() {
  int a = 50;
  passByValue(a);
  std::cout << "Pass by value: " << a << std::endl; // Output: 50

  int b = 50;
  passByReference(b);
  std::cout << "Pass by reference: " << b << std::endl; // Output: 100
  return 0;
}

Default arguments #

Default arguments provide default values for function parameters. If a caller omits an argument, the default value is used.

void greet(std::string name, std::string greeting = "Hello") {
  std::cout << greeting << ", " << name << "!" << std::endl;
}

int main() {
  greet("Bob");             // Uses default greeting "Hello"
  greet("Alice", "Greetings"); // Uses specified greeting
  return 0;
}

Default arguments must be placed at the end of the parameter list.

Arrays and Strings #

Declaring and initializing arrays #

Arrays are contiguous blocks of memory that store elements of the same data type. They are declared using the following syntax:

dataType arrayName[arraySize];

int numbers[5]; // Declares an array named 'numbers' that can hold 5 integers.
int scores[] = {85, 92, 78, 95, 88}; // Declares and initializes an array.  The compiler determines the size.

You can initialize arrays during declaration by providing values within curly braces {}. If you don’t specify a size when initializing with values, the compiler automatically determines the size based on the number of elements.

Accessing array elements #

Array elements are accessed using their index, which starts at 0. For example, numbers[0] accesses the first element, numbers[1] the second, and so on.

int scores[] = {85, 92, 78, 95, 88};
std::cout << "First score: " << scores[0] << std::endl; // Accesses the first element (85)
std::cout << "Last score: " << scores[4] << std::endl;  // Accesses the last element (88)

//Attempting to access an element outside the array bounds will lead to undefined behavior (a common source of errors)
//std::cout << scores[5] << std::endl; //This will cause an error.

Accessing an element outside the array’s bounds (e.g., scores[5] in the example above) leads to undefined behavior and is a common source of errors. Always ensure your array index is within the valid range [0, arraySize -1].

Multi-dimensional arrays #

Multi-dimensional arrays are arrays of arrays. They are used to represent tables or matrices.

int matrix[3][4] = {
  {1, 2, 3, 4},
  {5, 6, 7, 8},
  {9, 10, 11, 12}
};

std::cout << "Element at [1][2]: " << matrix[1][2] << std::endl; // Accesses element 7

This creates a 3x4 matrix. matrix[i][j] accesses the element at row i and column j.

Introduction to strings #

Strings are sequences of characters. In C++, strings are typically represented using the std::string class from the <string> header file.

#include <string>
#include <iostream>

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

The std::string class provides various methods for string manipulation.

String manipulation (basic operations) #

The std::string class offers many useful methods for string manipulation:

#include <string>
#include <iostream>

int main() {
    std::string str = "Hello";

    str += " world!"; // Concatenation
    std::cout << str << std::endl; // Output: Hello world!

    size_t len = str.length(); // Get string length
    std::cout << "Length: " << len << std::endl; //Output: Length: 12

    std::string substr = str.substr(6, 5); // Extract a substring ("world")
    std::cout << "Substring: " << substr << std::endl; // Output: Substring: world

    str.replace(6,5,"C++"); //Replace "world" with "C++"
    std::cout << str << std::endl; // Output: Hello C++!

    return 0;
}

This demonstrates concatenation (+=), length (length()), substring extraction (substr()), and string replacement (replace()). The <string> header provides many more useful string functions. Remember to #include <string> when working with strings.

Pointers #

Pointers are variables that store memory addresses. Understanding pointers is crucial for working with dynamic memory allocation and understanding how C++ manages memory.

Understanding pointers #

Every variable in C++ is stored in a specific location in the computer’s memory. A pointer holds the memory address of another variable. Think of it like a street address that tells you where a house (variable) is located.

Declaration and initialization of pointers #

Pointers are declared using the * operator before the variable name. The data type of the pointer must match the data type of the variable it points to.

int num = 10;     // An integer variable
int *ptr;        // A pointer to an integer (uninitialized)
ptr = &num;      // ptr now holds the memory address of num. & is the address-of operator.

double price = 99.99;
double *pricePtr = &price; // Declare and initialize a pointer to a double in one line

&num is the address of the variable num. ptr now “points to” num. Note that an uninitialized pointer will hold a garbage value and should not be dereferenced (see below).

Dereferencing pointers #

The * operator, when used with a pointer, dereferences it – it accesses the value stored at the memory address held by the pointer.

int num = 10;
int *ptr = &num;

std::cout << "Value of num: " << num << std::endl;       // Output: 10
std::cout << "Address of num: " << &num << std::endl;     // Output: Memory address of num
std::cout << "Value of ptr: " << ptr << std::endl;       // Output: Memory address of num (same as above)
std::cout << "Value pointed to by ptr: " << *ptr << std::endl; // Output: 10 (dereferencing)

*ptr = 20; // Modifying the value at the address pointed to by ptr.
std::cout << "New value of num: " << num << std::endl;  // Output: 20 (num's value has changed)

Pointer arithmetic #

You can perform arithmetic operations (addition and subtraction) on pointers. However, the increment/decrement is done in terms of the size of the data type the pointer points to.

int numbers[] = {1, 2, 3, 4, 5};
int *ptr = numbers; // ptr points to the first element of the array

std::cout << *ptr << std::endl;  // Output: 1
ptr++;                         // ptr now points to the second element
std::cout << *ptr << std::endl;  // Output: 2
ptr += 2;                        // ptr now points to the fourth element
std::cout << *ptr << std::endl;  // Output: 4

Incrementing ptr moves it to the next integer in memory.

Pointers and arrays #

In C++, array names decay to pointers to their first element in many contexts. This means that an array name can often be used interchangeably with a pointer to its first element.

int numbers[] = {10, 20, 30};
int *ptr = numbers; // Equivalent to int *ptr = &numbers[0];

std::cout << *ptr << std::endl;  // Output: 10
std::cout << *(ptr + 1) << std::endl; // Output: 20 (pointer arithmetic)
std::cout << numbers[2] << std::endl; // Output: 30 (array indexing)

This shows the close relationship between pointers and arrays in C++. However, it’s important to remember that numbers itself is not a pointer; it’s an array. There are subtle differences in behavior in certain situations (like using sizeof()).

Object-Oriented Programming (OOP) Introduction #

Object-Oriented Programming (OOP) is a programming paradigm that organizes code around “objects” rather than functions and logic. Objects contain data (member variables) and functions (member methods) that operate on that data. C++ supports OOP features that allow you to create modular, reusable, and maintainable code.

Classes and Objects #

A class is a blueprint for creating objects. It defines the structure (member variables) and behavior (member methods) of objects of that class. An object is an instance of a class.

class Dog {
public:
  std::string name;
  int age;

  void bark() {
    std::cout << "Woof!" << std::endl;
  }
};

int main() {
  Dog myDog; // Creates an object (instance) of the Dog class
  myDog.name = "Buddy";
  myDog.age = 3;
  myDog.bark(); // Calls the bark() method of myDog
  return 0;
}

Here, Dog is a class, and myDog is an object of the Dog class.

Constructors and Destructors #

Constructors are special member methods that are automatically called when an object is created. They initialize the object’s member variables. Destructors are special member methods automatically called when an object is destroyed (goes out of scope). They are used to perform cleanup tasks.

class Dog {
public:
  std::string name;
  int age;

  // Constructor
  Dog(std::string dogName, int dogAge) : name(dogName), age(dogAge) {}

  // Destructor (optional, automatically called when object is destroyed)
  ~Dog() {
    std::cout << "Dog " << name << " destroyed." << std::endl;
  }

  void bark() {
    std::cout << "Woof!" << std::endl;
  }
};

int main() {
  Dog myDog("Lucy", 5); // Constructor is called here
  myDog.bark();
  return 0; // Destructor is called here (for myDog)
}

The constructor initializes name and age. The destructor prints a message. Note the destructor’s name: ~Dog().

Member variables and methods #

Member variables store the object’s data. Member methods (functions) operate on that data. They provide the object’s behavior. In the Dog example above, name and age are member variables, and bark() is a member method.

Access specifiers (public, private, protected) #

Access specifiers control the accessibility of member variables and methods from outside the class:

public: Members are accessible from anywhere.
private: Members are accessible only from within the class itself.
protected: Members are accessible from within the class and its derived classes (discussed later in inheritance).

class Dog {
private:
  int weight; // Only accessible within the Dog class

public:
  std::string name;
  int age;

  void setWeight(int w) { weight = w; } // Method to set weight (private member)
  int getWeight() const { return weight; } //Method to get weight

  void bark() {
    std::cout << "Woof! I weigh " << weight << "kg" << std::endl;
  }
};

Here, weight is private, so it can only be accessed through the setWeight and getWeight methods. This is an example of encapsulation – hiding internal data and providing controlled access. name and age are public and can be accessed directly. Note that the getWeight() method is declared as const, indicating that it does not modify the object’s state.

Further Learning Resources #

This section provides resources to help you continue your C++ learning journey beyond the beginner’s guide.

Recommended books and online courses #

Several excellent books and online courses offer in-depth C++ instruction:

Books:

“Principles and Practice Using C++” by Bjarne Stroustrup: Written by the creator of C++, this book offers a comprehensive and authoritative guide. It’s a good choice for those who want a deep understanding of the language.
“Effective C++” and “More Effective C++” by Scott Meyers: These books focus on best practices and common pitfalls, helping you write efficient and idiomatic C++ code.
“Effective Modern C++” by Scott Meyers: Covers features introduced in C++11 and later.
“Programming: Principles and Practice Using C++ (2nd Edition)” by Bjarne Stroustrup: A more approachable version of Stroustrup’s original book, good for beginners.

Online Courses:

Coursera and edX: These platforms offer numerous C++ courses from top universities and organizations, ranging from beginner to advanced levels. Search for “C++” to find suitable options.
Udemy: Udemy provides a wide selection of C++ courses, often at various price points.
YouTube: Many channels offer C++ tutorials, often focusing on specific aspects of the language or libraries. Look for channels with high-quality content and positive reviews.

C++ communities and forums #

Connecting with other C++ developers is invaluable for learning and problem-solving:

Stack Overflow: This Q&A site is an excellent resource for finding answers to your C++ questions. Use relevant tags like “c++”, “cpp”, and specific libraries (e.g., “Qt”, “Boost”).
Reddit (r/cpp, r/learnprogramming): These subreddits provide communities for discussing C++ and programming in general.
C++ Forum: Many dedicated C++ forums exist where you can ask questions, share your code, and learn from experienced programmers.

Practice problems and coding challenges #

Practice is key to mastering any programming language. Here are some resources to find practice problems and coding challenges:

LeetCode, HackerRank, Codewars: These websites offer a wide range of coding challenges that test your problem-solving skills. Many problems can be solved using C++. Start with easier problems and gradually increase the difficulty.
Project Euler: This website presents mathematical problems that require programming to solve. It’s an excellent way to improve your algorithmic thinking and programming skills.
Your own projects: The best way to learn is to build something you’re interested in! Start with small projects and gradually increase complexity. Even a simple text-based game can be a great learning experience.

Remember to consistently practice, actively engage in the C++ community, and explore the resources listed above to solidify your understanding of the language and become a proficient C++ programmer.

←

Beginner's Guide to lisp