C / C++ / MFC

manoharbalu wrote:

transfer data across LAN network using TCP sockets and hence needs MFC support.

MSDN:

The FD_WRITE event is handled slightly differently. An FD_WRITE message is posted when a socket is first connected with connect or WSAConnect (after FD_CONNECT, if also registered) or accepted with accept or WSAAccept, and then after a send operation fails with WSAEWOULDBLOCK and buffer space becomes available. Therefore, an application can assume that sends are possible starting from the first FD_WRITE message and lasting until a send returns WSAEWOULDBLOCK. After such a failure the application will be notified that sends are again possible with an FD_WRITE message.

Quote:

When an application makes a send call, if there is sufficient buffer space, the data is copied into the socket's send buffers, the call completes immediately with success, and the completion is posted. On the other hand, if the socket's send buffer is full, then the application's send buffer is locked and the send call fails with WSA_IO_PENDING. After the data in the send buffer is processed (for example, handed down to TCP for processing), then Winsock will process the locked buffer directly. That is, the data is handed directly to TCP from the application's buffer and the socket's send buffer is completely bypassed.

Quote:

For a Winsock application, once the WSASend function is called, the system owns these buffers and the application may not access them. This array must remain valid for the duration of the send operation.

For a Winsock application, once the WSASend function is called, the system owns these buffers and the application may not access them. This array must remain valid for the duration of the send operation.

class vecbase {
public:
   virtual int size() const = 0;
   virtual int& operator[](int i) = 0;
   virtual int operator[](int i) const = 0;
   virtual vecbase create(int sz, int* values) = 0;

   friend vecbase operator+(const vecbase& a, const vecbase& b) {
      assert(a.size() == b.size());
      int* values = new int[a.size()];
      for (int i = 0; i < a.size(); ++i) {
         values[i] = a[i] + b[i];
      }
      result = create(a.size(), values);
   }
};

class vec2 : public vecbase {
private:
   int val[2]
public:
   vec2(int* values) {
      assert(values != nullptr);
      val[0] = values[0];
      val[1] = values[1];
   }
   int size() const { return 2; }
   int& operator[](int i) { return val[i]; }
   int operator[](int i) const { return val[i]; }
   // change return type on this override - it is tstill considered an override!
   vec2 create(int sz, int* values) {
      assert(sz==2);
      return vec2(values);
   }
};

class vecbase {
...
   virtual vecbase add(const vecbase&, const vecbase&) = 0;

   friend vecbase operator+(const vecbase& a, const vecbase& b) {
      return add(a, b);
   }
};
class vec2 : public vecbase {
...
public:
   vec2 add(const vecbase&, const vecbase&) { ... }
};

econy wrote:

I think this is because ...

Judo Sarabia wrote:

how to determine the flow of the program?