这是运算符重载+重载，第二个重载的意思和函数重载一样。
例如：
c++中可以这样定义函数：
void print(char *string, int n);
void print(int n, char *string);
void print(int n);
只要参数个数不同，或是个数相同的，但参数类型不同的，具有同样函数名的函数称为重载函数。

这又牵扯到函数重载 那名字相同系统就只能根据参数来判断用那个函数了吧？

// class CObject is the root of all compliant objects

#ifdef _AFXDLL
class CObject
#else
class AFX_NOVTABLE CObject
#endif
{
public:

// Object model (types, destruction, allocation)
    virtual CRuntimeClass* GetRuntimeClass() const;
    virtual ~CObject();  // virtual destructors are necessary

    // Diagnostic allocations
    void* PASCAL operator new(size_t nSize);
    void* PASCAL operator new(size_t, void* p);
    void PASCAL operator delete(void* p);
#if _MSC_VER >= 1200
    void PASCAL operator delete(void* p, void* pPlace);
#endif

#if defined(_DEBUG) && !defined(_AFX_NO_DEBUG_CRT)
    // for file name/line number tracking using DEBUG_NEW
    void* PASCAL operator new(size_t nSize, LPCSTR lpszFileName, int nLine);
#if _MSC_VER >= 1200
    void PASCAL operator delete(void *p, LPCSTR lpszFileName, int nLine);
#endif
#endif

    // Disable the copy constructor and assignment by default so you will get
    //   compiler errors instead of unexpected behaviour if you pass objects
    //   by value or assign objects.
protected:
    CObject();
private:
    CObject(const CObject& objectSrc);              // no implementation
    void operator=(const CObject& objectSrc);       // no implementation

// Attributes
public:
    BOOL IsSerializable() const;
    BOOL IsKindOf(const CRuntimeClass* pClass) const;

// Overridables
    virtual void Serialize(CArchive& ar);

#if defined(_DEBUG) || defined(_AFXDLL)
    // Diagnostic Support
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif

// Implementation
public:
    static const AFX_DATA CRuntimeClass classCObject;
#ifdef _AFXDLL
    static CRuntimeClass* PASCAL _GetBaseClass();
#endif
};

AFX.H里的CObject类的代码
为什么析构函数设置成虚函数 构造函数设置为保护模式？

这些是编译器做的工作，编译器知道会链结哪个重载函数，当然就是依据参数的不同性。

为什么你会去读MFC的代码呢？还是从基本的C++程序开始学起吧。
这些设计意图没有人会知道，除了微软自己。当然这里上面的英文解释了protect型的构造函数的意图。自己读读吧。
另外说句实话，MFC这种设计根本不符合<effective C++>中的55条设计准则。
虚析构函数和继承相关的，所有的被继承的基类都要求其析构函数是虚函数，至于为什么，这个需要你去理解C++的对象模型。
理解了这个以后，就会明白为什么如果不为虚函数，其子类都会产生内存泄露问题。

我建立了一个MFC运行的单文档窗口 我就想知道那些家伙是怎么把类封装起来不让俺看见的
看了后才知道哦 一个类继承于另一个类在继承于另一个类在继承于另一个类在继承于另一个类 ……
看了为写一个单文档窗口MFC用心良苦啊。

不建议你在不了解C++的情况，就去看MFC的源代码，要想知道手工封装Win32窗口，我们完全可以自己干。

这是一个最简单的窗口封装类：
win.h

#pragma once

class KWindow
{
private:
    virtual void OnDraw(HDC hdc){}
    virtual void OnKeyDown(WPARAM wParam, LPARAM lParam){}
    virtual LRESULT WndProc(HWND hwnd, UINT uMsg,
        WPARAM wParam, LPARAM lParam);

    static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg,
        WPARAM wParam, LPARAM lParam);

    virtual void GetwndClassEx(WNDCLASSEX &wc);

public:
    HWND m_hwnd;
   
    KWindow(void)
    {
        m_hwnd = NULL;
    }

    virtual ~KWindow(void){}

    virtual bool CreateEx(DWORD dwExStyle, LPCTSTR lpszClass, LPCTSTR lpszName,
        DWORD dwStyle, int x, int y , int nWidth, int hHeigth, HWND hParent,
        HMENU hMenu, HINSTANCE hInst);

    bool RegisterClass(LPCTSTR lpszclas, HINSTANCE hInst);
   
    virtual WPARAM MessageLoop(void);

    BOOL ShowWindow(int nCmdShow) const
    {
        return ::ShowWindow(m_hwnd, nCmdShow);
    }

    BOOL UpdateWindow(void) const
    {
        return ::UpdateWindow(m_hwnd);
    }
};

win.cpp 实现文件
#define STRICT
#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <assert.h>
#include <tchar.h>
#include "win.h"

LRESULT KWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch(uMsg)
    {
        case WM_KEYDOWN:
            OnKeyDown(wParam, lParam);
            return 0;
        case WM_PAINT:
            {
                PAINTSTRUCT ps;

                BeginPaint(m_hwnd, &ps);
                OnDraw(ps.hdc);
                EndPaint(hWnd, &ps);
            }
            return 0;
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
    }

    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

LRESULT CALLBACK KWindow::WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    KWindow * pWindow;

    if(uMsg ==  WM_NCCREATE)
    {
        assert( ! IsBadReadPtr((void *) lParam, sizeof(CREATESTRUCT)) );

        MDICREATESTRUCT *pMDIC = (MDICREATESTRUCT *)
            ((LPCREATESTRUCT) lParam)->lpCreateParams;
        pWindow = (KWindow *) (pMDIC->lParam);

        assert( ! IsBadReadPtr(pWindow, sizeof(KWindow)) );
        SetWindowLong(hWnd, GWL_USERDATA, (LONG) pWindow);
    }
    else
        pWindow = (KWindow *) GetWindowLong(hWnd, GWL_USERDATA);

    if ( pWindow )
        return pWindow->WndProc(hWnd, uMsg, wParam, lParam);
    else
        return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

bool KWindow::RegisterClass(LPCTSTR lpszClass, HINSTANCE hInst)
{
        WNDCLASSEX wc;

        if( !GetClassInfoEx(hInst, lpszClass, &wc) )
        {
            GetwndClassEx(wc);

            wc.hInstance = hInst;
            wc.lpszClassName = lpszClass;
            if( !RegisterClassEx(&wc) )
                return false;

        }

        return true;
}

bool KWindow::CreateEx(DWORD dwExStyle, LPCTSTR lpszClass,
                       LPCTSTR lpszName, DWORD dwStyle,
                       int x, int y, int nWidth, int hHeight,
                       HWND hParent, HMENU hMenu, HINSTANCE hInst)
{

    if(! RegisterClass(lpszClass, hInst) )
        return false;
    // use MDICREATESTRUCT to pass this pointer, support MDI child window

    MDICREATESTRUCT mdic;
    memset(&mdic, 0, sizeof(mdic));
    mdic.lParam = (LPARAM) this;
    m_hwnd = CreateWindowEx(dwExStyle, lpszClass, lpszName, dwStyle,
        x, y, nWidth, hHeight, hParent, hMenu, hInst, &mdic);

    return m_hwnd != NULL;

}

void KWindow::GetwndClassEx(WNDCLASSEX & wc)
{
    memset(&wc, 0, sizeof(wc));

    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = 0;
    wc.lpfnWndProc = WindowProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = NULL;
    wc.hIcon = NULL;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
    wc.lpszMenuName = NULL;
    wc.lpszMenuName = NULL;
    wc.hIconSm = NULL;
}

WPARAM KWindow::MessageLoop(void)
{
    MSG msg;
   
    while( GetMessage(&msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return msg.wParam;
}

-----------------------------------------------------------------------
主程序：
#define STRICT
#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <assert.h>
#include <tchar.h>

#include "win.h"

const TCHAR szMessage[] = _T("Hello, world!");
const TCHAR szFace[] = _T("Times New Roman");
const TCHAR szHint[] = _T("Press ESC to Quit");
const TCHAR szProgram[] = _T("HelloWorld3");

//copy centerText from Hello2.cpp
void CenterText(HDC hdc, int x, int y, LPCTSTR szFace,
                LPCTSTR szMessage, int point)
{
    HFONT hFont = CreateFont(
        -point * GetDeviceCaps(hdc, LOGPIXELSY) /72,
        0, 0, 0, FW_BOLD, TRUE, FALSE, FALSE,
        ANSI_CHARSET, OUT_TT_PRECIS, CLIP_DEFAULT_PRECIS,
        PROOF_QUALITY, VARIABLE_PITCH, szFace);

    assert(hFont);

    HGDIOBJ hOld  = SelectObject(hdc, hFont);

    SetTextAlign(hdc, TA_CENTER | TA_BASELINE );
    SetBkMode(hdc, TRANSPARENT);
    TextOut(hdc, x, y, szMessage, _tcslen(szMessage));

    SelectObject(hdc, hOld);
    DeleteObject(hFont);
}

class KHelloWindow : public KWindow
{
private:
    void OnKeyDown(WPARAM wParam, LPARAM lParam)
    {
        if( wParam == VK_ESCAPE )
        {
            PostMessage(m_hwnd, WM_CLOSE, 0, 0);
        }
    }

    void OnDraw(HDC hdc)
    {
        TextOut(hdc, 0, 0, szHint, lstrlen(szHint));
        CenterText(hdc, GetDeviceCaps(hdc, HORZRES) / 2,
            GetDeviceCaps(hdc, VERTRES) / 2,
            szFace, szMessage, 72);
    }

public:

};

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR lpCmd, int nShow)
{
    KHelloWindow win;

    win.CreateEx(0, szProgram, szProgram, WS_POPUP, 0, 0,
                GetSystemMetrics(SM_CXSCREEN),
                GetSystemMetrics(SM_CYSCREEN),
                NULL, NULL, hInst);
    win.ShowWindow(nShow);
    win.UpdateWindow();

    return win.MessageLoop();
}

Thank you very much !

好好研究下。

C++的哲学是这个世界上最复杂的，你可能穷尽一生，也未必能理解透。。
这个世界上能真正称之为C++高手的人不多。
所以现在你处在一个转折点上，就是语言的选择，切忌贪多，追新心态。。
认真选择一门语言做为你的开发工具，熟悉并始终从一而终。
然后就是选择你的研究方向，始终始一的走下去，没有人会同时精通计算机所有的技术。
另外要记住的是这个世界的程序开发不是个人开发，团队开发才是主流。。个人的能力不能左右团队开发的。

哈哈 刚开始接触 很多不知道呢 希望C++ 能带来好运 给我。谢谢你的忠告。