VC++控制台程序 调用结构（正向层）

相关源代码整理，可双击右边调用堆栈查看源代码

extern "C" DWORD mainCRTStartup(LPVOID)
{
    return __scrt_common_main();
}

// This is the common main implementation to which all of the CRT main functions
// delegate (for executables; DLLs are handled separately).
//// 这是所有 CRT 主函数（针对可执行文件；动态链接库单独处理）委托的通用主实现。
static __forceinline int __cdecl __scrt_common_main()
{
    // The /GS security cookie must be initialized before any exception handling
    // targeting the current image is registered.  No function using exception
    // handling can be called in the current image until after this call:
    ///GS 安全 Cookie 必须在针对当前映像注册任何异常处理程序之前进行初始化。
    //在执行此调用之前，当前映像中任何使用异常处理的函数都不能被调用：
    __security_init_cookie();

    return __scrt_common_main_seh();
}

static __declspec(noinline) int __cdecl __scrt_common_main_seh()
{
    if (!__scrt_initialize_crt(__scrt_module_type::exe))
        __scrt_fastfail(FAST_FAIL_FATAL_APP_EXIT);

    bool has_cctor = false;
    __try
    {
        bool const is_nested = __scrt_acquire_startup_lock();

        if (__scrt_current_native_startup_state == __scrt_native_startup_state::initializing)
        {
            __scrt_fastfail(FAST_FAIL_FATAL_APP_EXIT);
        }
        else if (__scrt_current_native_startup_state == __scrt_native_startup_state::uninitialized)
        {
            __scrt_current_native_startup_state = __scrt_native_startup_state::initializing;

            if (_initterm_e(__xi_a, __xi_z) != 0)
                return 255;

            _initterm(__xc_a, __xc_z);

            __scrt_current_native_startup_state = __scrt_native_startup_state::initialized;
        }
        else
        {
            has_cctor = true;
        }

        __scrt_release_startup_lock(is_nested);

        // If this module has any dynamically initialized __declspec(thread)
        // variables, then we invoke their initialization for the primary thread
        // used to start the process:
        _tls_callback_type const* const tls_init_callback = __scrt_get_dyn_tls_init_callback();
        if (*tls_init_callback != nullptr && __scrt_is_nonwritable_in_current_image(tls_init_callback))
        {
            (*tls_init_callback)(nullptr, DLL_THREAD_ATTACH, nullptr);
        }

        // If this module has any thread-local destructors, register the
        // callback function with the Unified CRT to run on exit.
        _tls_callback_type const * const tls_dtor_callback = __scrt_get_dyn_tls_dtor_callback();
        if (*tls_dtor_callback != nullptr && __scrt_is_nonwritable_in_current_image(tls_dtor_callback))
        {
            _register_thread_local_exe_atexit_callback(*tls_dtor_callback);
        }

        //
        // Initialization is complete; invoke main...
        //

        int const main_result = invoke_main();

        //
        // main has returned; exit somehow...
        //

        if (!__scrt_is_managed_app())
            exit(main_result);

        if (!has_cctor)
            _cexit();

        // Finally, we terminate the CRT:
        __scrt_uninitialize_crt(true, false);
        return main_result;
    }
    __except (_seh_filter_exe(GetExceptionCode(), GetExceptionInformation()))
    {
        // Note:  We should never reach this except clause.
        int const main_result = GetExceptionCode();

        if (!__scrt_is_managed_app())
            _exit(main_result);

        if (!has_cctor)
            _c_exit();

        return main_result;
    }
}

static int __cdecl invoke_main()
{
    return main(__argc, __argv, _get_initial_narrow_environment());
}

int main()
{
    return 0;
}

__scrt_common_main_seh
 ├── __scrt_initialize_crt
 ├── _initterm_e (__xi range)
 ├── _initterm (__xc range)
 ├── TLS 初始化回调
 ├── invoke_main (你的 main 函数)
 └── exit / _cexit / _exit

int main(int argc, const char** argv, const char** envp);

#include <iostream>

int main(int argc, const char** argv, const char** envp)
{
    std::cout << "参数个数 argc = " << argc << "\n";

    // 打印 argv 内容
    std::cout << "\n【命令行参数】argv:\n";
    for (int i = 0; i < argc; ++i)
    {
        std::cout << "argv[" << i << "] = " << argv[i] << "\n";
    }

    // 打印环境变量 envp 内容（最多打印10个）
    std::cout << "\n【环境变量】envp:\n";
    for (int i = 0; envp[i] != nullptr && i < 10; ++i)
    {
        std::cout << "envp[" << i << "] = " << envp[i] << "\n";
    }

    return 0;
}

your_program.exe hello world 123

参数个数 argc = 4

【命令行参数】argv:
argv[0] = your_program.exe
argv[1] = hello
argv[2] = world
argv[3] = 123

【环境变量】envp:
envp[0] = PATH=...
envp[1] = TEMP=...
envp[2] = USER=...
...

+---------------------------+
          | 操作系统加载 EXE 文件      |
          +---------------------------+
                       │
                       ▼
          +---------------------------+
          | mainCRTStartup             |
          +---------------------------+
                       │
                       ▼
          +---------------------------+
          | __scrt_common_main_seh     |
          | ├─ __security_init_cookie  |
          | ├─ __scrt_initialize_crt   |
          | ├─ _initterm_e / _initterm |
          | ├─ TLS 初始化（如有）       |
          +---------------------------+
                       │
                       ▼
          +---------------------------+
          | invoke_main()             |
          +---------------------------+
                       │
                       ▼
          +---------------------------+
          | int main(argc, argv, envp)|
          +---------------------------+
                       │
                       ▼
          +---------------------------+
          | exit / _cexit / _exit     |
          +---------------------------+
                       │
                       ▼
          +---------------------------+
          | __scrt_uninitialize_crt   |
          +---------------------------+
                       │
                       ▼
          +---------------------------+
          | 返回操作系统，进程结束    |
          +---------------------------+

[操作系统加载 EXE]
        │
        ▼
[入口点：NtProcessStartup / kernel32!BaseProcessStartup]
        │
        ▼
[调用编译器生成的 EXE 入口点函数：mainCRTStartup]
        │
        ▼
[调用 CRT 框架内部初始化函数：__scrt_common_main_seh()]
        │
        ├─► 初始化 Security Cookie: __security_init_cookie()
        ├─► 初始化 CRT 运行时环境：__scrt_initialize_crt()
        ├─► 执行 .CRT$XIA ~ .CRT$XIZ 区段中的全局构造函数（_initterm_e）
        ├─► 执行 .CRT$XCA ~ .CRT$XCZ 中的静态构造函数（_initterm）
        ├─► TLS 初始化回调（如有）: __scrt_get_dyn_tls_init_callback()
        │
        ▼
[调用 invoke_main()]
        │
        ▼
[调用你的 main(argc, argv, envp)]
        │
        ▼
[你的程序逻辑运行结束，返回 int 值]
        │
        ▼
[处理退出逻辑：exit() / _cexit() / _exit()]
        │
        ▼
[CRT 释放资源：__scrt_uninitialize_crt()]
        │
        ▼
[进程退出：返回给操作系统]