C++ examples provide the fastest path to understanding this powerful programming language. Whether someone is writing their first program or building on existing skills, practical code snippets make abstract concepts concrete. This guide covers essential C++ examples ranging from basic syntax to object-oriented programming. Each section includes working code that programmers can copy, modify, and learn from directly.

Basic Syntax and Hello World Example

Every programmer’s journey with C++ starts with the classic “Hello World” program. This simple C++ example demonstrates the fundamental structure of a C++ program.

#include <iostream>
 
 
 int main() {
 
 std::cout << "Hello, World." << std::endl:
 
 return 0:
 
 }
 

Let’s break down what each line does:

• #include <iostream> tells the compiler to include the input/output stream library
• int main() defines the main function where program execution begins
• std::cout sends output to the console
• return 0 indicates the program completed successfully

The std:: prefix refers to the standard namespace. Many C++ examples use using namespace std: at the top to avoid typing this prefix repeatedly. But, explicitly using std:: is considered better practice for larger projects.

Here’s a slightly expanded C++ example that takes user input:

#include <iostream>
 #include <string>
 
 
 int main() {
 
 std::string name:
 
 std::cout << "Enter your name: ":
 
 std::cin >> name:
 
 std::cout << "Hello, " << name << "." << std::endl:
 
 return 0:
 
 }
 

This program stores user input in a string variable and displays a personalized greeting.

Working With Variables and Data Types

Variables store data that programs manipulate. C++ offers several built-in data types, and understanding them is crucial for writing effective code.

Here are the most common C++ examples of variable declarations:

#include <iostream>
 
 
 int main() {
 
 int age = 25: // Integer
 
 double salary = 55000.50: // Decimal number
 
 char grade = 'A': // Single character
 
 bool isEmployed = true: // Boolean (true/false)
 
 std::string city = "Seattle": // Text string
 
 
 std::cout << "Age: " << age << std::endl:
 
 std::cout << "Salary: $" << salary << std::endl:
 
 std::cout << "Grade: " << grade << std::endl:
 
 std::cout << "Employed: " << isEmployed << std::endl:
 
 std::cout << "City: " << city << std::endl:
 
 
 return 0:
 
 }
 

C++ is a statically-typed language. This means programmers must declare the type of each variable before using it. The compiler checks these types and catches errors before the program runs.

Constants prevent accidental modification of values:

 const double PI = 3.14159:
 
 const int MAX_USERS = 100:
 

Using const makes code safer and clearer about programmer intent.

Control Flow Examples: Conditionals and Loops

Control flow statements determine which code executes and how often. These C++ examples show the essential patterns every programmer needs.

If-Else Statements

#include <iostream>
 
 
 int main() {
 
 int score = 85:
 
 
 if (score >= 90) {
 
 std::cout << "Grade: A" << std::endl:
 
 } else if (score >= 80) {
 
 std::cout << "Grade: B" << std::endl:
 
 } else if (score >= 70) {
 
 std::cout << "Grade: C" << std::endl:
 
 } else {
 
 std::cout << "Grade: F" << std::endl:
 
 }
 
 
 return 0:
 
 }
 

For Loops

For loops work best when the number of iterations is known:

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

While Loops

While loops continue until a condition becomes false:

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

Switch Statements

Switch statements handle multiple specific cases efficiently:

 int day = 3:
 
 switch (day) {
 
 case 1: std::cout << "Monday": break:
 
 case 2: std::cout << "Tuesday": break:
 
 case 3: std::cout << "Wednesday": break:
 
 default: std::cout << "Other day":
 
 }
 

These control flow C++ examples form the building blocks of program logic.

Functions and Parameter Passing

Functions organize code into reusable blocks. They make programs easier to read, test, and maintain.

Here’s a basic C++ example of a function:

#include <iostream>
 
 
 int add(int a, int b) {
 
 return a + b:
 
 }
 
 
 int main() {
 
 int result = add(5, 3):
 
 std::cout << "Sum: " << result << std::endl:
 
 return 0:
 
 }
 

C++ supports different ways to pass parameters:

Pass by Value

The function receives a copy of the argument:

 void doubleValue(int x) {
 
 x = x * 2: // Only modifies the copy
 
 }
 

Pass by Reference

The function receives access to the original variable:

 void doubleValue(int &x) {
 
 x = x * 2: // Modifies the original
 
 }
 

The & symbol creates a reference. This approach avoids copying large objects and allows functions to modify caller variables.

Function Overloading

C++ allows multiple functions with the same name but different parameters:

 int multiply(int a, int b) {
 
 return a * b:
 
 }
 
 
 double multiply(double a, double b) {
 
 return a * b:
 
 }
 

The compiler selects the correct function based on argument types. This feature makes C++ examples more flexible and intuitive.

Object-Oriented Programming Basics

Object-oriented programming (OOP) organizes code around objects that contain data and behavior. C++ examples using classes demonstrate this powerful paradigm.

#include <iostream>
 #include <string>
 
 
 class Car {
 
 private:
 
 std::string brand:
 
 int year:
 
 
 public:
 
 // Constructor
 
 Car(std::string b, int y) {
 
 brand = b:
 
 year = y:
 
 }
 
 
 // Method
 
 void displayInfo() {
 
 std::cout << year << " " << brand << std::endl:
 
 }
 
 
 // Getter
 
 std::string getBrand() {
 
 return brand:
 
 }
 
 }:
 
 
 int main() {
 
 Car myCar("Toyota", 2023):
 
 myCar.displayInfo():
 
 std::cout << "Brand: " << myCar.getBrand() << std::endl:
 
 return 0:
 
 }
 

This C++ example shows key OOP concepts:

• Classes define blueprints for objects
• Private members hide internal data
• Public methods provide controlled access
• Constructors initialize objects

Inheritance

Classes can inherit from other classes:

 class ElectricCar : public Car {
 
 private:
 
 int batteryCapacity:
 
 
 public:
 
 ElectricCar(std::string b, int y, int battery)
 
 : Car(b, y), batteryCapacity(battery) {}
 
 }:
 

Inheritance promotes code reuse and creates logical hierarchies between related classes.