Generate UUID in C++

C++ doesn't have built-in UUID support, but you can use the Boost.UUID library, which is the most popular and comprehensive solution:

#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <iostream>

int main() {
    // Generate UUID version 4 - random
    boost::uuids::random_generator gen;
    boost::uuids::uuid uuid = gen();
    
    std::cout << "Generated UUID: " << uuid << std::endl;
    return 0;
}

For generating specific UUID versions, Boost.UUID provides comprehensive support:

#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <boost/uuid/name_generator.hpp>
#include <iostream>
#include <string>

int main() {
    // Generate UUID version 1 - time based (if available)
    try {
        boost::uuids::basic_random_generator<boost::mt19937> gen;
        boost::uuids::uuid uuid1 = gen();
        std::cout << "UUID v1: " << uuid1 << std::endl;
    } catch (const std::exception& e) {
        std::cout << "UUID v1 not available: " << e.what() << std::endl;
    }

    // Generate UUID version 3 - deterministic and hashed with MD5
    boost::uuids::name_generator_md5 gen3(boost::uuids::ns::url());
    boost::uuids::uuid uuid3 = gen3("https://example.com");
    std::cout << "UUID v3: " << uuid3 << std::endl;

    // Generate UUID version 4 - random
    boost::uuids::random_generator gen4;
    boost::uuids::uuid uuid4 = gen4();
    std::cout << "UUID v4: " << uuid4 << std::endl;

    // Generate UUID version 5 - deterministic and hashed with SHA-1
    boost::uuids::name_generator_sha1 gen5(boost::uuids::ns::url());
    boost::uuids::uuid uuid5 = gen5("https://example.com");
    std::cout << "UUID v5: " << uuid5 << std::endl;

    return 0;
}

Installation & Setup

Using vcpkg (Recommended):

vcpkg install boost-uuid

Using Conan:

conan install boost/1.82.0@

Manual Installation:

# Download and build Boost
wget https://boostorg.jfrog.io/artifactory/main/release/1.82.0/source/boost_1_82_0.tar.gz
tar -xzf boost_1_82_0.tar.gz
cd boost_1_82_0
./bootstrap
./b2 --with-uuid

CMake Integration:

# CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(UUIDExample)

set(CMAKE_CXX_STANDARD 17)

find_package(Boost REQUIRED COMPONENTS uuid)

add_executable(uuid_example main.cpp)
target_link_libraries(uuid_example ${Boost_LIBRARIES})
target_include_directories(uuid_example PRIVATE ${Boost_INCLUDE_DIRS})

Advanced C++ UUID Usage

UUID Utility Class:

#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <boost/uuid/name_generator.hpp>
#include <boost/lexical_cast.hpp>
#include <string>
#include <stdexcept>

class UUIDGenerator {
private:
    static boost::uuids::random_generator random_gen;
    static boost::uuids::name_generator_md5 md5_gen;
    static boost::uuids::name_generator_sha1 sha1_gen;

public:
    // Generate UUID version 4 - random
    static std::string generateV4() {
        return boost::lexical_cast<std::string>(random_gen());
    }

    // Generate UUID version 3 - MD5 namespace
    static std::string generateV3(const std::string& name, 
                                  const boost::uuids::uuid& namespace_uuid = boost::uuids::ns::url()) {
        boost::uuids::name_generator_md5 gen(namespace_uuid);
        return boost::lexical_cast<std::string>(gen(name));
    }

    // Generate UUID version 5 - SHA1 namespace
    static std::string generateV5(const std::string& name, 
                                  const boost::uuids::uuid& namespace_uuid = boost::uuids::ns::url()) {
        boost::uuids::name_generator_sha1 gen(namespace_uuid);
        return boost::lexical_cast<std::string>(gen(name));
    }

    // Parse UUID from string
    static boost::uuids::uuid parse(const std::string& uuid_str) {
        try {
            return boost::lexical_cast<boost::uuids::uuid>(uuid_str);
        } catch (const boost::bad_lexical_cast& e) {
            throw std::invalid_argument("Invalid UUID format: " + uuid_str);
        }
    }

    // Validate UUID string
    static bool isValid(const std::string& uuid_str) {
        try {
            parse(uuid_str);
            return true;
        } catch (const std::invalid_argument&) {
            return false;
        }
    }
};

// Static member definitions
boost::uuids::random_generator UUIDGenerator::random_gen;
boost::uuids::name_generator_md5 UUIDGenerator::md5_gen(boost::uuids::ns::url());
boost::uuids::name_generator_sha1 UUIDGenerator::sha1_gen(boost::uuids::ns::url());

// Usage example
int main() {
    std::cout << "UUID v4: " << UUIDGenerator::generateV4() << std::endl;
    std::cout << "UUID v3: " << UUIDGenerator::generateV3("example.com") << std::endl;
    std::cout << "UUID v5: " << UUIDGenerator::generateV5("example.com") << std::endl;

    std::string uuid_str = UUIDGenerator::generateV4();
    std::cout << "Valid UUID: " << std::boolalpha << UUIDGenerator::isValid(uuid_str) << std::endl;

    return 0;
}

Modern C++17/20 Usage:

#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <iostream>
#include <optional>
#include <string_view>

class ModernUUIDGenerator {
public:
    using UUID = boost::uuids::uuid;
    
    // C++17 structured bindings support
    static auto generateWithMetadata() {
        auto uuid = boost::uuids::random_generator{}();
        auto timestamp = std::chrono::system_clock::now();
        return std::make_tuple(uuid, timestamp);
    }
    
    // C++17 optional for safe parsing
    static std::optional<UUID> tryParse(std::string_view uuid_str) noexcept {
        try {
            return boost::lexical_cast<UUID>(std::string(uuid_str));
        } catch (...) {
            return std::nullopt;
        }
    }
    
    // C++20 concepts (if available)
    template<typename T>
    requires std::convertible_to<T, std::string>
    static UUID generateFromName(T&& name) {
        boost::uuids::name_generator_sha1 gen(boost::uuids::ns::url());
        return gen(std::forward<T>(name));
    }
};

int main() {
    // C++17 structured bindings
    auto [uuid, timestamp] = ModernUUIDGenerator::generateWithMetadata();
    std::cout << "UUID: " << uuid << std::endl;
    
    // C++17 optional usage
    if (auto parsed = ModernUUIDGenerator::tryParse("invalid-uuid")) {
        std::cout << "Parsed: " << *parsed << std::endl;
    } else {
        std::cout << "Failed to parse UUID" << std::endl;
    }
    
    return 0;
}

Thread-Safe UUID Generation:

#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <thread>
#include <mutex>
#include <vector>
#include <iostream>

class ThreadSafeUUIDGenerator {
private:
    static std::mutex mtx;
    static boost::uuids::random_generator gen;

public:
    static std::string generate() {
        std::lock_guard<std::mutex> lock(mtx);
        return boost::lexical_cast<std::string>(gen());
    }
};

std::mutex ThreadSafeUUIDGenerator::mtx;
boost::uuids::random_generator ThreadSafeUUIDGenerator::gen;

void generateUUIDs(int count) {
    for (int i = 0; i < count; ++i) {
        std::cout << "Thread " << std::this_thread::get_id() 
                  << ": " << ThreadSafeUUIDGenerator::generate() << std::endl;
    }
}

int main() {
    std::vector<std::thread> threads;
    
    // Create multiple threads
    for (int i = 0; i < 4; ++i) {
        threads.emplace_back(generateUUIDs, 3);
    }
    
    // Wait for all threads to complete
    for (auto& t : threads) {
        t.join();
    }
    
    return 0;
}

Platform-Specific Alternatives

Windows (without Boost):

#include <windows.h>
#include <rpc.h>
#include <iostream>
#include <string>

#pragma comment(lib, "rpcrt4.lib")

std::string generateWindowsUUID() {
    UUID uuid;
    UuidCreate(&uuid);
    
    RPC_CSTR uuidStr;
    UuidToStringA(&uuid, &uuidStr);
    
    std::string result(reinterpret_cast<char*>(uuidStr));
    RpcStringFreeA(&uuidStr);
    
    return result;
}

int main() {
    std::cout << "Windows UUID: " << generateWindowsUUID() << std::endl;
    return 0;
}

Linux (using libuuid):

#include <uuid/uuid.h>
#include <iostream>
#include <string>

std::string generateLinuxUUID() {
    uuid_t uuid;
    uuid_generate(uuid);
    
    char uuid_str[37];
    uuid_unparse(uuid, uuid_str);
    
    return std::string(uuid_str);
}

int main() {
    std::cout << "Linux UUID: " << generateLinuxUUID() << std::endl;
    return 0;
}

UUID Version Comparison

Choose the right version for your C++ application:

• Version 1 - Time-based, includes MAC address
• Version 3 - MD5 namespace-based, deterministic
• Version 4 - Random, most popular choice
• Version 5 - SHA-1 namespace-based, more secure than v3
• Version 6 - Time-ordered, better than v1 for databases
• Version 7 - Modern time-based with improved sorting

For C++ applications:

• Game engines: Use Version 4 for entity and asset identification
• Real-time systems: Consider Version 1 for precise timing requirements
• Database applications: Use Version 6 for optimal indexing performance

How do I generate UUID in other languages?

Systems programming:

• Rust - Memory-safe systems programming
• Go - Cloud-native development

High-level languages:

• JavaScript - crypto.randomUUID() & uuid library
• Python - Built-in uuid module
• Java - java.util.UUID & UuidCreator
• C# - System.Guid & UuidCreator

← Back to Online UUID Generator