class Printer
{
private:
    int some_member;

public:
    Printer() : some_member(0) {}
    void Show()
    {
        std::cout << "Member " << some_member << std::endl;
    }
};

extern "C" void* printer_create();
extern "C" void printer_destroy(void* printer);
extern "C" void printer_show(void* printer);

class Printer
{
private:
    void * printer_handle;
public:
     Printer()
     {
         printer_handle = printer_create();
     }
     ~Printer()
     {
         printer_destroy(printer_handler);
     }
     void Show()
     {
         printer_show(printer_handle);
     }
};

Some *thing = CreateSome();
thing->MakeUserHappy();
thing->Release();

struct IEventListener {
    virtual void OnEventHappened( int errorCode ) = 0;
};

struct MyEventListener: public IEventListener {
    virtual void OnEventHappened( int errorCode ) {
        printf( "event happened\n" );
    }
};

struct EventSource {
    void Register( IEventListener *listener );
    void Unregister( IEventListener *listener );
};

LS>struct IEventListener {
LS>    virtual void OnEventHappened( int errorCode ) = 0;
LS>};

LS>struct MyEventListener: public IEventListener {
LS>    virtual void OnEventHappened( int errorCode ) {
LS>        printf( "event happened\n" );
LS>    }
LS>};

LS>struct EventSource {
LS>    void Register( IEventListener *listener );
LS>    void Unregister( IEventListener *listener );
LS>};

LS>

extern "C" void ieventlistener_oneventhappened(void* self, int errorCode);

extern "C" void my_event_listener_on_event_happened(void* self, int errorCode)
{
    MyEventListener* self_pointer = static_cast<MyEventListener*>(self);
    self_pointer->OnEventHappened(errorCode);
    // ...
}

class CustomCallbackForIEventListener : public IEventListener
{
    void* m_self;
    ONEVENTHAPPENDED_FP m_function;
public:
    virtual void SetSelfPointer(void* pointer)
    {
        m_self = pointer;
    }
    void SetOnEventHappenedPointer(ONEVENTHAPPENDED_FP pointer_to_function) // передается указатель не функцию типа ieventlistener_oneventhappened
    {
        m_function = pointer_to_function;
    }
    virtual void OnEventHappened( int errorCode )
    {
    m_function(m_self, errorCode); // вызываем функцию по указателю на нее, передаем ранее запомненный this на пользовательский объект
    }
};

void f(EventSource *event_source)
{
    MyEventListener* my_event_listener = new MyEventListener();
    CustomCallbackForIEventListener * custom_callback = CreateCustomCallbackForIEventListener();
    custom_callback->SetSelf(&my_event_listener);
    custom_callback->SetOnEventHappenedPointer(my_event_listener_on_event_happened);
    event_source->Register(custom_callback);
}

add_custom_command(
  OUTPUT ${hello_world_SOURCE_DIR}/source/AutoGenWrap.cpp
  COMMAND ${PYTHON_EXECUTABLE} ${hello_world_SOURCE_DIR}/../../../source/Main.py -i ${hello_world_SOURCE_DIR}/hello_world.xml -p ${hello_world_SOURCE_DIR}/hello_world_params.xml -o ${hello_world_SOURCE_DIR}/include -w ${hello_world_SOURCE_DIR}/source/AutoGenWrap.cpp
  MAIN_DEPENDENCY ${hello_world_SOURCE_DIR}/hello_world.xml
  DEPENDS ${hello_world_SOURCE_DIR}/hello_world_params.xml
  WORKING_DIRECTORY ${hello_world_SOURCE_DIR}
)

include_directories(${hello_world_SOURCE_DIR}/source/)

add_library(hello_world SHARED
  ${hello_world_SOURCE_DIR}/source/AutoGenWrap.cpp
  ${hello_world_SOURCE_DIR}/source/PrinterImpl.h
  ${hello_world_SOURCE_DIR}/source/PrinterImpl.cpp
)

cd examples
mkdir build
cd build
cmake -G "Visual Studio 14 2015 Win64" ..

extern "C" ...

TFUNCTION_POINTER1 g_func1 = 0;
TFUNCTION_POINTER2 g_func2 = 0;

#ifdef _WIN32
#include <windows.h>
#else
#include <dl.h>
#endif


struct ModuleInitializer
{
    ModuleInitializer()
    {
#ifdef _WIN32
        m_module = LoaderLibrary("Module.dll");
        g_func1 = GetProcAddress(...);
        g_func2 = GetProcAddress(...);
        ...
 
#else
        m_module = dlopen("libModule.so", RTL_NOW);
        g_func1 = dlsym(...);
        g_func2 = dlsym(...);
        ...
#endif
    }

    ~ModuleInitializer()
    {
        g_func1 = 0;
        g_func2 = 0;
#ifdef _WIN32
        FreeLibrary(m_module);
#else
        dlclose(m_module);
#endif
    }

private:
#ifdef _WIN32
    HMODULE m_module;
#else
    void* m_module;
#endif
};

class Printer
{
private:
    void * printer_handle;
public:
     Printer()
     {
         printer_handle = printer_create();
     }
     ~Printer()
     {
         printer_destroy(printer_handler);
     }
     void Show()
     {
         printer_show(printer_handle);
     }
};

{
    Printer printer_instance;
    printer_instance.Show();
}

    void SetB(const Circular::ClassB& value)
    {
        struct raw_pointer_holder { void* raw_pointer; };
        circular_classa_setb(mObject, reinterpret_cast<const raw_pointer_holder*>(&value)->raw_pointer);
    }

    Circular::ClassBFwdPtr GetB()
    {
        return Circular::ClassBFwdPtr(circular_classa_getb(mObject));
    }

namespace Circular
{
    namespace beautiful_capi
    {
        template<typename WrappedObjType>
        class forward_pointer_holder
        {
            void* m_pointer;
            bool m_object_was_created;
        public:
            explicit forward_pointer_holder(void* pointer)
             : m_object_was_created(false), m_pointer(pointer)
            {
            }
            ~forward_pointer_holder()
            {
                if (m_object_was_created)
                {
                    reinterpret_cast<WrappedObjType*>(this)->~WrappedObjType();
                }
            }
            operator WrappedObjType()
            {
                return WrappedObjType(m_pointer);
            }
            WrappedObjType* operator->()
            {
                m_object_was_created = true;
                return new(this) WrappedObjType(m_pointer);
            }
            void* get_raw_pointer() const
            {
                return m_pointer;
            }
        };
    }
    
    class ClassA;
    typedef beautiful_capi::forward_pointer_holder<ClassA> ClassAFwdPtr;
    class ClassB;
    typedef beautiful_capi::forward_pointer_holder<ClassB> ClassBFwdPtr;
}

    Circular::ClassA a_object; ...
    a_object.GetB()->Show(); // вызов на лету
    Circular::ClassB b_object = a_object.GetB();
    b_object.Show(); // а тут используем точку (".") как обычно

class Printer
{
private:
    void * printer_handle;
public:
     Printer()
     {
         printer_handle = printer_create();
     }
     ~Printer()
     {
         printer_destroy(printer_handler);
     }
     Printer* operator->()
     {
         return this;
     }
     const Printer* operator->() const
     {
         return this;
     }
     void Show()
     {
         printer_show(printer_handle);
     }
};

{
    Printer printer_instance;
    printer_instance->Show();
}

#include <iostream>
#include <cstdlib>
#include "Example.h"

using Example::down_cast;

void show(Example::IShapePtr shape)
{
    shape->Show();
    if (down_cast<Example::IPolygonPtr>(shape)->IsNotNull())
    {
        std::cout << "IPolygon" << std::endl;
        Example::IPolygonPtr polygon = down_cast<Example::IPolygonPtr>(shape);
        std::cout << "number of points = " << polygon->GetPointsCount() << std::endl;
    }
    if (down_cast<Example::ITrianglePtr>(shape)->IsNotNull())
    {
        std::cout << "ITriangle" << std::endl;
        Example::ITrianglePtr triangle = down_cast<Example::ITrianglePtr>(shape);
        triangle->SetPoints(-1, 1, 5, 6, 10, 15);
    }
    if (down_cast<Example::ISquarePtr>(shape)->IsNotNull())
    {
        std::cout << "ISquare" << std::endl;
        Example::ISquarePtr square = down_cast<Example::ISquarePtr>(shape);
        square->SetSize(3.14);
    }
    if (down_cast<Example::ICirclePtr>(shape)->IsNotNull())
    {
        std::cout << "ICircle" << std::endl;
        Example::ICirclePtr circle = down_cast<Example::ICirclePtr>(shape);
        circle->SetRadius(7.77);
    }
}

int main()
{
#if defined(_WIN32) && defined(_DEBUG)
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
    Example::IShapePtr triangle = Example::CreateTriangle();
    Example::IShapePtr shape0(Example::CreateCircle());
    Example::IShapePtr shape1(Example::CreateSquare());

    std::cout << std::endl << "The first pass." << std::endl;
    show(triangle);
    show(shape0);
    show(shape1);

    std::cout << std::endl << "The second pass." << std::endl;
    show(triangle);
    show(shape0);
    show(shape1);

    std::cout << std::endl;
    return EXIT_SUCCESS;
}

struct beautiful_capi_exception_info_t
{
    int code;
    void* object_pointer;
};

*
 * Beautiful Capi generates beautiful C API wrappers for your C++ classes
 * Copyright (C) 2015 Petr Petrovich Petrov
 *
 * This file is part of Beautiful Capi.
 *
 * Beautiful Capi is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Beautiful Capi is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Beautiful Capi.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
#include <iostream>
#include <cstdlib>
#include "Example.h"

int main()
{
    try
    {
        Example::Printer printer;
        Example::ScannerPtr scanner;

        scanner->PowerOn();
        std::cout << "Scanned text: " << scanner->ScanText() << std::endl;
        scanner->PowerOff();

        printer.PowerOn();
        printer.Show("from main()");
        std::cout << "Trying to show null pointer" << std::endl;
        printer.Show(0); // Здесь выбрасывает исключение типа Exception::NullArgument, которое занаследовано от Exception::BadArgument, которое наследовано от Exception::Generic
        printer.PowerOff();
    }
    /* Если закоментировать блок catch для NullArgument, то исключение можно словить как Exception:BadArgument, если и его закоментировать, то словится как Exception:Generic
    /*catch (Exception::NullArgument& null_argument_exception)
    {
        std::cout << "    *** Exception::NullArgument was thrown" << std::endl;
        std::cout << "    " << null_argument_exception.GetErrorText() << std::endl;
        std::cout << "    argument: " << null_argument_exception.GetArgumentName() << std::endl;
    } */ 
    catch (Exception::BadArgument& null_argument_exception)
    {
        std::cout << "    *** Exception::BadArgument was thrown" << std::endl;
        std::cout << "    " << null_argument_exception.GetErrorText() << std::endl;
    }
    catch (Exception::Generic& generic_exception)
    {
        std::cout << "    *** Exception::Generic was thrown" << std::endl;
        std::cout << "    " << generic_exception.GetErrorText() << std::endl;
    }
    catch (const std::exception& exception)
    {
        std::cout << "    *** std::exception was thrown" << std::endl;
        std::cout << "    " << exception.what() << std::endl;
    }
    catch (...)
    {
        std::cout << "    *** Unknown exception was hrown" << std::endl;
    }

    return EXIT_SUCCESS;
}

class CustomPrinterImplementation
{
    std::string mLastPrintedText;
public:
    CustomPrinterImplementation()
    {
        std::cout << "CustomPrinterImplementation ctor" << std::endl;
    }
    ~CustomPrinterImplementation()
    {
        std::cout << "CustomPrinterImplementation ctor" << std::endl;
    }
    void Print(const char* text) // Note that this method is non-virtual
    {
        if (!text)
        {
            // This exception will be correctly passed through the library boundary
            // and will be caught by the library code
            throw Exception::NullArgument();
        }
        mLastPrintedText = std::string(text);
        std::transform(mLastPrintedText.begin(), mLastPrintedText.end(), mLastPrintedText.begin(), toupper);
        std::cout << mLastPrintedText << std::endl;
    }
};

int main()
{
    Example::Person famous_person;
    famous_person.SetFirstName("Isaac");
    famous_person.SetSecondName("Newton");
    famous_person.SetAge(26);
    famous_person.SetMale(true);

    Example::PrinterPtr printing_device = Example::CreateDefaultPrinter();
    famous_person.Dump(printing_device);
    famous_person.Print(printing_device, "Hello World");

    CustomPrinterImplementation my_printer_implementation;
    printing_device = Example::create_callback_for_customprinter(my_printer_implementation);
    famous_person.Dump(printing_device);

    // CustomPrinterImplementation::Print() will throw exception (Exception::NullArgument)
    // and this exception will be caught by the library code
    famous_person.Print(printing_device, 0);

    return EXIT_SUCCESS;
}

GC>

class Printer
{
public:
    void Show() {
        printer_show(this);
    }

    static void * operator new(size_t size) {
        assert(size == sizeof Printer);
        return printer_create();
    }
    
    static void operator delete(void * obj, size_t size) {
        assert(size == sizeof Printer);
        printer_destroy(obj);
    }
};