Image

Imagelavandergirl wrote in Imagecpp

I am having an odd error that I have not come up across before. My code compiles but doesn't link into an executable, whining about multiple definitions of the functions in the Client class. What am I doing wrong?


GeSHi © 2004, Nigel McNie
  1. // main.cpp

  2. #include <iostream>

  3. #include "Client.cpp"

  4.  

  5. int main(int argc, char* argv[])


  6. {

  7.   std::cout<<"Entry point\n";

  8.   Client ircc;

  9.  

  10.   return 0;


  11. }

  12.  

  13. // Socket.cpp

  14. #ifndef Socket_class

  15. #define Socket_class

  16.  

  17. #include <sys/types.h>

  18. #include <sys/socket.h>

  19. #include <netinet/in.h>


  20. #include <netdb.h>

  21. #include <unistd.h>

  22. #include <string>

  23. #include <arpa/inet.h>

  24.  

  25. const int MAXHOSTNAME = 200;


  26. const int MAXCONNECTIONS = 5;

  27. const int MAXRECV = 500;

  28.  


  29. class Socket

  30. {

  31.  public:

  32.   Socket();

  33.   virtual ~Socket();


  34.  

  35.   // Server initialization

  36.   bool create();

  37.   bool bind ( const int port );


  38.   bool listen() const;

  39.   bool accept ( Socket& ) const;


  40.  

  41.   // Client initialization

  42.   bool connect ( const std::string host, const int port );


  43.  

  44.   // Data Transimission

  45.   bool send ( const std::string ) const;


  46.   int recv ( std::string& ) const;

  47.  

  48.  

  49.   void set_non_blocking ( const bool );


  50.  

  51.   bool is_valid() const { return m_sock != -1; }

  52.  

  53.  private:


  54.  

  55.   int m_sock;

  56.   sockaddr_in m_addr;

  57.  

  58.  

  59. };

  60.  


  62.  


  63. // Socket.cpp

  64. #include <iostream>

  65. #include <string>

  66. #include <errno.h>

  67. #include <fcntl.h>

  68. #include "Socket.h"


  69.  

  70. Socket::Socket() :

  71.   m_sock ( -1 )

  72. {

  73.  

  74.   memset ( &m_addr,


  75.            0,

  76.            sizeof ( m_addr ) );


  77.  

  78. }

  79.  

  80. Socket::~Socket()

  81. {

  82.   if ( is_valid() )

  83.     ::close ( m_sock );


  84. }

  85.  

  86. bool Socket::create()

  87. {

  88.   m_sock = socket ( AF_INET,

  89.                     SOCK_STREAM,


  90.                     0 );

  91.  

  92.   if ( ! is_valid() )


  93.     return false;

  94.  

  95.  

  96.   // TIME_WAIT - argh

  97.   int on = 1;


  98.   if ( setsockopt ( m_sock, SOL_SOCKET, SO_REUSEADDR, ( const char* ) &on, sizeof ( on ) ) == -1 )


  99.     return false;

  100.  

  101.  

  102.   return true;

  103.  

  104. }


  105.  

  106.  

  107.  

  108. bool Socket::bind ( const int port )

  109. {

  110.  


  111.   if ( ! is_valid() )

  112.     {

  113.       return false;


  114.     }

  115.  

  116.  

  117.  

  118.   m_addr.sin_family = AF_INET;

  119.   m_addr.sin_addr.s_addr = INADDR_ANY;


  120.   m_addr.sin_port = htons ( port );

  121.  

  122.   int bind_return = ::bind ( m_sock,


  123.                              ( struct sockaddr * ) &m_addr,


  124.                              sizeof ( m_addr ) );


  125.  

  126.  

  127.   if ( bind_return == -1 )

  128.     {

  129.       return false;


  130.     }

  131.  

  132.   return true;

  133. }

  134.  

  135.  

  136. bool Socket::listen() const


  137. {

  138.   if ( ! is_valid() )

  139.     {

  140.       return false;


  141.     }

  142.  

  143.   int listen_return = ::listen ( m_sock, MAXCONNECTIONS );

  144.  

  145.  

  146.   if ( listen_return == -1 )


  147.     {

  148.       return false;

  149.     }

  150.  

  151.   return true;


  152. }

  153.  

  154.  

  155. bool Socket::accept ( Socket& new_socket ) const

  156. {

  157.   int addr_length = sizeof ( m_addr );


  158.   new_socket.m_sock = ::accept ( m_sock, ( sockaddr * ) &m_addr, ( socklen_t * ) &addr_length );


  159.  

  160.   if ( new_socket.m_sock <= 0 )

  161.     return false;


  162.   else

  163.     return true;

  164. }

  165.  

  166.  

  167. bool Socket::send ( const std::string s ) const


  168. {

  169.   int status = ::send ( m_sock, s.c_str(), s.size(), MSG_NOSIGNAL );

  170.   if ( status == -1 )


  171.     {

  172.       return false;

  173.     }

  174.   else


  175.     {

  176.       return true;

  177.     }

  178. }

  179.  

  180.  


  181. int Socket::recv ( std::string& s ) const

  182. {

  183.   char buf [ MAXRECV + 1 ];


  184.  

  185.   s = "";

  186.  

  187.   memset ( buf, 0, MAXRECV + 1 );


  188.  

  189.   int status = ::recv ( m_sock, buf, MAXRECV, 0 );

  190.  

  191.   if ( status == -1 )


  192.     {

  193.       std::cout << "status == -1   errno == " << errno << "  in Socket::recv\n";


  194.       return 0;

  195.     }

  196.   else if ( status == 0 )


  197.     {

  198.       return 0;

  199.     }

  200.   else


  201.     {

  202.       s = buf;

  203.       return status;

  204.     }


  205. }

  206.  

  207.  

  208.  

  209. bool Socket::connect ( const std::string host, const int port )


  210. {

  211.   if ( ! is_valid() ) return false;

  212.  

  213.   m_addr.sin_family = AF_INET;


  214.   m_addr.sin_port = htons ( port );

  215.  

  216.   int status = inet_pton ( AF_INET, host.c_str(), &m_addr.sin_addr );


  217.  

  218.   if ( errno == EAFNOSUPPORT ) return false;

  219.  

  220.   status = ::connect ( m_sock, ( sockaddr * ) &m_addr, sizeof ( m_addr ) );


  221.  

  222.   if ( status == 0 )

  223.     return true;

  224.   else


  225.     return false;

  226. }

  227.  

  228. void Socket::set_non_blocking ( const bool b )


  229. {

  230.  

  231.   int opts;

  232.  

  233.   opts = fcntl ( m_sock,

  234.                  F_GETFL );


  235.  

  236.   if ( opts < 0 )

  237.     {

  238.       return;


  239.     }

  240.  

  241.   if ( b )

  242.     opts = ( opts | O_NONBLOCK );


  243.   else

  244.     opts = ( opts & ~O_NONBLOCK );

  245.  

  246.   fcntl ( m_sock,


  247.           F_SETFL,opts );

  248.  

  249. }

  250.  

  251. // client.h

  252. #ifndef _CLIENT_H_

  253. #define _CLIENT_H_


  254.  

  255. #include "Socket.h"

  256.  

  257. class Client : private Socket

  258. {

  259.   private:


  260.   public:

  261.     Client(int port);

  262.     Client() {};


  263.     virtual ~Client();

  264.  

  265.     const Client& operator <<(const std::string&) const;


  266.     const Client& operator >>(std::string&) const;

  267.  

  268.     void accept(Client&);


  269. };

  270.  


  272.  

  273. // client.cpp

  274. #include <iostream>

  275. #include "Client.h"

  276.  

  277. Client::Client(int port)


  278. {

  279.   if(!Socket::create())

  280.     std::cout<<"Could not create socket\n";

  281.  

  282.   if(!Socket::bind(port) )


  283.     std::cout<<"Could not bind to port.\n";

  284.  

  285.   if(!Socket::listen())

  286.     std::cout<<"Could not listen to socket.\n";


  287. }

  288.  

  289. Client::~Client()

  290. {

  291. }

  292.  

  293.  

  294. const Client& Client::operator <<(const std::string& s) const


  295. {

  296.   if(!Socket::send(s))

  297.     std::cout<<"Could not write to socket.\n";

  298.    


  299.   return *this;

  300. }

  301.  

  302.  

  303. const Client& Client::operator >>(std::string& s) const


  304. {

  305.   if(!Socket::recv(s))

  306.     std::cout<<"Could not read from socket.\n";

  307.  

  308.   return *this;


  309. }

  310.  

  311. void Client::accept(Client& sock)

  312. {

  313.   if (!Socket::accept(sock))


  314.     std::cout<<"Could not accept socket.\n";

  315. }

  316.  
Parsed in 0.238 seconds
Statistics

LJ Video