Thread: calling the contructor again

against my will the deconstructor of the temporary object get called and the copied data members become invalid.

Then you have a larger problem in the class, that its copy constructor and assignment operator are not implemented properly.

if i change the data member of the assigning ( right hand ) object to a specific invalid value during the assignment

You must be doing something wrong. The right-hand value should not be modified by assigning. (There's a basic choice between doing a deep copy of stuff, or sharing stuff in an intelligent way - e.g through reference-counting.)

You could post the real code for the class definition, the constructors, destructors and assignment operator to let people help you sort these things out.

But you can also use a kind of reset() method, and then the constructor could also be implemented in terms of it. (The copying behaviour will still need to be fixed in one way or another.)

oh i'm not familiar implementing ref counting. this is the code i was talking about

mySocket.h

Code:

#if !defined(_MYSOCKET_H)
#define _MYSOCKET_H

#include <string>
#include <winsock2.h>
#pragma comment (lib, "ws2_32.lib") // avoids manually specifying this lib file to the linker

class mySocket
{
private:
  SOCKET _hSocket; // winsock handle
public:  
  mySocket( const std::string& protocol )
  {
    // winsock data
    static const int winsock_ver_minimum = 2;
    WSADATA wsaData;

    // start winsock
    WSAStartup( MAKEWORD(winsock_ver_minimum,0), &wsaData);
    
    // acquire socket handle
    _hSocket = INVALID_SOCKET;
    if( protocol == "TCP" )
    { 
       _hSocket = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); 
    }
    else if( protocol == "UDP" )
    {
      _hSocket = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
    }
  }

  mySocket& operator=( mySocket& other )
  {
    
    // destroy old socket handle
    if( _hSocket != INVALID_SOCKET )
    {
      closesocket( _hSocket );
    }
    
    _hSocket = other._hSocket;       // copy other socket handle
    other._hSocket = INVALID_SOCKET; // prevent other from destroying socket handle

    return *this;                    // return this
    
  }
  
  // destroy socket
  ~mySocket()
  {
    if( _hSocket != INVALID_SOCKET )
    {
      closesocket( _hSocket );
    }
  }
};

#endif  //_MYSOCKET_H

main.cpp

Code:

#include "mySocket.h"

int main( int argc, char* argv[] )
{
  mySocket objSocket( "TCP" );
  objSocket = mySocket( "TCP" );

  mySocket objSocket2( "TCP" );
  objSocket = objSocket2; // objSocket2::_hSocket will contain INVALID_SOCKET

  return 0;
}

any suggestions are welcome.

That's a pretty good example of "how to NOT write a class".

What is the purpose of copying a socket class, by the way? What does it actually do? I don't mean what the code itself does, but why would you want to COPY an object in the first place... I'd say if both left and right part of the socket object is usable after a assignment operator, then you should forbid the assignment by making the operator private (which essentially prevents the object from being assigned).

Your constructor also allows you to create an object that doesn't work - e.g. if you do not pass in TCP or UDP - _hSocket is set to "invalid". You may want to consider using an "open" member function to open the socket itself. That way, you can return an error.

Or you could throw an exception if the constructor can't form a valid object.

--
Mats

I'm not sure which makes most sense when the connecction is lost:
1. call a "reconnecct" (or "connect") member function.
2. destroy the current object, and create a new one.
3. throw an exception, then do 2.

Obviously, if the connection is lost, you need to do something to make the socket object usable again - there is no doubt about that.

--
Mats