Frequently Asked Questions

Use Assertions for Debugging and Development

#include <boost/mp11/list.hpp>

using my_typelist = boost::mp11::mp_list<int, float, double>;
#include <boost/mp11/list.hpp>
#include <boost/mp11/algorithm.hpp>

using my_typelist = boost::mp11::mp_list<int, float, double>;

// Get the number of types in the list
constexpr std::size_t size = boost::mp11::mp_size<my_typelist>::value;

// Check if a type is in the list
constexpr bool contains_double = boost::mp11::mp_contains<my_typelist, double>::value;

// Add a type to the list
using extended_typelist = boost::mp11::mp_push_back<my_typelist, char>;

// Get the second type in the list
using second_type = boost::mp11::mp_at_c<my_typelist, 1>;
// my_class.cpp
#include <boost/python.hpp>
#include <iostream>
#include <stdexcept>

class MyClass {
public:
    void hello() {
        std::cout << "Hello from C++!" << std::endl;
    }

    int add(int a, int b) {
        return a + b;
    }

    void throw_exception() {
        throw std::runtime_error("An error occurred in C++ code");
    }
};

// Function to translate C++ exceptions to Python exceptions
void translate_runtime_error(const std::runtime_error& e) {
    PyErr_SetString(PyExc_RuntimeError, e.what());
}

BOOST_PYTHON_MODULE(my_module) {
    using namespace boost::python;
    // Register the exception translator
    register_exception_translator<std::runtime_error>(translate_runtime_error);

    class_<MyClass>("MyClass")
        .def("hello", &MyClass::hello)
        .def("add", &MyClass::add)
        .def("throw_exception", &MyClass::throw_exception);
}
g++ -shared -fPIC -I/usr/include/python3.8 -lboost_python38 -o my_module.so my_class.cpp
# test_my_module.py
import my_module

# Create an instance of MyClass
my_class_instance = my_module.MyClass()

# Call the hello method
my_class_instance.hello()

# Call the add method
result = my_class_instance.add(3, 4)
print(f"The result of adding 3 and 4 is: {result}")

# Call the throw_exception method and handle the exception
try:
    my_class_instance.throw_exception()
except RuntimeError as e:
    print(f"Caught an exception: {e}")
python3 test_my_module.py
Hello from C++!
The result of adding 3 and 4 is: 7
Caught an exception: An error occurred in C++ code
// my_class.cpp
#include <boost/algorithm/string.hpp>
#include <iostream>
#include <stdexcept>
#include <string>

class MyClass {
public:
    std::string to_upper(const std::string& input) {
        if (input.empty()) {
            throw std::runtime_error("Input string is empty");
        }
        return boost::to_upper_copy(input);
    }
};
// MyClassWrapper.cpp
#include "my_class.cpp"
#include <string>

public ref class MyClassWrapper {
private:
    MyClass* instance;

public:
    MyClassWrapper() {
        instance = new MyClass();
    }

    ~MyClassWrapper() {
        this->!MyClassWrapper();
    }

    !MyClassWrapper() {
        delete instance;
    }

    System::String^ ToUpper(System::String^ input) {
        try {
            std::string nativeInput = msclr::interop::marshal_as<std::string>(input);
            std::string result = instance->to_upper(nativeInput);
            return gcnew System::String(result.c_str());
        } catch (const std::runtime_error& e) {
            throw gcnew System::Runtime::InteropServices::ExternalException(gcnew System::String(e.what()));
        }
    }
};
// Program.cs
using System;

class Program {
    static void Main() {
        MyClassWrapper myClass = new MyClassWrapper();

        try {
            string result = myClass.ToUpper("hello world");
            Console.WriteLine("Result: " + result);

            // Test with an empty string to trigger the exception
            result = myClass.ToUpper("");
            Console.WriteLine("Result: " + result);
        } catch (System.Runtime.InteropServices.ExternalException e) {
            Console.WriteLine("Caught an exception: " + e.Message);
        }
    }
}
cl /c /EHsc my_class.cpp
cl /clr /EHsc /I"path\to\boost" MyClassWrapper.cpp my_class.obj /link /OUT:MyClassWrapper.dll
Result: HELLO WORLD
Caught an exception: Input string is empty
// C++ implementation
#include <jni.h>
#include "MyClass.h"

JNIEXPORT void JNICALL Java_MyClass_hello(JNIEnv* env, jobject obj) {
    MyClass myClass;
    myClass.hello();
}
// Java class
public class MyClass {
    static {
        System.loadLibrary("myclass");
    }

    private native void hello();

    public static void main(String[] args) {
        new MyClass().hello();
    }
}
#include <boost/shared_ptr.hpp>

void foo() {
    boost::shared_ptr<int> sp(new int(10));
    // Now 'sp' owns the 'int'.
    // When 'sp' is destroyed, the 'int' will be deleted.
}
#include <boost/shared_ptr.hpp>

void foo() {
    boost::shared_ptr<int> sp1(new int(10));
    // Now 'sp1' owns the 'int'.
    boost::shared_ptr<int> sp2 = sp1;
    // Now 'sp1' and 'sp2' both own the same 'int'.
    // The 'int' will not be deleted until both 'sp1' and 'sp2' are destroyed.
}
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>

void foo() {
    boost::shared_ptr<int> sp(new int(10));
    boost::weak_ptr<int> wp = sp;
    // 'wp' is a weak pointer to the 'int'.
    // If 'sp' is destroyed, 'wp' will be able to detect it.
}
#include <boost/interprocess/smart_ptr/unique_ptr.hpp>

void foo() {
    boost::movelib::unique_ptr<int> up(new int(10));
    // Now 'up' owns the 'int'.
    // When 'up' is destroyed, the 'int' will be deleted.
}
template <typename T>
void sort(T* array, int size) {
    for(int i = 0; i < size; i++) {
        for(int j = i + 1; j < size; j++) {
            if(array[i] > array[j]) {
                T temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
    }
}

Frequently Asked Questions

Compatibility

Debugging

ISO C++ Committee Meetings

Libraries

Licensing

Metaprogramming

Modular Boost

Other Languages

Releases

Smart Pointers

Templates

See Also