Building C++ Projects with Clang Without Build Systems (CMake or Meson)

Introduction

Clang is a powerful compiler that supports the latest C++ standards and optimizations, often preferred for its fast compilation times, excellent diagnostics, and modular architecture. Many C++ projects use build systems like CMake or Meson to manage dependencies and configurations. However, you can compile and build projects directly with Clang without these systems, which is useful for learning, debugging, or setting up lightweight builds.

This guide explores how to use Clang to compile simple programs, manage large projects manually, and enable the latest C++ standards (C++23 and upcoming C++26).

Compiling a Single C++ Source File

For a basic C++ program, Clang can compile a single source file as follows:

clang++ main.cpp -o main

Enabling a Specific C++ Standard (C++20, C++23, C++26)

Clang defaults to an older C++ standard unless specified. Use -std= to enable modern features:

clang++ -std=c++20 main.cpp -o main  # C++20  
clang++ -std=c++23 main.cpp -o main  # C++23  
clang++ -std=c++2b main.cpp -o main  # Experimental C++26 (C++2b)

C++23 Enhancements:

• std::expected for handling errors without exceptions.

• std::mdspan for multi-dimensional array views.

• std::print as a modern replacement for printf.

C++26 (experimental, available in Clang trunk builds):

• Deduction in this pointer.

• Metaclasses (if approved).

• Pattern Matching.

Compiling Multiple Files

For larger projects with multiple source files (main.cpp and helper.cpp):

clang++ main.cpp helper.cpp -o my_program

Using Object Files for Incremental Compilation

Recompiling everything every time is inefficient. Instead, compile each file into object files (.o):

clang++ -c main.cpp -o main.o  
clang++ -c helper.cpp -o helper.o  
clang++ main.o helper.o -o my_program

This speeds up builds because only modified files are recompiled.

Managing Large Projects Without Build Systems

For large projects, you must organize files, headers, and dependencies efficiently.

Project Structure Example:

my_project/
├── src/
│   ├── main.cpp
│   ├── helper.cpp
│   ├── module/
│   │   ├── math.cpp
│   │   ├── physics.cpp
├── include/
│   ├── helper.hpp
│   ├── module/
│   │   ├── math.hpp
│   │   ├── physics.hpp
├── build/

Compiling Using Include Paths (-I)

If header files are in include/, use -I to include them:

clang++ -Iinclude src/main.cpp src/helper.cpp -o my_program

Building with Object Files

To compile only changed files:

clang++ -c -Iinclude src/main.cpp -o build/main.o  
clang++ -c -Iinclude src/helper.cpp -o build/helper.o  
clang++ -c -Iinclude src/module/math.cpp -o build/math.o  
clang++ build/main.o build/helper.o build/math.o -o my_program

Linking Libraries

Many projects depend on external libraries. To link them:

Linking a Standard Library (Math, Threads)

clang++ main.cpp -o my_program -lm -lpthread

Linking a Shared Library (.so or .dll)

For a shared library (e.g., libmylib.so):

clang++ main.cpp -L/path/to/libs -lmylib -o my_program

Linking a Static Library (.a or .lib)

For a static library (e.g., libmylib.a):

clang++ main.cpp /path/to/libmylib.a -o my_program

Enabling Optimizations and Debugging

Optimization Levels:

• -O1, -O2, -O3 → Increasing levels of optimization.

• -Os → Optimized for size.

• -Ofast → Aggressive optimizations, may break strict compliance.

Example:

clang++ -O2 main.cpp -o main

Debugging with -g and -fsanitize

• -g → Adds debugging symbols.

• -fsanitize=address → Detects memory errors.

• -fsanitize=undefined → Detects undefined behavior.

Example:

clang++ -g -fsanitize=address main.cpp -o main

Cross-Compilation with Clang

Compiling for ARM64 (Linux)

clang++ --target=aarch64-linux-gnu main.cpp -o main

Compiling for Windows (From Linux/macOS)

clang++ --target=x86_64-windows-gnu main.cpp -o main.exe

Automating Builds with a Simple Script

For large projects, instead of a build system, use a Makefile or script:

Example: Bash Script (build.sh)

#!/bin/bash
mkdir -p build
clang++ -c -Iinclude src/main.cpp -o build/main.o
clang++ -c -Iinclude src/helper.cpp -o build/helper.o
clang++ -c -Iinclude src/module/math.cpp -o build/math.o
clang++ build/main.o build/helper.o build/math.o -o my_program
echo "Build complete!"

Run it:

chmod +x build.sh
./build.sh

When to Use a Build System (CMake/Meson)

While manual builds work for small and medium projects, using CMake/Meson is beneficial when:

• Managing platform-specific dependencies.

• Handling many source files and configurations.

• Automating compilation across different OSes.

However, understanding how Clang works without a build system is crucial for debugging, learning, and writing efficient scripts.

Conclusion

Clang provides a powerful way to compile C++ projects without a build system. By using clang++ effectively, you can:

• Compile simple and large projects.

• Optimize builds and enable debugging tools.

• Link external libraries.

• Cross-compile for different architectures.

• Automate builds with shell scripts.

This approach is ideal for learning, small projects, and debugging, but for large-scale applications, a build system eventually becomes necessary.