The C++ source file (.cpp, .cc, .cxx)

The basics

What is a C++ file?

Anatomy

What's inside a C++ file

A C++ file is made of declarations: includes, namespaces, classes and functions, one of which is main. Here is a short program that greets each name given on the command line, part by part.

// greet.cpp: greet everyone named on the command line
#include <iostream>
#include <string>
#include <utility>
#include <vector>

namespace app {

class Greeter {
public:
    explicit Greeter(std::string greeting) : greeting_{std::move(greeting)} {}

    std::string greet(const std::string& name) const
    {
        return greeting_ + ", " + name + "!";
    }

private:
    std::string greeting_;
};

}  // namespace app

int main(int argc, char* argv[])
{
    std::vector<std::string> names(argv + 1, argv + argc);
    if (names.empty()) {
        names.push_back("world");
    }

    const app::Greeter greeter{"Hello"};
    for (const auto& name : names) {
        std::cout << greeter.greet(name) << '\n';
    }
}

1. 1// greet.cpp: …

   A comment

   // runs to the end of the line; /* … */ can span several lines.

2. 2#include <iostream>

   Standard library headers

   C++'s own headers have no extension. Each one makes part of the standard library available: iostream for console output, string, vector, and utility for std::move.

3. 3namespace app { … }

   A namespace

   Keeps names apart: this class is app::Greeter, so it can't clash with a Greeter in a library. Everything in the standard library lives in std.

4. 4class Greeter { public: … private: … };

   A class

   Data and the functions that work on it, in one type. private members can only be used by the class itself. Note the semicolon after the closing brace.

5. 5explicit Greeter(std::string greeting) : greeting_{…} {}

   A constructor

   Runs when an object is created. The member initialiser list after the colon sets greeting_, and std::move hands over the string's memory instead of copying it.

6. 6std::string greet(const std::string& name) const

   A member function

   const std::string& passes the name by reference, without copying it. The const at the end promises not to change the object.

7. 7int main(int argc, char* argv[])

   The entry point

   Every program starts in main. argc counts the command-line arguments and argv holds them; argv[0] is the program's own name.

8. 8std::vector<std::string> names(argv + 1, argv + argc);

   A container from a template

   std::vector is a resizable array; <std::string> says what it holds. It frees its own memory when it goes out of scope, so there's no delete anywhere.

9. 9for (const auto& name : names)

   A range-based for loop

   Visits each element. auto lets the compiler work out the type, and const auto& avoids copying each string.

10. 10std::cout << … << '\n';

    Console output

    << sends values to the standard output stream in turn. '\n' ends the line; std::endl would also flush the stream, which is slower.

11. 11}

    No return statement

    main is the one function that may end without return: reaching the end means return 0, success.

Under the hood

How to compile and run a C++ file

# CMakeLists.txt: describes the build once, for every compiler and IDE
cmake_minimum_required(VERSION 3.20)
project(report LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_executable(report main.cpp stats.cpp)

# then, in a terminal:
#   cmake -S . -B build
#   cmake --build build

Conventions

.cpp vs .cc vs .cxx, and the other C++ extensions

Versions

C++ standards: C++98 to C++26

C++20

Modules: .cppm and .ixx files

Troubleshooting

C++ build errors people hit most, and what they mean

How to

How to open and edit a C++ file

Security

Is it safe to open a C++ file?

Free downloads

Sample C++ files to download

Free sample C++ files for testing compilers, IDEs, syntax highlighting, code viewers and upload filters. Each one compiles with GCC and Clang using -Wall -Wextra -pedantic -std=c++20 without a single warning, and runs.

Loading…

What's inside sample-program.cpp

The file is commented: open it in a text editor and each numbered comment marks one of these parts. Compile it with c++ -std=c++20 sample-program.cpp -o sample-program and run it to see a stock report.

1. Comments 1 and 2: includes and a namespace

   Thirteen standard library headers, and a shop namespace around the program's own names.

2. Comment 3: a class

   shop::Item with private members, a constructor that throws std::invalid_argument for negative stock, and const accessor functions.

3. Comments 4 and 5: a constrained template and std::optional

   A function template limited to floating-point types with the C++20 concept std::floating_point, and a search function that returns std::optional instead of a null pointer.

4. Comments 6 and 7: a vector and an algorithm

   A std::vector of items that manages its own memory, sorted with std::ranges::sort and a projection, largest value first.

5. Comments 8 and 9: output, a lambda and a map

   Aligned columns with <iomanip>, then a lambda that classifies stock levels and a std::map that counts them, read back with structured bindings.

6. Comments 10 to 12: optional, exceptions and the exit status

   Testing an optional before using it, a try/catch that handles the constructor's exception, and return 0.

All sample C++ files

• Commented sample program

  sample-program.cpp · 4.5 KB (4,583 bytes)

  A complete C++20 program that prints a sorted stock report: a class, a namespace, a concept-constrained template, std::optional, std::vector, ranges, a lambda, std::map and exceptions, with numbered comments explaining each part.

  • Checking compilers, IDEs and syntax highlighters on modern C++
  • Teaching the parts of a C++ program
  DownloadOpen

• Hello world

  sample-hello.cpp · 305 bytes

  The classic first C++ program, with build commands for GCC, Clang and MSVC in its comments.

  • A minimal compile test
  • Checking a new toolchain works
  DownloadOpen

• UTF-8 with a byte order mark

  sample-utf8-bom.cpp · 1.9 KB (1,911 bytes)

  Saved as UTF-8 with a BOM (the bytes EF BB BF first), so Microsoft's compiler reads it correctly even without /utf-8. Prints greetings in seven scripts, plus emoji, with their size in bytes and code points, and shows why C++20's u8"…" literals can't go straight to std::cout.

  • Testing how editors, diffs and tools handle a BOM
  • Source-encoding tests across GCC, Clang and MSVC
  DownloadOpen

• C++20 module interface

  sample-module.cppm · 1.4 KB (1,421 bytes)

  A module named greetings with a global module fragment, exported and private functions, and an exported constant. Its comments give the build commands for GCC and Clang, tested with both.

  • Testing tools and build systems on C++20 modules
  • Checking that a viewer or filter recognises the `.cppm` extension
  DownloadOpen

• Program that imports the module

  sample-module-main.cpp · 408 bytes

  import greetings; next to a classic #include. Build it together with sample-module.cppm, which must be compiled first.

  • Module build-order tests
  • A minimal `import` example
  DownloadOpen

• 100 KB C++ file

  sample-100kb.cpp · 100 KB (102,400 bytes)

  A constexpr std::array of the first 13,300 prime numbers and a program that checks them with std::ranges algorithms, padded with a comment to exactly 102,400 bytes.

  • Upload and size-limit tests
  • Editor, highlighter and compile-time benchmarks
  DownloadOpen

Ways to test with them

• Standard mode: sample-program.cpp needs C++20 (concepts and ranges). Compile it with -std=c++17 to see what an older standard mode reports.
• Encoding and BOM: run sample-utf8-bom.cpp through your editor, formatter and Git; check the first three bytes survive, and compile it with MSVC with and without /utf-8.
• Modules: build sample-module.cppm and sample-module-main.cpp with your build system to check it orders module builds correctly.
• Upload limits: sample-100kb.cpp is exactly 102,400 bytes, for testing a limit at the boundary.

Free to use for testing, teaching and demos, commercially or not, with no attribution needed. A link back to this page is always appreciated.

Questions

C++ files, frequently asked