为什么是WTL

项目是toB的控制端软件，WTL程序包小，仅有一个EXE文件，对不同版本操作系统兼容性好，B端客户还用XP的不在少数，发布与使用的便捷性强。

为什么写这篇文章

WTL是基于模板对窗口封装，接近系统底层，灵活度高，只是由于资料匮乏开发上手比较困难，关于WTL的渊源我就不介绍了，重要的是，如果你在网络上搜索WTL的开资料，只能找到各种各样的广告以及WTL for MFC Programmers这篇文章的翻译版本，如果你没有MFC基础，看起来将有一定的困难，而像我这样没有C++基础，则更加头疼。作为IOS我有还行的C语言基础，Objective-C也使用了许多与C++类似的语法因此我大概用了一周时间学习C++和一周时间熟悉WTL最基本的框架使用以及几天时间了解公司项目框架构成后，上手并完成了几个界面模块的拧螺丝工作。这篇文章当然不足以让你成为WTL项目负责人，但是应该能帮助你顺利的上手。

这篇文章都要讲什么

利用WTL进行Win窗口界面程序开发主要是UI部分内容，主要有以下几个部分

1. 环境配置
2. 创建第一个窗口
3. 自定义绘图
4. 基础控件：CButton CEdit CScrollerBar
5. 动态及使用资源文件页面布局
6. 制作自定义控件
7. WTL扩展增强-DDX

你需要提前准备什么？

需要先学好C++吗？需要先看一看MFC吗？都不需要，但是你至少需要：
1.有C语言基础。
2.理解面向对象的程序开发，不论是C++还是JAVA，OC或者SWIFT等其他面向对象的开发语言，理解OOP即可。
3.如果你完全没有C++基础，也可以照着我的代码一步步做，关于C++面向对象的特性例如多继承，模板编程等，我也会在到的地方做出简单直观的解释，C++开发的其他资料比较详实如果有理解不了的内容，百度一下。
4.如果你有一些客户端开发基础IOS/安卓，会有一些帮助。
5.如果你是MFC开发人员可以直接看WTL for MFC Programmers。

更重要的资料

作为一篇以引入为目的的教程，我不会过多的介绍Windows系统的功能以及所有各种复杂的控件
如果你需要相关的资料 微软的官方文档是最佳参考资料
https://docs.microsoft.com/en-us/cpp/mfc/reference/mfc-classes?view=vs-2019
WTL基于ATL，ATL中的类大部分与MFC通用，因此官方的MFC 类文档是参考和学习价值极高的 某度甚至检索到一大堆广告 都不会把你引向官方文档
这里是WTL的下载地址
https://sourceforge.net/projects/wtl/
WTL项目中也带有一些例程，可以参考。

正式开始教程

项目搭建

1.下载安装VS。我使用的是Visual Studio2015 vs的版本对WTL影响不大，默认配置即可。

2.下载WTL，并取出include文件夹，这就是项目需要的WTL的全部文件

WTL项目文件

3.在VS中创建一个C++空项目

创建项目

引用WTL

5.创建Main.cpp文件和stdafx.h文件。并分别写入以下内容

项目初始文件

//stdfax.h:
#define STRICT
#define WIN32_LEAN_AND_MEAN
//#define _WTL_USE_CSTRING
#include <atlbase.h>  
#include <atlstr.h>  
#include <atlapp.h>  
extern CAppModule _Module;
#define _WTL_NO_CSTRING  
#include <atlwin.h>  
#include <atlmisc.h>  
#include <atlcrack.h>  
#include <atlframe.h>  
#include <atlctrls.h>  
#include <atldlgs.h>  
#include <atlwin.h>  

// main.cpp:
#include "stdafx.h"
CAppModule _Module;
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    LPSTR lpCmdLine, int nCmdShow)
{
    _Module.Init(NULL, hInstance);
    MSG msg;

    while (GetMessage(&msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    _Module.Term();
    return msg.wParam;
}

这些基本是固定写法。stdfax.h作为公共头文件，引入需要的WTL文件，由于include是将对应文件的代码复制到当前文件中因此要注意如果你不知道怎么回事，就不要改变引用顺序 ，包括其中插入的宏命令位置。
Main.CPP是程序入口。CAppModule _Module;是保存主线程ID和消息循环的实例。

while (GetMessage(&msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

这个循环是主消息循环，控制着应用的生命周期。Win程序的运行依赖于消息机制。边用便了解即可。此处只要知道走入这一行 程序便开始在消息循环中执行，存活。因此要在它之前插入操作入口。
程序的基本运行环境到这里就搭建完成了。WTL其实是一套对WinAPI界面描述的封装，可以非常轻松的扩展或引入到其他项目中。

开始创建自己的窗口

项目主入口完成后就可以开始通过WTL创建自己的窗口了。在此之前，我需要解释几个概念，熟悉C++的话可以跳过这部分。

一.C++中的变量。

如果你没有C++基础 那么你需要重新理清C++中的变量和对象关系。
对于变量 它在创建的时候在栈中分配内存。C++中的对象可与基本类型一样直接创建，创建时即分配内存，离开作用域时出栈释放。也可以在堆中创建即创建指针指向new的对象

void founction(){
yourClass obj1;
yourClass *obj2 = new class;
}//obj1释放，obj2指针释放 ,*obj2对象内存溢出

二.模板。

WTL是基于模板开发，模板是实现泛型编程的基础。可以将模板看成一种描述方式，用于描述一个类型的对象遵循模板类型对象的类型声明。
举个例子

//一个单纯的类A
class A {
void functionA(){
}
}

//一个单纯的类B
class B {
void functionB(){
}
}
//一个单纯的类P
class P {
void functionP(){
}
}

//准备一个遵循T模板的类C
template<class T>//声明模板
class C:public T{
void functionC(){

}
}

//自己定义Class D
class D :public C<A>{
}
//D就是一个包含 functionC,functionA三个方法的类这样的描述指明了D继承于C 而C继承于A同样
//自己定义Class E
class E :public C<B>{
}
//E则是包含 functionC,functionB的类

模板可以用于描述一种继承关系，也就可以在使用的时候再去定义一个对象继承于谁

//自定义一个class F
template<class T /* = P */>//声明模板同时注释其类型 
class F :public T{
void functionF(){
//调用自己继承而来的functionP 继承于F的类必须指定其模板参数为P及P的子类
functionP()
}
//或用于方法
//创建一个R类型的对象并调用其founctionP方法
template <class R /* = P */>
void founctionF2(){
R objR;
objR.founctionP();
}

void functionF3(){
//调用时必须使用P或P的子类
founctionF2<P>();
}
}

这么做则相当于我们创建一个 F 类并且指定其继承于 T 类,并且 T 必须是一个 P 的子类因为我们在 F 中直接使用了 P 的方法。
刨除元编程来看，模板点像多态，但与多态相比是逻辑逆序的，多态是“我的子类继承于我便拥有了我的接口和属性”而模板是“使用我创建的类必须包含我调用的接口和属性，从而成为符合本模板逻辑的类”。强调逻辑复用性而非结构。
WTL中模板主要用于声明自定义控件的继承类型 。

三. 虚函数

对于一个类中的函数使用virtual关键字 则这个函数是一个虚函数

virtual void founction(){};//虚函数
virtual void founction() = 0;//纯虚函数

虚函数可以视作是一种接口声明。
纯虚函数更多是一种描述性用途，它规定了包含纯虚函数的类为基类 ，不可直接使用只能使用其子类。

回到WTL

在理解以上三点后 就可以开始了解WTL界面搭建的基本工具了。
在Win程序中 一切界面元素皆是CWindow。在WTL中最基本的界面类是CWindowImpl。
在正式开始使用前先简单了解一下CWindowImpl

CWindowImpl

它有三个模板参数 其中 T自定义的类 TBase 是WinAPI中的窗口类 TWinTraits 是设置模板，可以不使用 先无视它。
从它的定义可以看出来两个泛型参数 TBase用于类型传递，T则用于本地调用，让CWindowImpl能够调用到你自定义的类的一些类方法，如果你重写了这些方法。防止子类重写这些方法后调用的仍然是父类的这些方法。
接着向上看

TWindowImplBaseT

CWindowImplRoot

CMessageMap

定义第一个自定义的窗口

第一个自定义窗口

BEGIN_MSG_MAP(FirstWindow)
END_MSG_MAP()

这些是自动创建的构造函数和析构函数。如无需要，可以删掉。

    FirstWindow();
    ~FirstWindow();
FirstWindow::FirstWindow()
{
}

FirstWindow::~FirstWindow()
{
}

练习项目中可以将代码全部写在.h文件。

然后使用它

在WinMain函数中，Moudle创建后，消息循环开始执行前创建并显示这个窗口

使用FirstWindowImpl

其中CRect是描述位置大小的对象，可以设置上下左右边相对于父控件的位置。
创建了Window对象后需要调用Create方法创建窗口
该方法有以下几个参数

         In_opt_ HWND hWndParent, //父控件的句柄
        _In_ _U_RECT rect = NULL,//指定位置大小
        _In_opt_z_ LPCTSTR szWindowName = NULL,//窗口名称，会显示在左上角系统栏。默认样式可见
        _In_ DWORD dwStyle = 0,//窗口风格类型，属性设置 
        _In_ DWORD dwExStyle = 0,//窗口扩展风格
        _In_ _U_MENUorID MenuOrID = 0U,//资源ID，可以理解为该对象的数字标记，后面使用资源文件的时候会再次用到
        _In_opt_ LPVOID lpCreateParam = NULL//16位机遗留参数。现在用不着

这里我简单解释一下句柄
句柄是是一个结构体表示一个Window资源，也就相当于它的索引，通过句柄可以找到这个资源。也就可以通过句柄首发消息。CWindow对句柄进行了重载。使得CWindow的赋值操作实际只是让另一个CWindow对象的句柄指针指向目标对象的句柄。暂时了解一下就行了。

句柄

在Create方法中指定句柄通常用于设置控件位置，也就是说 rect参数设置的控件位置是相对于 hWndParent 的。而指定hWndParent为空的时候，窗口的位置是相对于屏幕的，左上角为0.0点，向右/向下为正轴。
此时我们添加的代码创建了一个从屏幕左上角X/Y轴均为以10为起点到500为终点的FirstWindow类型的窗口。执行一下看看

执行效果

Window.Create(NULL, rc, "HELLO WORLD",WS_VISIBLE | WS_SYSMENU,NULL,0U,NULL );

拥有关闭按钮

但是这并不能关闭程序!
点击X只是隐藏了窗口，程序仍然在主方法中循环，没有任何变量被释放。

关闭窗口

添加消息

MSG的定义

但是要注意 调用该方法结束应用前必须删除掉所有你创建的窗口

WTL中对于关闭程序时还有残留窗口的断言

删除指定窗口

删除前

删除后

绘图

由于WinApi诞生之时还没有Material Design这样美观的视觉表达规范，其系统控件样式相当的匮乏且充满工程师设计风格，因此大多数时候，控件都需要实现自定义绘图，即使只是简单的设置背景颜色。
完成了上面最简单的视窗控件后，我们来给它添加一个背景色。
绘图方法在系统更新控件时被调用。因此它也依赖于消息循环。我们可以在消息的定义文件中找到它。

绘图消息

添加OnPaint

简要解析一下绘图对象

前往CDCHandle的定义

CDCHandle

CDCT的定义

CPrintDC

使用CPrintDC

绘图

绘制窗口背景色

动态绘图

如果你接触过其他平台的界面API应该可以直接想到下面这个注意点：
绘图操作仅可以由系统调用绘图方法是一个特定过程执行的方法。不能主动调用
比如如下操作
通过消息添加一个鼠标点击的响应事件，当鼠标左键在窗口内点击的时候会调用OnLbuttonDown
在此处添加想要做的操作

更新界面

Invalidate() 方法是可以用来更新控件的方法，他会使得该控件失效并由系统在空闲的时间更新。
UpdateWindow() 方法可以让失效的控件立即刷新，也就会重新绘制。如果不需要立即刷新 可以不用添加。
可以看到，不论是直接使用画刷 还是在外部调用OnPaint方法 都没有让界面颜色发生改变。

生效时机

换个颜色

画笔和文字

    void printLine( CDCHandle dc) {
        CPen pen;
        pen.CreatePen(PS_SOLID, 2, RGB(255, 255, 255));
        dc.SelectPen(pen.m_hPen);
        CPoint start;
        start.x = 10;
        start.y = 10;
        dc.MoveTo(start);
        CPoint dest;
        dest.x = mouseClickLocation.left;
        dest.y = mouseClickLocation.top;
        if (dest.x != 0)
        {
            dc.LineTo(dest);
        }
    }

    void printText(CDCHandle dc) {
        CString text;
        CRect textLocation;
        text = "hello world";
        dc.SetTextColor(RGB(0, 0, 0));
        dc.ExtTextOutA(mouseClickLocation.left, mouseClickLocation.top, ETO_OPAQUE, NULL, text, text.GetLength(), NULL);
    }

通常来说如果你对 CPringDC的调用是一次独立绘图的话
你应该在绘图前使用SaveDC保存并在最后对它调用
RestoreDC(-1) 方法以恢复你使用之前的状态

保存和回复DC

CDoubleBufferImpl

在进行绘图时 如果你反复重绘，会因为绘图事会绘制一部分 显示一部分，重绘过快就会在上一次绘制完成前就进行下一次绘制，进而导致闪烁。

闪烁现象

CDoubleBufferImpl

继承

添加消息链接

DoPaint

添加CDoubleBufferImpl后

动态生成基础控件

在进一步使用WTL封装控件之前，需要先了解和使用一些MFC基本控件。
通常给自定义控件添加子控件的过程放置在生命周期方法中的创建消息中。对于CWinodwImpl就是MSG_WM_CREATE

创建方法

CButton

为FirstWindow创建一个CButton
注意对于一个子控件，需要为其指定父控件的句柄以确定坐标系位置。同时需要设置样式为WS_CHILD或者WS_CHILDWINDOW（二者等价）。

    int OnCreate(LPCREATESTRUCT lpCreateStruct) {
     //TODO:添加控件
        CButton btn;
        CRect btnRect;
        btnRect.left = 50;
        btnRect.right = 150;
        btnRect.top = 50;
        btnRect.bottom = 100;
        btn.Create(m_hWnd, btnRect, "ClickBtnHere", WS_VISIBLE | WS_CHILD, NULL, 0U, NULL);
        return 0;
    }

添加按钮

添加响应事件

按钮响应事件通过消息机制传递
通过COMMAND_HANDLER宏命令添加

添加消息

资源窗口

菜单

添加资源

COMMAND_HANDLER定义

按钮点击响应

点击事件

GetDlgItem

CEdit

输入框控件，同样通过Create方法创建

        CEdit textField;
        CRect tfRect;
        tfRect.left = 200;
        tfRect.right = 300;
        tfRect.top = 50;
        tfRect.bottom = 100;
        textField.Create(m_hWnd, tfRect, nullptr, WS_VISIBLE | WS_CHILD | ES_MULTILINE | ES_AUTOVSCROLL, 0UL, 0U, NULL);

通过Style参数设置属性。默认状态下为单行 ES_MULTILINE 设置为多行，ES_AUTOVSCROLL设置为垂直自动滚动，默认状态下为单行，如果不设置滚动，在字符填满控件时不再接受输入字符。

输入框

获取输入框文字内容

SetWindowText方法和GetWindowText分别可以设置/获取Cedit中的字符内容。

在代码中设置和获取字符

CScrollBar

CScrollerBar 本身是作为独立控件使用的 但是CWindow是有默认的滚动条可以使用的 只需要在Style中设置WS_VSCROLL/WS_HSCROLL。

        CScrollBar scroller;
        CRect scrRect;
        scrRect.left = 20;
        scrRect.right = 40;
        scrRect.top = 20;
        scrRect.bottom = 200;
        scroller.Create(m_hWnd, scrRect, "", SBS_VERT | WS_VISIBLE |WS_CHILD, NULL, 0U, NULL);
      
        this->ShowScrollBar(0, 1);//显示水平滚动条
        this->ShowScrollBar(1, 1);//显示垂直滚动条

SBS_VERT设置了滚动条的方向为垂直。默认为水平

添加滚动条

给滚动条设置属性

        SCROLLINFO info;
        scroller.GetScrollInfo(&info);
        scroller.SetScrollInfo(&info, false);
        scroller.SetScrollRange(0, 100);
        scroller.SetScrollPos(20, TRUE);

通过SCROLLINFO给滚动栏设置两侧代表的值
滚动条自身是不会随着滚动而停在对应的位置的，只能通过SetScrollPos方法令其停在对应的位置。

默认滚动

    void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar pScrollBar) {
        int curPos = pScrollBar.GetScrollPos();
        int destPos = curPos;
        switch (nSBCode)
        {
        case SB_THUMBPOSITION:
            destPos = nPos;
            break;

        }
        pScrollBar.SetScrollPos(destPos);
    }

nSBCode是滚动条事件的类型标志，包含各个方向的滚动，鼠标拖动开始，停止等。先添加一个最简单的事件
SB_THUMBPOSITION就是鼠标拖着滑块到达某个位置抬起后触发

响应触发

其他事件

CComboBox

        CComboBox box;
        CRect lstRect;
        lstRect.left = 50;
        lstRect.right = 150;
        lstRect.top = 120;
        lstRect.bottom = 200;
        box.Create(m_hWnd, lstRect, "listCtrl", WS_VISIBLE | WS_CHILD | CBS_DROPDOWNLIST, 0UL, 0U, NULL);
        box.AddString("item1");
        box.AddString("item2");
        box.AddString("item3");

设置不同的Style会有不同的样式 可以自己试试

CComboBox

关于常用的控件的例子就讲这些 复杂的如树形控件，文件选择，菜单之类的特殊控件可以搜到其他更详细的资料。

窗口布局

在改变窗口大小时，或者触发控件事件时，有时会需要去改变界面布局。
改变控件位置可以使用 MoveWindow()方法
方便使用 先将控件储存为类成员变量
在滚动条滚动中改变按钮的位置

    void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar pScrollBar) {
        int curPos = pScrollBar.GetScrollPos();
        int destPos = curPos;
        switch (nSBCode)
        {
        case  SB_LINEUP:
            destPos -= 1;
            break;
        case  SB_LINEDOWN:
            destPos += 1;
            break;
        case SB_THUMBTRACK:
            destPos = nPos;
            break;
        case SB_THUMBPOSITION:
            destPos = nPos;
            break;
        }

        if (destPos < 0){destPos = 0;}
        if (destPos > 100){destPos = 100;}

        pScrollBar.SetScrollPos(destPos);
        CRect btnRect;
        btn.GetWindowRect(&btnRect);
        int W = btnRect.Width();
        int H = btnRect.Height();
        btnRect.top = destPos;
        btnRect.bottom = destPos + H;
        btnRect.left = 50;
        btnRect.right = 50 + W;
        btn.MoveWindow(btnRect, TRUE);//第二个BOOL值参数指定是否立即重绘
    }

移动窗口

响应父窗口大小改变事件

通常来收移动控件位置大小主要用于在父窗口大小发生改变时合理布局
首先对一个窗口添加风格WS_SIZEBOX 这样就就可以拖动大小了

    Window.Create(NULL, rc, "HELLO WORLD",WS_VISIBLE | WS_SYSMENU | WS_SIZEBOX,NULL,0U,NULL );

然后接收MSG_WM_SIZE消息

MSG_WM_SIZE

需要补充点窗口与坐标系的内容

获取窗口位置通常有两个方法
窗口有两个坐标区域，一个是窗口自身的大小。还有一个是窗口的用户区，也就是去除边框之外的用户可操作的部分区域。
GetWindowRect() 获取的是窗口相对于父窗口的位置 也就是整个窗口的大小位置
GetClientRect()获取的是窗口自身用户区的位置，永远都是0.0为起点 其实也就是自身用户区的大小。
ScreenToClient()方法可以将获取到的坐标系转换到对应屏幕上的绝对位置
对于子控件来说通常通过GetClientRect获取父控件的区域去布局， 通过GetWindowRect获取其他处于同一个父控件之下的子控件的位置。此时获取到的位置都是相对于父控件的用户区的相对坐标。
而如果要将父子控件都转换到对应的相同坐标系
则需要先让需要转换坐标系的控件自身调用GetWindowRect然后统一通过父控件调用ScreenToClient去转换坐标系 此时获取到的就是控件相对于屏幕的绝对位置。
关于这一点的应用，会在结束基础内容后补充的综合布局实践中使用到。当然自己创建几个控件试一试理解起来会更加清晰。

接下来在OnSize中让scroller贴紧左边

    void OnSize(UINT nType, CSize size) {
        CRect clientRect;
        GetClientRect(&clientRect);
        CRect scrRect;
        scrRect.top = clientRect.top;
        scrRect.left = clientRect.left;
        scrRect.right = scrRect.left + 20;
        scrRect.bottom = clientRect.bottom;
        scroller.MoveWindow(scrRect);
    }

OnSize

使用资源文件可视化布局

在开发中需要界面有相当繁复但是固定的控件，全部使用动态创建的方式代码量较大，因此也可以通过资源文件拖控件去实现。只需要通过资源直接拖动控件到需要的位置后使用时通过资源ID获取就可以了。节省了大量的布局代码。
以对话框为例实践一下。打开资源视图，右键选择添加资源

添加资源

添加资源

基本对话框

属性面板

确定按钮

    enum
    {
        IDD = IDD_DIALOG_FIRST//资源ID
    };

指定资源绑定。

#pragma once
#include "stdafx.h"
#include "resource.h"
class FirstDialog :public CDialogImpl<FirstDialog>
{
public:
    enum
    {
        IDD = IDD_DIALOG_FIRST
    };

    BEGIN_MSG_MAP(FirstDialog)
    END_MSG_MAP()

};

这样我们使用对应的类。就会调起被绑定的资源窗口
先回到资源文件打开工具箱给窗口添加控件

打开工具箱

工具箱

弹出对话框

弹出对话框

CPP文件

添加响应

声明

实现

BOOL OnInitDialog(CWindow wndFocus, LPARAM lInitParam) {
        GetDlgItem(IDOK).SetWindowText("BTNOK");
        return 0;
    }

LRESULT FirstDialog::OnBnClickedOk(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
    // TODO: 在此添加控件通知处理程序代码
    EndDialog(0);
    return 0;
}

制作自定义控件

先介绍一个WTL增强数据交换工具 DDX

DDX是一套类似于MSG_MAP的宏命令，其实质就是简化和统一窗口与数据之间相互传值的调用代码。
使用起来比较简单，举个例子。
首先在需要使用DDX的类中继承CWinDataExchange父类

继承

绑定

变量赋值控件

控件赋值变量

DDX

在自定义控件中可以定义自己的DDX宏，这样可以方便的统一输入和输出，便于代码阅读。

使用资源文件设置自定义视图

使用纯代码创建自定义视图很简单，继承就行了。
如果希望不需要通过代码创建只要拖控件的话，则要使用Custom Control控件，并在使用前注册，并使用自定义的窗口类关联。
首先拖一个CustomControl 类型的资源到对应的视图中 ，然后指定一个资源ID和自定义一个Class名称。

添加控件

然后回到Main函数中注册这个Class

注册

关联资源

自定义资源

给自定义的资源视图添加控件

使用资源自定义视图则不需要调用Create方法，也就无法在这里创建子空间了，但是类与资源绑定时会调用SubclassWindow。就可以在这里重写该方法添加创建子控件的操作。

class FirstCustomItem :public CWindowImpl<FirstCustomItem,CWindow>
。。。。。
    CButton btnL;
    CButton btnR;

    BOOL SubclassWindow(_In_ HWND hWnd) {
            //先调用父类的SubclassWindow
        BOOL result = CWindowImpl::SubclassWindow(hWnd);
        if (result)
        {
            CRect lRect;
            GetClientRect(&lRect);
            lRect.right = lRect.right / 2;
            CRect rRect;
            GetClientRect(&rRect);
            rRect.left = rRect.right / 2;
            btnL.Create(m_hWnd, lRect, "0", WS_VISIBLE | WS_CHILD, 0UL, 0U, NULL);
            btnR.Create(m_hWnd, rRect, "0", WS_VISIBLE | WS_CHILD, 0UL, 1U, NULL);
        }
        return result;
    }
};
。。。。。

添加自己的DDX

DDX宏本质上也只是方法调用，实际与“给自己的控件添加输入输出接口并手动调用”是一样的。其意义在于可以对一类输入输出统一处理统一声明。因为C++代码往往行数是比较多的。DDX实质上只是让程序更易读。
添加一个自己的类继承CWinDataExchange

template <class T>
class FirstDialogDDX :
    public CWinDataExchange<T>
{
#define DDX_FD_TEXT(nID, var) \
        if(nCtlID == (UINT)-1 || nCtlID == nID) \
        { \
            if(!ddxFdText(nID, var, sizeof(var), bSaveAndValidate)) \
                return FALSE; \
        }
    void ddxFdText(UINT nID, CString& nValue, BOOL bSave)
    {
//获取句柄
        T* pT = static_cast<T*>(this);
        HWND hWndCtrl = pT->GetDlgItem(nID);
        ATLASSERT(hWndCtrl != NULL);
//发送操作消息
        if (bSave)
        {
            //写入
        }
        else
        {
            //取出
        }
    }
};

如果你对前面分析其他组件的过程有所记忆这里就不再去DDX中分析了，可以自己去看一看。
原理非常简单。
模仿框架自带的DDX添加一个新的宏定义。和对应的调用方法。
bSave就是调用DoDataExchange时填入的参数，根据它判断操作方向。
然后回到自定义的类中添加自定义的消息和消息处理
接下来回到自定义的类中添加消息接收和处理方法

#define WM_WRITE WM_USER + 1
#define WM_HANDLE_POINTER WM_USER + 3
#define WM_READ WM_USER + 2
class FirstCustomItem :public CWindowImpl<FirstCustomItem,CWindow>
{
public:

    BEGIN_MSG_MAP(OnInitDialog)
        MSG_WM_PAINT(OnPaint)
        MSG_WM_SIZE(OnSize);
        MESSAGE_HANDLER(WM_READ, notifactionRead)
        MESSAGE_HANDLER(WM_WRITE, notifactionWrite)
    
    END_MSG_MAP()

添加消息接收和对应的处理方法

    LRESULT notifactionRead(...) {
        return readData();
    }

    LRESULT notifactionWrite( UINT , LPARAM lparm, WPARAM rparm, BOOL& /*bHandled*/) {
        writeData(lparm);
        return 0;
    }

    BOOL readData() {
    
        CString strL;
        btnL.GetWindowTextA(strL);

        CString strR;
        btnR.GetWindowTextA(strR);

        if (strL == "1" && strR == "1")
        {
            return TRUE;
        }

        return FALSE;
    }
    void writeData(BOOL state) {
    if (state)
    {
        btnL.SetWindowTextA("1");
        btnR.SetWindowTextA("1");
    }
    else
    {
        btnL.SetWindowTextA("0");
        btnR.SetWindowTextA("0");
    }
    
    }

顺便去自定义控件给按钮添加一个事件

    LRESULT OnLClick(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
    {

        CString btnStr;
        btnL.GetWindowTextA(btnStr);
        if (btnStr == "0")
        {
            btnL.SetWindowTextA("1");
        }
        else
        {
            btnL.SetWindowTextA("0");

        }

        return 0;
    }

    LRESULT OnRClick(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
    {
        CString btnStr;
        btnR.GetWindowTextA(btnStr);
        if (btnStr == "0")
        {
            btnR.SetWindowTextA("1");
        }
        else
        {
            btnR.SetWindowTextA("0");

        }

        return 0;
    }

好了 接下来就可以通过DDX将这个自定义控件与一个BOOL值之间做交互了
你应该看出来了 。这个控件 就是一个有两个可点击按钮并能通过DDX输出按钮上数字的&运算后取得的BOOL值的复合控件。
回到使用它的地方 用DDX做绑定

    BEGIN_DDX_MAP(FirstDialog)
        DDX_FD_BOOL(IDC_CUSTOM_FIRST,m_SocketState)
    END_DDX_MAP()
    BOOL m_SocketState = 1;

给对话框的两个按钮添加事件用来重置状态和进行DDX操作

LRESULT FirstDialog::OnBnClickedOk(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
    // TODO: 在此添加控件通知处理程序代码
    m_SocketState = 0;
    DoDataExchange(TRUE);
    

    return 0;
}


LRESULT FirstDialog::OnBnClickedCancel(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
    // TODO: 在此添加控件通知处理程序代码
    DoDataExchange(FALSE);
    if (m_SocketState)
    {
        (GetDlgItem(IDC_STATIC)).SetWindowTextA("TRUE");
    }
    else
    {
        (GetDlgItem(IDC_STATIC)).SetWindowTextA("FALSE");

    }
    return 0;
}

看一看做了个什么。

自定义DDX

STL基础

施工中。。。。。