Boost Macros

#define BOOST_ALL_NO_LIB  // Disable auto-linking

#include <boost/filesystem.hpp>
#include <iostream>

int main() {
    std::cout << "Boost Filesystem is included, but auto-linking is disabled.\n";
}

#include <boost/config.hpp>
#include <iostream>

int main() {
    std::cout << "Detected Standard Library: " << BOOST_STDLIB << std::endl;

#ifdef BOOST_LIBSTD_GNU
    std::cout << "Using GNU libstdc++" << std::endl;
#elif defined(BOOST_LIBSTD_MSVC)
    std::cout << "Using Microsoft STL (MSVC Standard Library)" << std::endl;
#elif defined(BOOST_LIBSTD_LIBCXX)
    std::cout << "Using libc++ (Clang Standard Library)" << std::endl;
#else
    std::cout << "Using an unknown or unsupported standard library" << std::endl;
#endif

    return 0;
}

#include <iostream>
#include <boost/config.hpp>

int main() {
    std::cout << "Platform: " << BOOST_PLATFORM << std::endl;
    std::cout << "Compiler: " << BOOST_COMPILER << std::endl;
    std::cout << "Standard Library: " << BOOST_STDLIB << std::endl;
    return 0;
}

#include <iostream>
#include <boost/version.hpp>

int main() {
    std::cout << "Boost version: "
              << (BOOST_VERSION / 100000) << "."   // Major version
              << (BOOST_VERSION / 100 % 1000) << "." // Minor version
              << (BOOST_VERSION % 100) << std::endl; // Patch version
    return 0;
}

#define BOOST_SP_USE_QUICK_ALLOCATOR // Define before including Boost.SmartPtr

#include <boost/smart_ptr.hpp>
#include <iostream>

int main() {
    boost::shared_ptr<int> ptr1(new int(42));
    boost::shared_ptr<int> ptr2 = ptr1;

    std::cout << "Shared pointer value: " << *ptr1 << std::endl;
    return 0;
}

#include <boost/assert.hpp>
#include <boost/static_assert.hpp>
#include <iostream>

void process(int value) {
    BOOST_ASSERT(value > 0 && "Value must be positive");  // Runtime assertion
}

int main() {
    BOOST_STATIC_ASSERT(sizeof(int) == 4);  // Compile-time assertion

    int x = 10;
    BOOST_VERIFY(x != 0);  // Always checks in release mode

    process(-1);  // Will trigger an assertion failure
}

#define BOOST_ASIO_ENABLE_HANDLER_TRACKING // Enable debugging before including Boost.Asio

#include <boost/asio.hpp>
#include <iostream>

int main() {
    boost::asio::io_context io;
    std::cout << "Boost.Asio handler tracking enabled!\n";
    return 0;
}

#include <boost/preprocessor/repetition/repeat.hpp>
#include <iostream>

#define PRINT_N(z, n, text) std::cout << text << " " << n << "\n";

int main() {
    BOOST_PP_REPEAT(5, PRINT_N, "Iteration");
}

Iteration 0
Iteration 1
Iteration 2
Iteration 3
Iteration 4

#include <iostream>
#include <boost/config.hpp>

int main() {
#ifdef BOOST_WINDOWS
    std::cout << "Running on Windows\n";
#elif defined(BOOST_LINUX)
    std::cout << "Running on Linux\n";
#elif defined(BOOST_UNIX)
    std::cout << "Running on a Unix-like system\n";
#else
    std::cout << "Unknown platform\n";
#endif
}

#include <iostream>
#include <boost/config.hpp>

int main() {
#if defined(BOOST_LITTLE_ENDIAN)
    std::cout << "System is little-endian.\n";
#elif defined(BOOST_BIG_ENDIAN)
    std::cout << "System is big-endian.\n";
#else
    std::cout << "Unknown endianness.\n";
#endif
    return 0;
}

#include <boost/thread.hpp>
#include <iostream>

void threadFunc() {
    std::cout << "Hello from thread!\n";
}

int main() {
#ifdef BOOST_HAS_THREADS
    boost::thread myThread(threadFunc);
    myThread.join();
#else
    std::cout << "Threads are not supported.\n";
#endif
}

#include <boost/exception/exception.hpp>
#include <boost/exception/all.hpp>
#include <iostream>

struct MyException : virtual boost::exception, virtual std::exception {
    const char* what() const noexcept override {
        return "A Boost exception occurred!";
    }
};

void riskyOperation() {
    BOOST_THROW_EXCEPTION(MyException());
}

int main() {
    try {
        riskyOperation();
    } catch (const MyException& e) {
        std::cout << "Caught exception: " << e.what() << "\n";
    }
}

#include <iostream>
#include <boost/config.hpp>

void safe_function() {
#ifndef BOOST_NO_EXCEPTIONS
    throw std::runtime_error("Something went wrong!");
#else
    std::cerr << "Exceptions are disabled. Handling error manually.\n";
#endif
}

int main() {
    try {
        safe_function();
    } catch (const std::exception& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
    }
}