C++ 构造函数失败后初始化boost:：asio套接字

我创建了一个类来广播UDP消息，如下所示：

#define _CRT_SECURE_NO_WARNINGS
#include <ctime>
#include <iostream>
#include <string>
#include <queue>
#include <boost/array.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/asio.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/thread.hpp>
#include <boost/thread/thread.hpp> 
#include <boost/chrono.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

using boost::asio::ip::udp;
using std::cout;
using std::cin;
using std::endl;
using std::string;
using namespace std;

template<typename T>
std::string toString(const T& value);
std::string IntToString(const int& i);

class UdpCore
{
private:
    boost::asio::ip::udp::endpoint endpoint;
    boost::asio::ip::udp::socket socket;

    string multicast_address;
    unsigned short multicast_port;
    boost::thread_group threads;    // thread group
    boost::thread* thread_main;     // main thread
    boost::thread* thread_listen;   // listen thread
    boost::thread* thread_getsend;  // get/send thread
    boost::mutex stopMutex;
    bool initialize = false;
    bool stop, showBroadcast;
    int i_getsend, i_listen, i_main, i_message, interval;
    string message;
public:
    // constructor
    UdpCore(boost::asio::io_service& io_service, std::string multicast_address, unsigned short multicast_port, int interval, bool show = false)
        : endpoint(boost::asio::ip::address::from_string(multicast_address), multicast_port),
        socket(io_service, endpoint.protocol()),
        multicast_address(multicast_address),
        multicast_port(multicast_port),
        interval(interval),
        showBroadcast(show)
    {
        Initialize(io_service, show);
    }

    ~UdpCore()
    {
        // show exit message
        cout << "Exiting UDP Core." << endl;
    }

    // initialize
    void Initialize(boost::asio::io_service& io_service, bool show = false)
    {
        if (initialize == false)
        {
            GetInfo();
        }

        boost::asio::ip::udp::endpoint endpoint(boost::asio::ip::make_address(multicast_address), multicast_port);
        boost::asio::ip::udp::socket socket(io_service, endpoint.protocol());
        socket.set_option(boost::asio::ip::udp::socket::reuse_address(true));   // no need

        thread_main = new boost::thread(boost::ref(*this));
        thread_getsend = new boost::thread(&UdpCore::Callable_GetSend, this, interval, boost::ref(i_listen), boost::ref(message));
        threads.add_thread(thread_getsend); // get/send thread
        stop = false;
        showBroadcast = show;
        i_getsend = 0;
        i_listen = 0;
        i_main = 0;
        i_message = 0;
        message.clear();

        initialize = true;
    }

    void GetInfo()
    {
        multicast_address = "192.168.0.255";
        multicast_port = 13000;
        interval = 500;
    }

    // start the threads
    void Start()
    {
        // Wait till they are finished
        threads.join_all();
    }

    // stop the threads
    void Stop()
    {
        // warning message
        cout << "Stopping all threads." << endl;

        // signal the threads to stop (thread-safe)
        stopMutex.lock();
        stop = true;
        stopMutex.unlock();

        // wait for the threads to finish
        thread_main->interrupt();   // in case not interrupted by operator()
        threads.interrupt_all();
        threads.join_all();

        // close socket after everything closes
        socket.close();
    }

    void Callable_Listen(int interval, int& count)
    {
        while (!stop)
        {
            if (message != "")
                socket.async_send_to(boost::asio::buffer(message), endpoint, [this](boost::system::error_code ec, std::size_t /*length*/)
            {
                stopMutex.lock();
                if (showBroadcast)
                {
                    cout << i_message << " - " << message << endl;  // show  count
                }
                message.clear();    //clear after sending
                stopMutex.unlock();
            });
            ++i_message;

            // wait routine
            boost::this_thread::sleep(boost::posix_time::millisec(interval));
            boost::this_thread::interruption_point();
            ++i_listen;
        }
    }

    void Callable_GetSend(int interval, int& count, string& userInput)
    {
        while (!stop)
        {
            stopMutex.lock();
            cout << "Callable_GetSend [" << count++ << "]. Enter message: ";
            getline(cin, userInput);
            if (message != "")
                socket.async_send_to(boost::asio::buffer(message), endpoint, [this](boost::system::error_code ec, std::size_t /*length*/)
            {
                if (showBroadcast)
                {
                    cout << i_message << " - " << message << endl;  // show  count
                }
                message.clear();    //clear after sending
            });
            stopMutex.unlock();

            // wait routine
            boost::this_thread::sleep(boost::posix_time::millisec(interval));
            boost::this_thread::interruption_point();
            ++i_getsend;
            ++i_message;
        }
    }

    // Thread function
    void operator () ()
    {
        while (!stop)
        {
            if (message == "STOP")
            {
                try
                {
                    this->Stop();
                }
                catch (exception e)
                {
                    cout << e.what() << endl;
                }
            }

            boost::this_thread::sleep(boost::posix_time::millisec(interval));
            boost::this_thread::interruption_point();
        }
    }

    std::string make_daytime_string()
    {
        using namespace std; // For time_t, time and ctime;
        time_t now = time(0);
        std::string result = ctime(&now);
        return result.erase(result.length() - 1, 1);
    }

    std::string some_string()
    {
        std::string result;
        result = make_daytime_string();
        return result;
    }
};

int main()
{
    try
    {
        boost::asio::io_service io_service;
        UdpCore mt(io_service, "192.168.0.255", 13000, 5000, false);
        mt.Start(); 
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception: " << e.what() << "\n";
    }
}

#define _CRT_SECURE_NO_WARNINGS
#include <ctime>
#include <iostream>
#include <string>
#include <queue>
#include <boost/array.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/asio.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/thread.hpp>
#include <boost/thread/thread.hpp> 
#include <boost/chrono.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

using boost::asio::ip::udp;
using std::cout;
using std::cin;
using std::endl;
using std::string;
using namespace std;

template<typename T>
std::string toString(const T& value);
std::string IntToString(const int& i);

class UdpCore
{
private:
    boost::asio::ip::udp::endpoint endpoint;
    boost::shared_ptr<udp::socket> socketPtr;

    string multicast_address;
    unsigned short multicast_port;
    boost::thread_group threads;    // thread group
    boost::thread* thread_main;     // main thread
    boost::thread* thread_listen;   // listen thread
    boost::thread* thread_getsend;  // get/send thread
    boost::mutex stopMutex;
    bool initialize = false;
    bool stop, showBroadcast;
    int i_getsend, i_listen, i_main, i_message, interval;
    string message;
public:
    // constructor
    UdpCore(boost::asio::io_service& io_service, std::string multicast_address, unsigned short multicast_port, int interval, bool show = false)
        : multicast_address(multicast_address),
        multicast_port(multicast_port),
        interval(interval),
        showBroadcast(show)
    {
        UdpCore(io_service, show);
    }

    UdpCore(boost::asio::io_service& io_service, bool show = false)
        : showBroadcast(show)
    {
        Initialize(io_service, show);
    }

    // destructor
    ~UdpCore()
    {
        // show exit message
        cout << "Exiting UDP Core." << endl;
    }

    // initialize
    void Initialize(boost::asio::io_service& io_service, bool show = false)
    {
        if (initialize == false)
        {
            GetInfo();
        }

        boost::asio::ip::udp::endpoint endpoint(boost::asio::ip::address::from_string(multicast_address), multicast_port);
        socketPtr = boost::make_shared<udp::socket>(boost::ref(io_service), endpoint.protocol());
        socketPtr->set_option(boost::asio::ip::udp::socket::reuse_address(true));   // no need

        thread_main = new boost::thread(boost::ref(*this));
        thread_getsend = new boost::thread(&UdpCore::Callable_GetSend, this, interval, boost::ref(i_listen), boost::ref(message));
        threads.add_thread(thread_getsend); // get/send thread
        stop = false;
        showBroadcast = show;
        i_getsend = 0;
        i_listen = 0;
        i_main = 0;
        i_message = 0;
        message.clear();

        initialize = true;
    }

    void GetInfo()
    {
        multicast_address = "192.168.0.255";
        multicast_port = 13000;
        interval = 500;
    }

    // start the threads
    void Start()
    {
        // Wait till they are finished
        threads.join_all();
    }

    // stop the threads
    void Stop()
    {
        // warning message
        cout << "Stopping all threads." << endl;

        // signal the threads to stop (thread-safe)
        stopMutex.lock();
        stop = true;
        stopMutex.unlock();

        // wait for the threads to finish
        thread_main->interrupt();   // in case not interrupted by operator()
        threads.interrupt_all();
        threads.join_all();

        // close socket after everything closes
        socketPtr->close();
    }

    void Callable_Listen(int interval, int& count)
    {
        while (!stop)
        {
            if (message != "")
                socketPtr->async_send_to(boost::asio::buffer(message), endpoint, [this](boost::system::error_code ec, std::size_t /*length*/)
            {
                stopMutex.lock();
                if (showBroadcast)
                {
                    cout << i_message << " - " << message << endl;  // show  count
                }
                message.clear();    //clear after sending
                stopMutex.unlock();
            });
            ++i_message;

            // wait routine
            boost::this_thread::sleep(boost::posix_time::millisec(interval));
            boost::this_thread::interruption_point();
            ++i_listen;
        }
    }

    void Callable_GetSend(int interval, int& count, string& userInput)
    {
        while (!stop)
        {
            stopMutex.lock();
            cout << "Callable_GetSend [" << count++ << "]. Enter message: ";
            getline(cin, userInput);
            if (message != "")
                socketPtr->async_send_to(boost::asio::buffer(message), endpoint, [this](boost::system::error_code ec, std::size_t /*length*/)
            {
                if (showBroadcast)
                {
                    cout << i_message << " - " << message << endl;  // show  count
                }
                message.clear();    //clear after sending
            });
            stopMutex.unlock();

            // wait routine
            boost::this_thread::sleep(boost::posix_time::millisec(interval));
            boost::this_thread::interruption_point();
            ++i_getsend;
            ++i_message;
        }
    }

    // Thread function
    void operator () ()
    {
        while (!stop)
        {
            if (message == "STOP")
            {
                try
                {
                    this->Stop();
                }
                catch (exception e)
                {
                    cout << e.what() << endl;
                }
            }

            boost::this_thread::sleep(boost::posix_time::millisec(interval));
            boost::this_thread::interruption_point();
        }
    }

    std::string make_daytime_string()
    {
        using namespace std; // For time_t, time and ctime;
        time_t now = time(0);
        std::string result = ctime(&now);
        return result.erase(result.length() - 1, 1);
    }

    std::string some_string()
    {
        std::string result;
        result = make_daytime_string();
        return result;
    }
};

int main()
{
    try
    {
        boost::asio::io_service io_service;
        UdpCore mt(io_service, false);
        mt.Start();
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception: " << e.what() << "\n";
    }
}

\define\u CRT\u SECURE\u NO\u警告
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用boost:：asio:：ip:：udp；
使用std：：cout；
使用std：：cin；
使用std：：endl；
使用std:：string；
使用名称空间std；
模板
std：：字符串到字符串（常量T和值）；
std:：string IntToString（const int&i）；
UdpCore类
{
私人：
boost:：asio:：ip:：udp:：endpoint；
boost:：asio:：ip:：udp:：socket；
字符串地址；
无符号短多播_端口；
boost:：thread\u group threads；//线程组
boost:：thread*thread_main；//主线程
boost:：thread*thread\u listen；//listen thread
boost:：thread*thread\u getsend；//获取/发送线程
boost：：mutex stopMutex；
bool初始化=false；
bool-stop，showBroadcast；
int i_getsend、i_listen、i_main、i_message、interval；
字符串消息；
公众：
//建造师
UdpCore（boost:：asio:：io_服务和io_服务，std:：string多播_地址，无符号短多播_端口，int interval，bool show=false）
：端点（boost:：asio:：ip:：address:：from_字符串（多播地址）、多播端口），
套接字（io_服务，endpoint.protocol（）），
多播地址（多播地址），
多播_端口（多播_端口），
间隔(间隔),，
showBroadcast（show）
{
初始化（io_服务，显示）；
}
~UdpCore（）
{
//显示退出消息
cout在第一个示例中，除了成员
端点
和
套接字
之外，您还可以在
Initialize（）
函数中创建一个本地
端点
和
套接字
。后面的对象只是未使用过而已-但是，成员
端点
已正确初始化

另一方面，在第二个示例中，您没有正确初始化成员
端点
。相反，您再次创建了一个本地端点。但请注意，在整个代码中使用的端点是成员端点

底线是：删除本地对象并为成员添加正确的初始化。
您能说得更具体一点吗？您说“它不工作”是什么意思？@IgorR.，我的接收器代码无法显示任何内容。WireShark显示未成功传输，这与切换到套接字指针之前不同。您能告诉我它是如何未正确初始化的吗？我如何更正它们？我看不到任何错误。谢谢。@CaTx查看UdpCore构造函数的初始化列表。您在那里执行
端点吗（boost:：asio:：ip:：address:：from_字符串（多播_地址），多播_端口）
。第二个示例中缺少这一行。这是我的初衷。我想在收到用户输入后对其进行初始化。这也是这个人的目标，他似乎成功了。@CaTx是否要将端点设置在ctor init列表之外？可以这样做，有关详细信息，请参阅asio参考。但目前您从未初始化过请将其全部初始化。相反，您创建了另一个本地端点对象，以后不再使用。（由于您对我的答案进行注释，因此不需要附加标记，因此将其删除。）是的，我希望在ctor init列表之后对其进行初始化。我认为此行初始化端点：boost:：asio:：ip:：udp:：endpoint endpoint（boost:：asio:：ip:：address:：from_字符串（多播_地址），多播_端口）；
//boost::asio::ip::udp::socket socket;
boost::shared_ptr<udp::socket> socketPtr;

//boost::asio::ip::udp::socket socket(io_service, endpoint.protocol());
//socket.set_option(boost::asio::ip::udp::socket::reuse_address(true));
socketPtr = boost::make_shared<udp::socket>(boost::ref(io_service), endpoint.protocol());
socketPtr->set_option(boost::asio::ip::udp::socket::reuse_address(true));

//socket.async_send_to(boost::asio::buffer(message), endpoint, [this](boost::system::error_code ec, std::size_t /*length*/)
socketPtr->async_send_to(boost::asio::buffer(message), endpoint, [this](boost::system::error_code ec, std::size_t /*length*/)