一个比较基本的问题，封装底层的网络操作，这样的功能该怎么实现？

Question

我想实现这样一个功能：对网络的操作，全部放在一个类中进行，包括数据的发送，接收，以及一些数据的初步处理，然后这个类把接受到的数据发给主程序，现在碰到一个问题：对于事件如何处理？比如，类接收到了数据，然后经过一些初始的处理，需要把这些数据发给主程序处理，主程序如何才能知道这个时候需要去处理类发来的数据了呢？希望能够有一个比较详细的叙述谢谢！

Answer 1

类是cpp的语法，不需要把什么数据发给主程序

Answer 2

类是cpp的语法，不需要把什么数据发给主程序
//-----------------------------
谢谢！
那什么样的东西可以满足我的要求呢

Answer 3

这要视你的类抽象与实现的程度而定，你可以让类的某个方法来实际监听并在有数据时立即调用类的别一个方法处理，也可以让主程序监听，而在监听到有数据或有进入的连接或要关闭连接等等之时，调用你的类方法，总之，网络是有专门的监听API的，直接调用即可。下面是一个简单的程序（封装了网络操作）
本例用它可以发送、接收、连接、断开和获取对方端口各种不同的信息。该类的主要优点是完全将连接对象化，不需要窗口就可以处理网络消息，通过定义回调函数或事件即可，甚至连通知消息都可以不用。对正在开发网络应用程序朋友，该类会对你有所帮助。 
//////////////////////////////////////////////
#include <windows.h>
#include "resource.h"
#include "CConnection.h"
extern HWND hWndDialog; // used to pass the handle of the dialog the main.cpp
extern CConnection* Connection;
extern CNetworking Networking;
#define CONNECT_PORT 10205
void ReceiveCallback (DWORD ptr);
void CloseCallback (DWORD ptr);
void AcceptCallback (DWORD ptr); 
BOOL CALLBACK SendString(
　HWND hwndDlg, // handle to dialog box
　UINT uMsg, // message
　WPARAM wParam, // first message parameter
　LPARAM lParam // second message parameter
);BOOL CALLBACK SendFile(
　HWND hwndDlg, // handle to dialog box
　UINT uMsg, // message
　WPARAM wParam, // first message parameter
　LPARAM lParam // second message parameter
);BOOL CALLBACK ConnectToIP(
　HWND hwndDlg, // handle to dialog box
　UINT uMsg, // message
　WPARAM wParam, // first message parameter
　LPARAM lParam // second message parameter
);//////////////////////////////////////////////////////mian.cpp
#include "main.h"
#define MAX_LOADSTRING 100
HINSTANCE hInst; // current instance
HWND hWnd, hWndDialog; // handle of the dialog
TCHAR szTitle[MAX_LOADSTRING]; // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING]; // The title bar text
CNetworking Networking;
CConnection* Connection = NULL;
int connections[8]; // holds our connection slots...
// Foward declarations of functions included in this code module:
ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
void ReceiveCallback (DWORD ptr)
{
　char buff[1024] = "";
　CConnection* c = reinterpret_cast <CConnection*> (ptr);
　c->Receive (buff, 1024);
　MessageBox (hWnd, buff, "Information", MB_OK | MB_ICONINFORMATION);
}void CloseCallback (DWORD ptr)
{
　MessageBox (hWnd, "The connection was closed.", "Information", MB_OK | MB_ICONINFORMATION);
}void AcceptCallback (DWORD ptr)
{
　char cip[15];
　unsigned int cp = 0;
　CNetworking* net = reinterpret_cast <CNetworking*> (ptr);
　if (Connection && Connection->IsConnected ())
　{
　　CConnection* c = net->GetAccepted ();
　　while (c)
　　{
　　　char nocon[] = "The host can not accept your connection at this time.";
　　　c->Send (nocon, sizeof (nocon));
　　　c->Disconnect ();
　　　delete c;
　　　c = net->GetAccepted ();
　　};
　}
　else
　{
　　if (Connection)
　　　delete Connection;
　　　Connection = net->GetAccepted ();
　　　Connection->PeerInfo (&cip[0], 15, &cp);
　　　Connection->SetReceiveFunc (ReceiveCallback);
　　　Connection->SetCloseFunc (CloseCallback);
　　　char ci[128];
　　　sprintf (ci, "A connection was accepted.\n\nClient Information:\n %s:%i\n\n", cip, cp);
　　　MessageBox (hWnd, ci, "Client Info", MB_OK | MB_ICONINFORMATION);
　}
}
---------
//后面还有一段

Answer 4

//按上段
int APIENTRY WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,
LPSTR lpCmdLine,int nCmdShow)
{
　// TODO: Place code here.
　MSG msg;
　// Initialize global strings
　LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
　LoadString(hInstance, IDS_NETWORKING, szWindowClass, MAX_LOADSTRING);
　MyRegisterClass(hInstance);
　// Perform application initialization:
　if (!InitInstance (hInstance, nCmdShow)) 
　{
　　return FALSE;
　}
　// Main message loop:
　while (GetMessage(&msg, NULL, 0, 0)) 
　{
　　TranslateMessage(&msg);
　　DispatchMessage(&msg);
　}
　return msg.wParam;
}ATOM MyRegisterClass(HINSTANCE hInstance)
{
　WNDCLASSEX wcex;
　wcex.cbSize = sizeof(WNDCLASSEX); 
　wcex.style = CS_HREDRAW | CS_VREDRAW;
　wcex.lpfnWndProc = (WNDPROC)WndProc;
　wcex.cbClsExtra = 0;
　wcex.cbWndExtra = 0;
　wcex.hInstance = hInstance;
　wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_NETWORKING);
　wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
　wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW);
　wcex.lpszMenuName = (LPCSTR)IDM_NETWORKING;
　wcex.lpszClassName = szWindowClass;
　wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
　return RegisterClassEx(&wcex);
}BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
　hInst = hInstance; // Store instance handle in our global variable
　hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU, 
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
　if (!hWnd)
　{
　　return FALSE;
　}
　ShowWindow(hWnd, nCmdShow);
　UpdateWindow(hWnd);
　return TRUE;
}LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
　int wmId, wmEvent;
　switch (message) 
　{
　　case WM_CREATE:
　　{
　　　hWndDialog = NULL;
　　　SetWindowPos (hWnd, HWND_TOP, 0, 0, 200, 44, SWP_NOOWNERZORDER | SWP_NOMOVE);
　　　char jakobIP[225] = "";
　　　Networking.GetLocalIPs (jakobIP, 225);
　　　MessageBox(NULL, jakobIP, "Info", NULL);
　　　Networking.SetAcceptFunc (AcceptCallback);
　　　break;
　　}
　　case WM_COMMAND:
　　　wmId = LOWORD(wParam); 
　　　wmEvent = HIWORD(wParam); 
　　　// Parse the menu selections:
　　　switch (wmId)
　　　{
　　　　case IDM_EXIT:
　　　　　DestroyWindow (hWnd);
　　　　　break;
　　　　case IDM_LISTEN:
　　　　　if (Connection)
　　　　　{
　　　　　　if (MessageBox (hWnd, "You are still connected to a computer.\nPress Yes if you want
to disconnect and No to abort.\n\nSince this is just a demonstration of what you 
can\ndo with Networking I kept things simple.", NULL, MB_YESNO | MB_ICONSTOP) == IDNO)
　　　　　　　break;
　　　　　　　delete Connection;
　　　　　　Connection = NULL;
　　　　　}
　　　　　if (!Networking.Listen (CONNECT_PORT))
　　　　　{
　　　　　　char cPort[1024] = "";
　　　　　　sprintf (cPort, "Unable to listen at port %i", CONNECT_PORT);
　　　　　　MessageBox (hWnd, cPort, NULL, MB_OK | MB_ICONSTOP);
　　　　　}
　　　　　else
　　　　　{
　　　　　　char cPort[1024] = "";
　　　　　　sprintf (cPort, "Now listening at port %i!\nPress 'Ok' to accept 
incoming connections.", CONNECT_PORT);
　　　　　　MessageBox (hWnd, cPort, "Listening", MB_OK | MB_ICONINFORMATION);
　　　　　}
　　　　　break;
　　　　case IDM_CANCELLISTEN:
　　　　　if (Networking.IsListening ())
　　　　　　Networking.StopListen ();
　　　　　else
　　　　　　MessageBox (hWnd, "Unable to cancel listen-process!\nMake sure you are listening.",
NULL, MB_OK | MB_ICONINFORMATION);
　　　　　　break;
　　　　case IDM_CONNECT:
　　　　{
　　　　　if (Connection)
　　　　　{
　　　　　　Connection->Disconnect ();
　　　　　}
　　　　　DialogBox (hInst, "CONNECTIP", hWnd, ConnectToIP);
　　　　　break;
　　　　}
　　　　case IDM_SENDMSG:
　　　　　if (!Connection)
　　　　　　MessageBox(hWnd, "Please connect before sending data.", NULL, 
MB_OK | MB_ICONINFORMATION);
　　　　　else
　　　　　　DialogBox(hInst, "SENDMSG", hWnd, SendString);
　　　　　　break;
　　　　case IDM_DISCONNECT:
　　　　　if (Connection)
　　　　　　Connection->Disconnect ();
　　　　　else
　　　　　　MessageBox (hWnd, "Unable to close connection!\nMake sure you are connected.",
NULL, MB_OK | MB_ICONINFORMATION);
　　　　　　break;
　　　　case IDM_LISTLAN:
　　　　{
　　　　　char lanlist[1024] = "";
　　　　　Networking.GetNeighborhood (lanlist, 1024);
　　　　　MessageBox (hWnd, lanlist, "Information", MB_OK | MB_ICONINFORMATION);
　　　　}
　　　　default:
　　　　　return DefWindowProc(hWnd, message, wParam, lParam);
　　　}
　　　break;
　　case WM_DESTROY:
　　　PostQuitMessage(0);
　　　break;
　　default:
　　　return DefWindowProc (hWnd, message, wParam, lParam);
　}
　return 0;
}