Abseil (absl)

FetchContent Integration

Abseil (abseil-cpp) is Google's open-source collection of C++ library code designed to augment the C++ standard library. It provides battle-tested implementations of strings, containers, synchronization primitives, time utilities, and error handling — all used extensively in Google's production systems.

# CMakeLists.txt — Abseil via FetchContent
cmake_minimum_required(VERSION 3.20)
project(MyApp LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

include(FetchContent)

# Abseil requires setting the C++ standard before fetching
set(ABSL_PROPAGATE_CXX_STD ON)

FetchContent_Declare(abseil-cpp
    GIT_REPOSITORY https://github.com/abseil/abseil-cpp.git
    GIT_TAG        20240722.0    # LTS release
)
FetchContent_MakeAvailable(abseil-cpp)

add_executable(myapp src/main.cpp)
target_link_libraries(myapp PRIVATE
    absl::strings
    absl::flat_hash_map
    absl::status
    absl::statusor
)

Selecting Components

Abseil exposes dozens of fine-grained CMake targets. Link only what you use — each target brings in its dependencies automatically:

# Common Abseil targets grouped by category

# Strings
target_link_libraries(myapp PRIVATE
    absl::strings           # StrCat, StrSplit, StrJoin, string_view utilities
    absl::str_format        # Type-safe printf replacement
    absl::cord              # Efficient large string representation
)

# Containers
target_link_libraries(myapp PRIVATE
    absl::flat_hash_map     # Fast open-addressing hash map
    absl::flat_hash_set     # Fast open-addressing hash set
    absl::node_hash_map     # Pointer-stable hash map
    absl::btree             # B-tree ordered containers
    absl::inlined_vector    # Small-buffer-optimized vector
)

# Error handling
target_link_libraries(myapp PRIVATE
    absl::status            # Status error code + message
    absl::statusor          # Status-or-value return type
)

# Synchronization
target_link_libraries(myapp PRIVATE
    absl::synchronization   # Mutex, CondVar, Notification
    absl::base              # Core utilities, spinlock
)

# Time
target_link_libraries(myapp PRIVATE
    absl::time              # Duration, Time, TimeZone
)

# Hashing
target_link_libraries(myapp PRIVATE
    absl::hash              # Extensible hashing framework
)

# Logging (abseil-cpp 20230125+)
target_link_libraries(myapp PRIVATE
    absl::log               # Structured logging
    absl::log_initialize    # Log initialization
)

ABI Compatibility and C++ Standard

Abseil's ABI depends on the C++ standard version used to compile it. Mixing standards across translation units causes subtle runtime bugs:

# CMakeLists.txt — Ensuring consistent C++ standard
cmake_minimum_required(VERSION 3.20)
project(MyApp LANGUAGES CXX)

# CRITICAL: Set standard BEFORE FetchContent
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Propagate standard to Abseil
set(ABSL_PROPAGATE_CXX_STD ON)

# Use LTS releases for stability
include(FetchContent)
FetchContent_Declare(abseil-cpp
    GIT_REPOSITORY https://github.com/abseil/abseil-cpp.git
    GIT_TAG        20240722.0
)
FetchContent_MakeAvailable(abseil-cpp)

# Verify consistency
message(STATUS "Project C++ standard: ${CMAKE_CXX_STANDARD}")
message(STATUS "Abseil propagate std: ${ABSL_PROPAGATE_CXX_STD}")

Abseil with Protobuf

Protocol Buffers (protobuf) v4+ depends on Abseil. When using both in the same project, they must share a single Abseil instance:

# CMakeLists.txt — Abseil + Protobuf shared dependency
cmake_minimum_required(VERSION 3.20)
project(ProtoApp LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(ABSL_PROPAGATE_CXX_STD ON)

include(FetchContent)

# 1. Fetch Abseil first
FetchContent_Declare(abseil-cpp
    GIT_REPOSITORY https://github.com/abseil/abseil-cpp.git
    GIT_TAG        20240722.0
)
FetchContent_MakeAvailable(abseil-cpp)

# 2. Tell Protobuf to use our Abseil
set(protobuf_ABSL_PROVIDER "package" CACHE STRING "" FORCE)
set(ABSL_ROOT_DIR "${abseil-cpp_SOURCE_DIR}" CACHE PATH "" FORCE)

# 3. Fetch Protobuf
FetchContent_Declare(protobuf
    GIT_REPOSITORY https://github.com/protocolbuffers/protobuf.git
    GIT_TAG        v27.3
    GIT_SUBMODULES ""
)
set(protobuf_BUILD_TESTS OFF CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(protobuf)

add_executable(proto_app src/main.cpp)
target_link_libraries(proto_app PRIVATE
    protobuf::libprotobuf
    absl::strings
    absl::status
)

String Utilities

Abseil's string library provides high-performance alternatives to standard string operations:

// src/string_demo.cpp — Abseil string utilities
#include <absl/strings/str_cat.h>
#include <absl/strings/str_split.h>
#include <absl/strings/str_join.h>
#include <absl/strings/str_format.h>
#include <absl/strings/substitute.h>
#include <iostream>
#include <vector>

int main() {
    // StrCat — efficient concatenation (no temporaries)
    std::string greeting = absl::StrCat("Hello, ", "world", "! Count: ", 42);
    std::cout << greeting << "\n";

    // StrSplit — flexible string splitting
    std::vector<std::string> parts = absl::StrSplit("a,b,c,d", ',');
    for (const auto& p : parts) {
        std::cout << "Part: " << p << "\n";
    }

    // StrSplit with predicate (skip empty)
    std::vector<std::string> tokens =
        absl::StrSplit("a,,b,,c", ',', absl::SkipEmpty());

    // StrJoin — join elements with separator
    std::string joined = absl::StrJoin(parts, " | ");
    std::cout << "Joined: " << joined << "\n";

    // StrFormat — type-safe printf
    std::string formatted = absl::StrFormat("%-20s %5d %8.2f", "item", 100, 3.14);
    std::cout << formatted << "\n";

    // Substitute — positional template substitution
    std::string msg = absl::Substitute("$0 has $1 items ($2%)", "Cart", 5, 99.9);
    std::cout << msg << "\n";

    return 0;
}

Containers (flat_hash_map)

Abseil's Swiss Table containers outperform std::unordered_map significantly — often 2-3x faster for lookups due to SIMD-accelerated probing:

// src/container_demo.cpp — Abseil containers
#include <absl/container/flat_hash_map.h>
#include <absl/container/flat_hash_set.h>
#include <absl/container/btree_map.h>
#include <absl/hash/hash.h>
#include <iostream>
#include <string>

// Custom type with Abseil hashing support
struct Endpoint {
    std::string host;
    int port;

    // AbslHashValue friend function for absl::Hash
    template <typename H>
    friend H AbslHashValue(H h, const Endpoint& ep) {
        return H::combine(std::move(h), ep.host, ep.port);
    }

    bool operator==(const Endpoint& other) const {
        return host == other.host && port == other.port;
    }
};

int main() {
    // flat_hash_map — fastest general-purpose hash map
    absl::flat_hash_map<std::string, int> scores;
    scores["Alice"] = 95;
    scores["Bob"] = 87;
    scores.insert({"Charlie", 92});

    for (const auto& [name, score] : scores) {
        std::cout << name << ": " << score << "\n";
    }

    // flat_hash_set — unique elements
    absl::flat_hash_set<int> unique_ids = {1, 2, 3, 4, 5};
    unique_ids.insert(3);  // No-op, already present

    // Custom type as key
    absl::flat_hash_map<Endpoint, std::string> services;
    services[{"localhost", 8080}] = "web";
    services[{"localhost", 5432}] = "postgres";

    // btree_map — ordered, cache-friendly
    absl::btree_map<int, std::string> ordered;
    ordered[3] = "three";
    ordered[1] = "one";
    ordered[2] = "two";

    for (const auto& [key, val] : ordered) {
        std::cout << key << " -> " << val << "\n";  // Sorted output
    }

    return 0;
}

# Link the container targets
target_link_libraries(myapp PRIVATE
    absl::flat_hash_map
    absl::flat_hash_set
    absl::btree
    absl::hash
)

Status and StatusOr

Abseil's Status and StatusOr<T> provide a structured approach to error handling without exceptions — the pattern used throughout Google's codebase:

// src/status_demo.cpp — Abseil Status/StatusOr
#include <absl/status/status.h>
#include <absl/status/statusor.h>
#include <absl/strings/str_cat.h>
#include <fstream>
#include <iostream>
#include <string>

// Return StatusOr for operations that can fail
absl::StatusOr<std::string> readFile(const std::string& path) {
    std::ifstream file(path);
    if (!file.is_open()) {
        return absl::NotFoundError(
            absl::StrCat("File not found: ", path));
    }

    std::string content((std::istreambuf_iterator<char>(file)),
                         std::istreambuf_iterator<char>());

    if (content.empty()) {
        return absl::FailedPreconditionError(
            absl::StrCat("File is empty: ", path));
    }

    return content;
}

absl::StatusOr<int> parseInt(const std::string& str) {
    try {
        size_t pos = 0;
        int value = std::stoi(str, &pos);
        if (pos != str.size()) {
            return absl::InvalidArgumentError(
                absl::StrCat("Trailing characters: '", str, "'"));
        }
        return value;
    } catch (const std::exception& e) {
        return absl::InvalidArgumentError(
            absl::StrCat("Cannot parse '", str, "': ", e.what()));
    }
}

int main() {
    // Pattern 1: Check and use
    absl::StatusOr<std::string> content = readFile("config.txt");
    if (content.ok()) {
        std::cout << "Content: " << *content << "\n";
    } else {
        std::cerr << "Error: " << content.status() << "\n";
    }

    // Pattern 2: Early return on error
    auto result = parseInt("42");
    if (!result.ok()) {
        std::cerr << result.status().message() << "\n";
        return 1;
    }
    std::cout << "Parsed: " << *result << "\n";

    // Pattern 3: Status codes
    absl::Status status = absl::OkStatus();
    std::cout << "Is OK: " << status.ok() << "\n";

    status = absl::DeadlineExceededError("Timeout after 30s");
    std::cout << "Code: " << absl::StatusCodeToString(status.code()) << "\n";
    std::cout << "Message: " << status.message() << "\n";

    return 0;
}

Build Performance Tips

Abseil has many targets and internal dependencies. A full Abseil build from source adds significant time. These strategies minimize the impact:

# CMakeLists.txt — Optimizing Abseil build performance
cmake_minimum_required(VERSION 3.20)
project(FastBuild LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(ABSL_PROPAGATE_CXX_STD ON)

include(FetchContent)

# Tip 1: Disable Abseil tests and examples
set(ABSL_BUILD_TESTING OFF CACHE BOOL "" FORCE)
set(ABSL_BUILD_TEST_HELPERS OFF CACHE BOOL "" FORCE)
set(BUILD_TESTING OFF CACHE BOOL "" FORCE)

# Tip 2: Use SYSTEM to suppress warnings from Abseil headers
FetchContent_Declare(abseil-cpp
    GIT_REPOSITORY https://github.com/abseil/abseil-cpp.git
    GIT_TAG        20240722.0
    SYSTEM          # CMake 3.25+ — marks headers as SYSTEM
)
FetchContent_MakeAvailable(abseil-cpp)

# Tip 3: Only link targets you actually use
add_executable(myapp src/main.cpp)
target_link_libraries(myapp PRIVATE
    absl::strings         # Only what's needed
    absl::flat_hash_map
    absl::status
)
# DON'T link absl::base or other "umbrella" targets unnecessarily

# Tip 4: Use ccache or sccache for repeated builds
export CMAKE_CXX_COMPILER_LAUNCHER=ccache
cmake -B build -DCMAKE_BUILD_TYPE=Release ..

# Tip 5: Parallel compilation (limit jobs if RAM-constrained)
cmake --build build --parallel $(nproc)

# Tip 6: Unity builds reduce Abseil compile time
cmake -B build -DCMAKE_UNITY_BUILD=ON ..