Initializing boost::asio socket after constructor failed

Question

I create a class to broadcast UDP messages as follows:

#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";
    }
}

It works fine. However, I wish to initialize the socket after the class constructor is initialized (to allow user input). Thus, I change from using socket to a socket pointer, as suggested by this post . The modified code is as follows:

#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";
    }
}

where I have these replacements:

//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*/)

Just one thing with the modification: it doesn't work. I keep poring over the code, and could not find the reason why it shouldn't work. Could someone please help?

Answer 1

In the first sample, besides the member endpoint and socket, you create a local endpoint and socket in Initialize() function. The latter objects are just unused - however, the member endpoint is properly initialized.

On the other hand, in the second example you do not properly initialize the member endpoint. Instead, you create again a local one. But pay attention that the endpoint used throughout the code is the member one.

The bottom line: remove the local objects and add correct initialization for the members.