Win32/MFC：如何在CDialog构造阶段提前创建并初始化控件？

Your core issue is that MFC only triggers OnInitDialog (where you must create child controls) after DoModal (for modal dialogs) or CreateIndirect + Show (for modeless ones), but you need users to initialize controls before showing the dialog—without knowing upfront if it'll be modal or modeless. Here are two robust, MFC-idiomatic solutions:

Option 1: Use an Initialization Callback (Flexible for End Users) #

Add a callback mechanism to your MyDialog class that lets users register code to run right after controls are created in OnInitDialog. This decouples user initialization logic from the dialog's lifecycle timing.

Modified Library Code #

#include <functional>
#include <unordered_map>

class MyDialog : public CDialogEx {
public:
    // Define a callback type for user initialization
    using DialogInitCallback = std::function<void(MyDialog*)>;

    MyDialog(CWnd* parent) : CDialogEx(), parent_(parent) {
        my_template_data_ = CreateSomeGenericTemplate();
    }

    // Let users register their initialization logic
    void SetInitCallback(DialogInitCallback callback) {
        init_callback_ = std::move(callback);
    }

    void ShowModal() {
        InitModalIndirect(my_template_data_, parent_);
        DoModal(); 
    }

    void ShowModeless() {
        CreateIndirect(my_template_data_, parent_);
        Show(); 
    }

    MyButton* GetButton(int id) {
        // Return pre-created button from our map
        auto it = button_map_.find(id);
        return (it != button_map_.end()) ? it->second : nullptr;
    }

private:
    BOOL OnInitDialog() override {
        CDialogEx::OnInitDialog();
        
        // Create all child controls first
        CreateAllControls();

        // Run user's initialization code immediately after controls exist
        if (init_callback_) {
            init_callback_(this);
        }

        return TRUE;
    }

    void CreateAllControls() {
        // Example: Create your subclassed button and store it
        MyButton* btn = new MyButton();
        btn->Create(L"Default Text", WS_CHILD | WS_VISIBLE, CRect(10, 10, 100, 30), this, 42);
        button_map_[42] = btn;

        // Add other control creation logic here
    }

    CWnd* parent_;
    DLGTEMPLATE* my_template_data_;
    std::unordered_map<int, MyButton*> button_map_;
    DialogInitCallback init_callback_;
};

User Code Example #

// 1. Create the dialog (no need to know modal/modeless yet)
MyDialog user_dialog(some_parent); 

// 2. Register initialization logic to run after controls are created
user_dialog.SetInitCallback([](MyDialog* dlg) {
    dlg->GetButton(42)->SetWindowText(L"New Button Text"); 
    // Add other control setup here (e.g., checkboxes, text fields)
});

// 3. Show the dialog (modal or modeless—callback runs either way)
user_dialog.ShowModal(); 
// OR user_dialog.ShowModeless();

Option 2: Virtual Initialization Method (MFC-Style Subclassing) #

If you prefer a more traditional MFC approach, define a virtual method that users can override in their own subclasses. This is great for users who want to encapsulate dialog logic in a subclass.

Modified Library Code #

#include <unordered_map>

class MyDialog : public CDialogEx {
public:
    MyDialog(CWnd* parent) : CDialogEx(), parent_(parent) {
        my_template_data_ = CreateSomeGenericTemplate();
    }

    void ShowModal() {
        InitModalIndirect(my_template_data_, parent_);
        DoModal(); 
    }

    void ShowModeless() {
        CreateIndirect(my_template_data_, parent_);
        Show(); 
    }

    MyButton* GetButton(int id) {
        auto it = button_map_.find(id);
        return (it != button_map_.end()) ? it->second : nullptr;
    }

protected:
    // Virtual method for user-specific initialization
    virtual void OnDialogInitialized() {
        // Default empty implementation
    }

private:
    BOOL OnInitDialog() override {
        CDialogEx::OnInitDialog();
        
        CreateAllControls();
        OnDialogInitialized(); // Trigger user's initialization

        return TRUE;
    }

    void CreateAllControls() {
        MyButton* btn = new MyButton();
        btn->Create(L"Default Text", WS_CHILD | WS_VISIBLE, CRect(10, 10, 100, 30), this, 42);
        button_map_[42] = btn;
    }

    CWnd* parent_;
    DLGTEMPLATE* my_template_data_;
    std::unordered_map<int, MyButton*> button_map_;
};

User Code Example #

// Subclass MyDialog to add custom initialization
class UserCustomDialog : public MyDialog {
public:
    UserCustomDialog(CWnd* parent) : MyDialog(parent) {}

protected:
    void OnDialogInitialized() override {
        GetButton(42)->SetWindowText(L"Custom Button Text");
        // Add other control setup logic here
    }
};

// Usage
UserCustomDialog user_dialog(some_parent);
user_dialog.ShowModal(); // OR ShowModeless()

Why These Work #

Both solutions ensure user initialization code runs immediately after controls are created in OnInitDialog, regardless of whether the dialog is modal or modeless. Users don't need to worry about MFC's internal lifecycle timing—they just provide their setup logic, and your library handles the rest.

Avoid trying to manually trigger OnInitDialog or create controls in the constructor: MFC relies on the dialog window handle being valid before creating child controls, and the constructor runs before the window is created (for both modal and modeless dialogs).

内容的提问来源于stack exchange，提问作者mrdecompilator