bool UdpClient::stopListen = false;

void UdpClient::listen(SOCKET RecvSocket, sockaddr_in addr, onReceive o, UdpClient::onError _onError)
{
    int size = sizeof(addr);
    char rBuff[1024];
    int buffSize = sizeof(rBuff);
    while (!stopListen) {
        int err = recvfrom(RecvSocket, rBuff, sizeof(rBuff), 0, (sockaddr*)&addr, &buffSize);
        if (err > 0) {
            rBuff[err] = 0;
            if (o)
                o(rBuff);
        }
        else {
            if (_onError) {
                std::ostringstream out;

                out << "recv failed: " << WSAGetLastError();
                _onError(out.str());
            }
            closesocket(RecvSocket);
            WSACleanup();
            return;
        }
    }
}

void UdpClient::receive(onReceive r, int port, const std::string& ip)
{
    std::ostringstream out;

    WSADATA wsaData;
    int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != NO_ERROR) {
        if (_onError) {
            out << "WSAStartup failed with error: " << iResult;
            _onError(out.str());
        }
        return;
    }

    sockaddr_in ServerAddr;
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_port = htons(port);
    inet_pton(AF_INET, ip.c_str(), &ServerAddr.sin_addr);

    SOCKET RecvSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (RecvSocket == INVALID_SOCKET) {
        if (_onError) {
            out << "socket failed with error: " << WSAGetLastError();
            _onError(out.str());
        }
        WSACleanup();
        return;
    }

    int err = bind(RecvSocket, (sockaddr*)&ServerAddr, sizeof(ServerAddr));
    if (err == SOCKET_ERROR) {
        if (_onError) {
            out << "bind failed with error: " << WSAGetLastError();
            _onError(out.str());
        }
        closesocket(RecvSocket);
        WSACleanup();
        return;
    }
    std::async(std::launch::async, listen, RecvSocket, ServerAddr, r, _onError);
    //std::thread(listen, RecvSocket, ServerAddr, r, _onError);
}

std::thread(listen, RecvSocket, ServerAddr, r, _onError).detach()

#include <future>

#define WIN32_LEAN_AND_MEAN
#include <WinSock2.h>
#include <ws2tcpip.h>

#pragma comment (lib, "ws2_32.lib")

bool stopListen = false;

int llisten(SOCKET RecvSocket, sockaddr_in addr)
{
    int size = sizeof(addr);
    char rBuff[1024];
    int buffSize = sizeof(rBuff);

    while (stopListen == false)
    {
        int err = recvfrom(RecvSocket, rBuff, sizeof(rBuff), 0, (sockaddr*)&addr, &buffSize);
        if (err > 0)
        {
            std::cout << "received: " << std::string(rBuff, err)  << std::endl;
        }
        else
        {
            std::cout << "recv failed: " << WSAGetLastError();
            closesocket(RecvSocket);
            WSACleanup();
            return 1;
        }
    }

    return 0;
}

int main()
{
    std::string ip = "127.0.0.1";
    int port = 44444;
    WSADATA wsaData;

    int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != NO_ERROR)
    {
        std::cout << "WSAStartup failed with error: " << iResult;
        return -1;
    }

    sockaddr_in ServerAddr;
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_port = htons(port);
    inet_pton(AF_INET, ip.c_str(), &ServerAddr.sin_addr);

    SOCKET RecvSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (RecvSocket == INVALID_SOCKET)
    {
        std::cout << "socket failed with error: " << WSAGetLastError();
        WSACleanup();
        return 1;
    }

    int err = bind(RecvSocket, (sockaddr*)&ServerAddr, sizeof(ServerAddr));
    if (err == SOCKET_ERROR)
    {
        std::cout << "bind failed with error: " << WSAGetLastError();
        closesocket(RecvSocket);
        WSACleanup();
        return 1;
    }

    auto result = std::async(std::launch::async, llisten, RecvSocket, ServerAddr);

    std::cout << "Here we are" << std::endl;
    system("pause");
    stopListen = true;
    shutdown(RecvSocket, SD_BOTH); // Останавливаем сокет, прерываем блок recvfrom с ошибкой WSAEINTR
    closesocket(RecvSocket); // Закрываем сокет
    system("pause");
 }

Here we are
Для продолжения нажмите любую клавишу . . . received: hello world

recv failed: 10004
Для продолжения нажмите любую клавишу . . .

bool UdpClient::stopListen = false;

void UdpClient::listen(SOCKET RecvSocket, sockaddr_in addr, onReceive o, UdpClient::onError _onError)
{
    int size = sizeof(addr);
    char rBuff[1024];
    int buffSize = sizeof(rBuff);
    while (stopListen) {
        int err = recvfrom(RecvSocket, rBuff, sizeof(rBuff), 0, (sockaddr*)&addr, &buffSize);
        if (err > 0) {
            rBuff[err] = 0;
            if (o)
                o(rBuff);
        }
        else {
            if (_onError) {
                std::ostringstream out;

                out << "recv failed: " << WSAGetLastError();
                _onError(out.str());
            }
            closesocket(RecvSocket);
            WSACleanup();
            return;
        }
    }
}

std::shared_future<void> UdpClient::receive(onReceive r, int port, const std::string& ip)
{
    std::ostringstream out;
    std::future<void> k;
    std::shared_future<void> m;
    WSADATA wsaData;
    int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != NO_ERROR) {
        if (_onError) {
            out << "WSAStartup failed with error: " << iResult;
            _onError(out.str());
        }
        return m;
    }

    sockaddr_in ServerAddr;
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_port = htons(port);
    inet_pton(AF_INET, ip.c_str(), &ServerAddr.sin_addr);

    SOCKET RecvSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (RecvSocket == INVALID_SOCKET) {
        if (_onError) {
            out << "socket failed with error: " << WSAGetLastError();
            _onError(out.str());
        }
        WSACleanup();
        return m;
    }

    int err = bind(RecvSocket, (sockaddr*)&ServerAddr, sizeof(ServerAddr));
    if (err == SOCKET_ERROR) {
        if (_onError) {
            out << "bind failed with error: " << WSAGetLastError();
            _onError(out.str());
        }
        closesocket(RecvSocket);
        WSACleanup();
        return m;
    }

    auto n = std::async(std::launch::async, listen, RecvSocket, ServerAddr, r, _onError).share();
    //std::shared_future<std::future<void>> f(n);
    return n;
}