Non-Copyable Within Class - c++

Question

I've been working on a server written in C++ and using SFML networking for the sockets and all. However, I've ran into a bit of a dead end for me. SFML Sockets are non-copyable and thus cannot be stored into most(all the ones that I know of) stl containers.
So, I quickly jumped to the idea of using a pointer and then it hit me that I should use RAII, but I hate smart pointers and needed to store more information than just the pointer to the Socket class.
I wrote a Client class that wraps the socket and deletes it when the destructor on the Client class gets called, which is fine and dandy..until I remembered that the stl containers will copy my class, delete the pointer and then I'd be left with a dangling pointer.
So, is there anyway I can get around non-copyables? I need the pointer to be stored within the class and I need the class to destroy the allocated memory.
I figured I could use a copy constructor to set the copied classes' pointer to null, but I cannot find a way to do that.
For Reference:
Client.cpp
Client::Client()
{
};
Client::Client(sf::TcpSocket* in_Connection)
{
m_Connection = in_Connection;
m_IPAddress = m_Connection->getRemoteAddress().toString();
m_AccountName = "NOACCOUNT";
m_CharacterName = "NOCHARACTER";
};
Client::~Client()
{
m_Connection->disconnect();
delete m_Connection;
};
//getters
sf::TcpSocket* Client::getConnection()
{
return m_Connection;
};
std::string Client::getIPAddress()
{
return m_IPAddress;
};
std::string Client::getAccountName()
{
return m_AccountName;
};
std::string Client::getCharacterName()
{
return m_CharacterName;
};
//setters -- Account Name and Character Name are the only two that can be changed during a connection.
void Client::setAccountName(std::string in_AccountName)
{
m_AccountName = in_AccountName;
};
void Client::setCharacterName(std::string in_CharacterName)
{
m_CharacterName = in_CharacterName;
};
//Copy Constructor <--This defintely won't work and I know that, haha.
Client::Client(const Client& that)
{
m_Connection = new sf::TcpSocket();
*m_Connection = *that.m_Connection; // Cannot copy non-copyable
m_IPAddress = that.m_IPAddress;
m_CharacterName = that.m_CharacterName;
m_AccountName = that.m_AccountName;
};
Server Accept Function
void Server::AcceptConnections()
{
sf::TcpSocket* Socket = new sf::TcpSocket();
if( m_Listener.accept(*Socket) == sf::Socket::Done)
{
if(Socket != NULL )
{
std::string IPAddress = Socket->getRemoteAddress().toString();
if( m_Connections.find( IPAddress ) == m_Connections.end() )
{
std::cout << IPAddress;
std::cout << " Has Connected.";
std::endl( std::cout );
m_Connections.insert( std::make_pair(IPAddress, Client(Socket) ) );
}
}
}
};

Answer 1

First of all, whether you can use C++11 or not is a game changer.
In C++11, you have the concept of move. Unlike copying, moving is not about duplicating but about transferring. All Standard containers were adapted to non-copyable classes that are movable.
An example of a movable class:
class Client {
public:
Client(Client const&) = delete; // non copyable
Client& operator=(Client const&) = delete; // non copy assignable
Client(Client&&) = default; // movable
Client& operator=(Client&&) = default; // move assignable
private:
std::unique_ptr<sf::TcpSocket> _socket;
};
And your problem is solved.
If you are stuck in C++03 land, you are in for a bit of trouble. The simplest solution would be to use a manager class:
the manager owns the instance
users of the instance only ever manipulates references/pointers to it