C / C++ / MFC

int ReceiveHeader(SOCKET ClientSock, short iHeader[], int iLength)
{
	// Function to properly fill buffer

	short iHeaderBuffer[14];	// Buffer to hold the header data

	int iReceivedTotal		= 0;	// Total bytes received
	int iReceivedThisPass   = 0;	// Total bytes received in one recv
	int x					= 0;	// For the elements of the array
	int iThisX;						// For the elements of the array

	// Loop until the total bytes received is equal
	// to the total bytes we want; 2 bytes at a time
	while (iReceivedTotal < iLength)
	{
		iThisX = 0;

		for (short i = 0; i < (14 - (iReceivedTotal / 2)); i++)
		{
			iHeader[x] = iHeaderBuffer[i];

			x++;

			iThisX++;	// the number of elements we advance in this loop ONLY
		}
		
		iReceivedThisPass = recv(ClientSock, 
			                     szBuffer, 
								 (28 - iReceivedTotal),
							     0
							    );
		

		if (iReceivedThisPass != SOCKET_ERROR)
		{
			// If an odd number of bytes are sent then go back and 
			// resend because the array is short aligned
			//if ( sizeof(iHeader) % iReceivedThisPass != 0 )
			if ( 28 % iReceivedThisPass != 0 )
			{
				iReceivedThisPass = 0;

				x -= iThisX;

				continue;
			}

			iReceivedTotal += iReceivedThisPass;	// Increment total received

			// Make sure we are not advancing that which we are not receiving
			// eg. if x was 14 and we had received 12 bytes then we would want
			// to subtract 2; we divide iReceivedTotal by two because each
			// element of the array is two bytes
			x -= (14 - (iReceivedTotal / 2));
		}
		else
		{
			if (WSAGetLastError() != WSAEWOULDBLOCK)
				return -1;
		}
	}

	return iReceivedTotal;
}

int SendHeader(SOCKET ClientSock, short iHeader[], int iLength)
{
	// Function to properly fill buffer

	short iHeaderBuffer[14];	// Buffer to hold the header data

	int iSentTotal		= 0;	// Total bytes sent
	int iSentThisPass   = 0;	// Total bytes sent in one send
	int x				= 0;	// For the elements of the array
	int iThisX;					// For the elements of the array

	// Loop until the total bytes sent is equal
	// to the total bytes we want; send two bytes at
	// a time

	while (iSentTotal < iLength)
	{
		iThisX = 0;

		for (short i = 0; i < (14 - iSentTotal); i++)
		{
			iHeaderBuffer[i] = iHeader[x];

			x++;

			iThisX++;
		}
		
		iSentThisPass = send(ClientSock, 
			                 (char*) iHeaderBuffer 
						     (28 - iSentTotal),	
						     0
							);

		if (iSentThisPass != SOCKET_ERROR)
		{
			// If an odd number of bytes are sent then go back and 
			// resend because the array is short aligned
			if ( 28 % iSentThisPass != 0 )
			{
				iSentThisPass = 0;

				x -= iThisX;

				continue;
			}
			
			iSentTotal += iSentThisPass;		// Increment total received

			// Make sure we are not advancing that which we are not sending
			// eg. if x was 14 and we had send 12 bytes then we would want
			// to subtract 2; we divide iSentTotal by two because each
			// element of the array is two bytes
			x -= (14 - (iSentTotal / 2));
		}
		else 
		{
			if (WSAGetLastError() != WSAEWOULDBLOCK)
				return -1;
		}
	}
	
	return iSentTotal;
}

int SendHeader(SOCKET ClientSock, const short *piHeader, int iLength)
{
   int iSentTotal = 0;
   int iSentPass = 0;
   const int iLengthBytes = iLength*sizeof(short);
   const unsigned char *ptr = (const unsigned char*)piHeader;
   while(iSentTotal < iLengthBytes)
   {
      iSentPass = send(ClientSock, ptr, iLengthBytes-iSentTotal, 0);
      if(iSentPass != SOCKET_ERROR)
      {
         iSentTotal += iSentPass;
         ptr += iSentPass;
      }
      else
      {
         if(WSAGetLastError() != WSAEWOULDBLOCK)
            return -1;
      }
   }
   return iSentTotal;
}

int ReceiveHeader(SOCKET ClientSock, short *piHeader, int iLength)
{
   int iRecvTotal = 0;
   int iRecvPass = 0;
   const int iLengthBytes = iLength*sizeof(short);
   unsigned char *ptr = (const unsigned short*)piHeader;
   while(iRecvTotal < iLengthBytes)
   {
      iRecvPass = recv(ClientSock, ptr, iLengthBytes-iRecvTotal, 0);
      if(iRecvPass != SOCKET_ERROR)
      {
         iRecvTotal += iRecvPass;
         ptr += iRecvPass;
      }
      else
      {
         if(WSAGetLastError() != WSAEWOULDBLOCK)
            return -1;
      }
   }
   return iRecvTotal;
}

#include <fstream.h>

void main()
{
fstream infile;
char c;
int i = 0;
infile.open("data.txt", ios::in);

	while(!infile.eof())
	{
	   infile.get(c);
	   if(c == '\n')
		i++;
	}
	i++;

cout << "data.txt has " << i << " lines.\n";

}

ifstream File;

File.open("data.txt");

int i = 0;

while ( !File.eof() )
{
    File.getline(szBuffer, sizeof(szBuffer), '\n');

    i++;
}

cout << "data.txt has" << i << " lines." << endl;

CGridCtrl m_Grid;

DDX_GridControl(pDX, IDC_GRID, m_Grid);

// Get position of first document template
POSITION pos = m_pDocManager->GetFirstDocTemplatePosition();
while( pos )
{
    // Get pointer to document template
    CDocTemplate* pTemplate = m_pDocManager->GetNextDocTemplate(pos);
    // Get position of first document using template
    POSITION pos2 = pTemplate->GetFirstDocPosition();
    while( pos2 )
    {
        // Get pointer to document
        CDocument * pDoc = pTemplate->GetNextDoc(pos2);
        if( pDoc )
            pDoc->UpdateAllViews();
    }
}
<pre\>
 

INTP