程序代碼如下蓄愁，非常具有自解釋性双炕，這里就不多說了现喳。

CMakeLists.txt

cmake_minimum_required(VERSION 2.6)
project(lexical_cast)

add_definitions(-std=c++14)

include_directories("/usr/local/include")
link_directories("/usr/local/lib")
file( GLOB APP_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
foreach( sourcefile ${APP_SOURCES} )
    file(RELATIVE_PATH filename ${CMAKE_CURRENT_SOURCE_DIR} ${sourcefile})
    string(REPLACE ".cpp" "" file ${filename})
    add_executable(${file} ${sourcefile})
    target_link_libraries(${file} boost_filesystem boost_thread boost_system boost_serialization pthread boost_chrono)
endforeach( sourcefile ${APP_SOURCES} )

utils/tasks_processor_base.hpp

#ifndef _CHAPTOR06_02_TASKS_PROCESSOR_BASE_HPP_
#define _CHAPTOR06_02_TASKS_PROCESSOR_BASE_HPP_
#include <boost/noncopyable.hpp>
#include <boost/thread/thread.hpp>
#include <boost/asio/io_service.hpp>

#include <iostream>

namespace detail {
    template <class T>
    struct task_wrapped {
        private:
            T task_unwrapped_;
    
        public:
            explicit task_wrapped(const T& task_unwrapped): task_unwrapped_(task_unwrapped) {}

            void operator()() const {
                // 設(shè)置中斷點(diǎn)抹恳，線程會(huì)在中斷點(diǎn)退出
                try {
                    boost::this_thread::interruption_point();
                } catch (const boost::thread_interrupted&) {}

                try {
                    // 執(zhí)行task
                    task_unwrapped_();
                } catch (const std::exception& e) {
                    std::cerr << "Exception: " << e.what() << '\n';
                } catch (const boost::thread_interrupted&) {
                    std::cerr << "Thread Interrupted...\n"; 
                } catch(...) {
                    std::cerr << "Unknown exception...\n";
                }
            }
    };

    template <class T>
    inline task_wrapped<T> make_task_wrapped(const T& task_unwrapped) {
        return task_wrapped<T>(task_unwrapped);
    }
}; // namespace detail

namespace tp_base {
    class tasks_processor: private boost::noncopyable {
        protected:
            boost::asio::io_service ios_;
            boost::asio::io_service::work work_;
        
            tasks_processor(): ios_(),
                work_(ios_) 
            {}

        public:
            static tasks_processor& get();

            template <class T>
            inline void push_task(const T& task_unwrapped) {
                ios_.post(detail::make_task_wrapped(task_unwrapped));
            }

            void start() {
                ios_.run();
            }

            void stop() {
                ios_.stop();
            }
    };

    tasks_processor& tasks_processor::get() {
        static tasks_processor proc;
        return proc;
    }
}; // namespace tp_base


#endif

main.cpp

#include "utils/tasks_processor_base.hpp"

#include <boost/exception_ptr.hpp>
#include <boost/lexical_cast.hpp>
#include <stdexcept>

using namespace tp_base;

// 前向聲明
void func_test2();

void process_exception(const boost::exception_ptr& exec_ptr) {
    try {
        boost::rethrow_exception(exec_ptr);
    } catch(const boost::bad_lexical_cast& /*e*/) {
        std::cerr << "Lexical cast exception detected \n";
        tasks_processor::get().push_task(&func_test2);
    } catch(...) {
        std::cerr << "Can not handle such exceptions: \n"
            << boost::current_exception_diagnostic_information()
            << "\n";
        // 停止io_service::run
        tasks_processor::get().stop();
    }
}

void func_test1() {
    try {
        boost::lexical_cast<int>("oops!");
    } catch(...) {
        auto exec = boost::current_exception();
        tasks_processor::get().push_task([exec](){
            process_exception(exec);
        });
    }
}

void func_test2() {
    try {
        BOOST_THROW_EXCEPTION(std::logic_error("Some fatal logic error"));
    } catch(...) {  
        auto exec = boost::current_exception();
        tasks_processor::get().push_task([exec](){
            process_exception(exec);
        });
    }
}

void run_sub_thread_throw(boost::exception_ptr& ptr) {

    
    try {
        boost::lexical_cast<float>("not-a-float");
    } catch(...) {
        ptr = boost::current_exception();
    }
}

int main(int argc, char* argv[]) {
    tasks_processor::get().push_task(&func_test1);
    tasks_processor::get().start();

    boost::exception_ptr ptr;
    boost::thread t([&ptr](){
        run_sub_thread_throw(ptr);
    });
    t.join();

    // 子線程有異常，在主線程中拋出異常
    if(ptr) {
        std::cerr << "bad exception occurred in sub thread\n";
        boost::rethrow_exception(ptr);
    }
}

程序輸出如下知牌，

圖片.png

然后抽了兩個(gè)小時(shí)時(shí)間看了下boost::exception_ptr類和boost::exception類的實(shí)現(xiàn)丹拯，畫了下類圖站超，受益匪淺，以后出問題查源碼可能用的著乖酬。

exception_wrapper的繼承鏈死相，

圖片.png

boost::exception類的構(gòu)造

圖片.png

boost::exception_ptr類的構(gòu)造

圖片.png