VC++应用集成VBScript与JavaScript引擎：基于Active Scripting的脚本化架构实践-平芜编程栈

1. 项目概述：为什么要在VC++应用中集成脚本引擎？

如果你是一位长期深耕于Windows桌面应用开发的C++程序员，最近可能被一个需求困扰：产品经理希望应用能支持“插件”或“宏”功能，让用户或二次开发者能自定义一些业务流程；或者，你维护着一个庞大的历史MFC/ATL项目，里面硬编码了无数业务规则，每次改动都需要重新编译、测试、发布，流程繁琐得让人头疼。这时，将脚本引擎集成到你的VC++应用中，就从一个“可有可无”的想法，变成了一个极具吸引力的工程解决方案。

这个项目标题“将VBScript和JavaScript集成至VC++应用”，直指的就是这个核心痛点。它不是简单地在界面上嵌入一个Web浏览器控件来跑JS，而是指在原生的C++应用程序进程内，创建并托管一个脚本引擎，让脚本能够安全、高效地调用C++暴露的对象和方法，反之亦然，C++也能动态调用脚本函数、获取脚本变量。VBScript和JavaScript（这里通常指Windows Script Host支持的JScript）是Windows平台上历史悠久、支持完备的两种脚本语言。尤其是VBScript，在自动化测试、Office宏、系统管理脚本领域有着深厚的积累。

我选择同时集成两者，并非炫技。在实际项目中，这往往出于兼容性和生态的考虑。你的用户可能有一批遗留的VBScript自动化脚本，直接让他们迁移到JavaScript成本太高；而新的开发者又更倾向于使用现代JavaScript（通过Active Scripting接口的JScript引擎）的语法和特性。提供一个双引擎支持，相当于给你的应用插上了两只翅膀，既能承接历史资产，又能拥抱更广泛的开发者生态。

从技术本质上看，这相当于在你的C++主程序中，构建了一个轻量级、可控的“沙盒”环境。脚本在这个沙盒中运行，其能力边界完全由你定义的“对象模型”来决定。你可以暴露一个Document对象让脚本操作文档内容，暴露一个Calculator对象进行财务计算，但绝不会暴露DeleteFile或ShellExecute这样的危险接口。这种架构带来了巨大的灵活性：业务逻辑的变更可以用脚本快速编写和替换，无需动辄数小时的完整编译部署流程；高级用户可以通过编写脚本实现个性化工作流；甚至你可以构建一个可视化的脚本编辑器，实现低代码平台的核心功能。

2. 技术选型与核心架构设计

在Windows平台上实现C++与脚本的互操作，主流路径有几条，但结合我们的目标（VC++、VBScript、JavaScript），Microsoft Active Scripting技术栈几乎是唯一也是最成熟的选择。别被“Active”这个词吓到，它并不复杂，本质上是一套COM接口规范。

2.1 为什么是Active Scripting？

首先排除其他选项。像V8、SpiderMonkey这样的独立JS引擎虽然性能强大、标准支持新，但集成复杂度高，需要自己处理内存、垃圾回收与C++对象的绑定，并且不直接支持VBScript。而Active Scripting是Windows原生组件，从Windows 98时代就存在，系统自带vbscript.dll和jscript.dll（或更高版本的jscript9.dll），无需额外分发运行时。它通过COM接口工作，这与VC++（尤其是ATL）的开发模式是天作之合。

Active Scripting的核心是双工通信。一方面，你的C++程序作为“宿主”（Host），通过IActiveScript和IActiveScriptSite接口创建并控制脚本引擎。另一方面，你需要向脚本引擎“添名”（Add Named Items），也就是暴露一些COM对象，这些对象在脚本环境中会变成全局变量。脚本代码就可以像操作普通对象一样，调用这些变量的方法和属性。

整个架构可以简化为以下几个核心组件：

脚本引擎：由vbscript.dll或jscript.dll提供，实现了IActiveScript,IActiveScriptParse等接口。
脚本宿主：我们的C++应用程序，实现IActiveScriptSite接口以接收引擎的回调（如错误、状态变化）。
对象模型：我们自定义的COM对象，实现了IDispatch接口（自动化接口）。这是脚本能够识别和调用C++方法的关键。脚本引擎通过IDispatch::Invoke来调用我们的C++方法。
脚本代码：一段字符串形式的VBScript或JavaScript代码。

它们之间的关系如下图所示（概念图）：

[你的C++ App] --(实现并传递)--> [IActiveScriptSite] | | |--(创建、控制)--> [IActiveScript] <--(由系统提供) [vbscript.dll/jscript.dll] | | |--(通过IDispatch暴露)--> [你的自定义COM对象] | | `--(脚本通过名称访问)--> [脚本代码中的全局对象]

2.2 关键COM接口详解

理解以下几个接口是成功集成的关键：

IActiveScript：这是控制脚本引擎的主接口。核心方法包括：
- SetScriptSite: 告诉引擎宿主是谁（我们的IActiveScriptSite实现）。
- AddNamedItem: 将我们的COM对象以特定名称添加到脚本的全局命名空间。
- ParseScriptText: 解析并执行一段脚本代码。
- GetScriptDispatch: 获取脚本执行后产生的顶层对象（可用于获取脚本中定义的函数或变量）。
IActiveScriptSite：宿主必须实现的接口，用于引擎向宿主报告信息。最重要的方法是GetItemInfo，当脚本引擎需要访问一个我们通过AddNamedItem添加的对象时，会调用这个方法来获取该对象的IDispatch接口指针。
IActiveScriptParse：如果脚本引擎支持（VBScript和JScript都支持），用于解析脚本文本。比起IActiveScript::ParseScriptText，它提供了更细粒度的控制，如支持增量添加代码。
IDispatch：自动化接口，是脚本能够调用C++方法的桥梁。它通过Invoke方法，根据一个“分发ID”（DISPID）来调用具体的方法或属性。我们自定义的COM对象必须实现此接口。

注意：在VC++中实现这些COM接口，强烈建议使用ATL（Active Template Library）。ATL通过模板和智能指针，极大地简化了COM对象的创建、引用计数管理和接口实现。手动用纯C++实现IUnknown和IDispatch是一场噩梦，而ATL的CComObject、IDispImpl等类能让你事半功倍。

2.3 双引擎管理的设计考量

既然要支持VBScript和JavaScript，就不能简单写死。一个好的设计是抽象出一个ScriptEngine管理类。这个类内部可以维护一个脚本引擎实例（IActiveScript*），并提供统一的接口，如ExecuteScript，CallScriptFunction等。在创建时，根据传入的参数（如“VBScript”或“JScript”），通过CLSIDFromProgID函数获取对应的CLSID（CLSID_VBScript或CLSID_JScript），然后用CoCreateInstance创建引擎。

这样，主程序只需要与这个管理类交互，底层是VBScript还是JavaScript被封装了起来。你甚至可以设计成同时运行多个引擎实例，彼此隔离。

3. 核心实现步骤拆解

下面，我将以一个具体的例子来贯穿整个实现过程：我们要创建一个简单的“计算器”应用，C++核心逻辑提供加减乘除运算，但运算表达式由脚本动态组合和执-行。

3.1 第一步：使用ATL创建并暴露COM对象

首先，我们需要创建一个能被脚本识别的COM对象。假设我们有一个计算器核心类CCalculator。

创建ATL项目或添加ATL支持：如果你用的是现代VC++（VS2015+），创建一个“Windows桌面应用程序”项目，然后在项目上右键 -> “添加” -> “新建项”，选择“ATL -> ATL简单对象”。命名为Calculator。这会自动生成.h和.cpp文件，并完成COM注册的基础设施。

定义接口和实现类：在自动生成的ICalculator接口（一个纯虚类）中，添加方法。我们通常在IDL文件中定义。

// Calculator.idl import "oaidl.idl"; import "ocidl.idl"; [ object, uuid(你的GUID), dual, // 重要：支持IDispatch和自定义接口 nonextensible, pointer_default(unique) ] interface ICalculator : IDispatch { [id(1)] HRESULT Add([in] DOUBLE a, [in] DOUBLE b, [out, retval] DOUBLE* result); [id(2)] HRESULT Subtract([in] DOUBLE a, [in] DOUBLE b, [out, retval] DOUBLE* result); [id(3)] HRESULT Multiply([in] DOUBLE a, [in] DOUBLE b, [out, retval] DOUBLE* result); [id(4)] HRESULT Divide([in] DOUBLE a, [in] DOUBLE b, [out, retval] DOUBLE* result); [propget, id(5)] HRESULT LastResult([out, retval] DOUBLE* pVal); };

编译IDL文件会生成Calculator_i.c（定义GUID）和Calculator.h（接口定义）。

实现C++类：ATL向导会生成一个CCalculator类，继承自ICalculator。我们在.cpp文件中实现这些方法。

// Calculator.cpp STDMETHODIMP CCalculator::Add(DOUBLE a, DOUBLE b, DOUBLE* result) { if (result == nullptr) return E_POINTER; *result = a + b; m_dLastResult = *result; // 存储上一次结果 return S_OK; } // ... 实现其他方法 STDMETHODIMP CCalculator::get_LastResult(DOUBLE* pVal) { if (pVal == nullptr) return E_POINTER; *pVal = m_dLastResult; return S_OK; }

注册COM对象：ATL项目会自动处理注册。在调试时，你可以使用管理员权限运行一次程序以注册；或者使用regsvr32.exe注册生成的DLL。

实操心得：在IDL中为每个方法分配明确的[id]至关重要。这个DISPID是IDispatch::Invoke寻址方法的依据。使用dual接口可以让脚本通过更高效的自定义接口vtable调用，也兼容通过IDispatch的后期绑定调用。ATL的IDispatchImpl模板帮我们自动实现了繁琐的IDispatch部分。

3.2 第二步：实现脚本宿主与引擎初始化

接下来，我们需要创建一个类来管理脚本引擎。我们称之为CScriptHost。

实现IActiveScriptSite接口：CScriptHost需要继承IActiveScriptSite（通常也继承IActiveScriptSiteWindow用于UI交互，如果不需要可设为NULL）。

class CScriptHost : public IActiveScriptSite, public IActiveScriptSiteWindow { // 实现IUnknown的AddRef, Release, QueryInterface // 实现IActiveScriptSite的主要方法 STDMETHOD(GetLCID)(LCID *plcid) { *plcid = LOCALE_SYSTEM_DEFAULT; return S_OK; } STDMETHOD(GetItemInfo)(LPCOLESTR pstrName, DWORD dwReturnMask, IUnknown **ppiunkItem, ITypeInfo **ppti) { if (dwReturnMask & SCRIPTINFO_IUNKNOWN) { // 根据pstrName查找我们之前添加的命名项（如“calc”） // 找到后，QueryInterface获取其IUnknown，赋值给*ppiunkItem // 这是我们自定义的CCalculator对象 if (wcscmp(pstrName, L"calc") == 0 && m_spCalculator) { return m_spCalculator->QueryInterface(IID_IUnknown, (void**)ppiunkItem); } return TYPE_E_ELEMENTNOTFOUND; } if (dwReturnMask & SCRIPTINFO_ITYPEINFO) { // 通常返回NULL，脚本引擎可以自己通过IUnknown获取类型信息 if (ppti) *ppti = NULL; return S_OK; } return E_INVALIDARG; } STDMETHOD(GetDocVersionString)(BSTR *pbstrVersion) { *pbstrVersion = SysAllocString(L"1.0"); return S_OK; } STDMETHOD(OnScriptTerminate)(const VARIANT *pvarResult, const EXCEPINFO *pexcepinfo) { return S_OK; } STDMETHOD(OnStateChange)(SCRIPTSTATE ssScriptState) { return S_OK; } STDMETHOD(OnScriptError)(IActiveScriptError *pIActiveScriptError) { // 这里是错误处理的关键！当脚本有语法或运行时错误时，引擎会调用这里。 BSTR bstrSourceLine = NULL; DWORD dwSourceContext; ULONG ulLineNumber; LONG lCharacterPosition; EXCEPINFO excepinfo; pIActiveScriptError->GetExceptionInfo(&excepinfo); pIActiveScriptError->GetSourcePosition(&dwSourceContext, &ulLineNumber, &lCharacterPosition); pIActiveScriptError->GetSourceLineText(&bstrSourceLine); // 将错误信息（excepinfo.bstrDescription, ulLineNumber等）记录到日志或显示给用户 SysFreeString(bstrSourceLine); return S_OK; } STDMETHOD(OnEnterScript)(void) { return S_OK; } STDMETHOD(OnLeaveScript)(void) { return S_OK; } // IActiveScriptSiteWindow 实现（简化） STDMETHOD(GetWindow)(HWND *phwnd) { *phwnd = m_hWnd; return S_OK; } // m_hWnd是你的主窗口句柄 STDMETHOD(EnableModeless)(BOOL fEnable) { return S_OK; } private: CComPtr<IActiveScript> m_spScriptEngine; CComPtr<ICalculator> m_spCalculator; // 我们暴露的对象 HWND m_hWnd; };

初始化脚本引擎：

HRESULT CScriptHost::InitializeEngine(LPCOLESTR szProgID) { HRESULT hr = S_OK; CLSID clsid; // 1. 初始化COM（如果之前没初始化） CoInitialize(NULL); // 2. 根据名称获取CLSID hr = CLSIDFromProgID(szProgID, &clsid); // 例如 L"VBScript" 或 L"JScript" if (FAILED(hr)) return hr; // 3. 创建脚本引擎实例 hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, IID_IActiveScript, (void**)&m_spScriptEngine); if (FAILED(hr)) return hr; // 4. 设置脚本站点（我们自己） hr = m_spScriptEngine->SetScriptSite(this); if (FAILED(hr)) return hr; // 5. 创建我们想要暴露的对象实例 hr = m_spCalculator.CoCreateInstance(__uuidof(Calculator)); if (FAILED(hr)) return hr; // 6. 将对象以名称“calc”添加到脚本引擎的全局空间 hr = m_spScriptEngine->AddNamedItem(L"calc", SCRIPTITEM_ISVISIBLE | SCRIPTITEM_GLOBALMEMBERS); if (FAILED(hr)) return hr; // 7. 设置脚本引擎状态为“已初始化” hr = m_spScriptEngine->SetScriptState(SCRIPTSTATE_INITIALIZED); return hr; }

3.3 第三步：执行脚本与双向通信

引擎初始化后，就可以执行脚本了。

执行脚本代码字符串：

HRESULT CScriptHost::ExecuteScript(LPCOLESTR szScript) { if (!m_spScriptEngine) return E_FAIL; CComPtr<IActiveScriptParse> spParse; HRESULT hr = m_spScriptEngine->QueryInterface(&spParse); if (SUCCEEDED(hr)) { // 初始化解析器（通常只需一次） hr = spParse->InitNew(); } if (SUCCEEDED(hr)) { EXCEPINFO excepInfo = {0}; // 解析并执行脚本。SCRIPTTEXT_ISVISIBLE表示脚本中定义的函数在后续可见。 hr = spParse->ParseScriptText(szScript, NULL, NULL, NULL, 0, 0, SCRIPTTEXT_ISVISIBLE, NULL, &excepInfo); if (FAILED(hr)) { // 处理excepInfo中的错误 } } // 启动脚本引擎，开始执行 if (SUCCEEDED(hr)) { hr = m_spScriptEngine->SetScriptState(SCRIPTSTATE_STARTED); } // 连接脚本引擎到宿主（触发脚本中事件处理器的绑定等） if (SUCCEEDED(hr)) { hr = m_spScriptEngine->SetScriptState(SCRIPTSTATE_CONNECTED); } return hr; }

现在，你可以调用ExecuteScript(L"var sum = calc.Add(2,3);")。脚本引擎会执行这段代码，当它遇到calc.Add时，会回调我们IActiveScriptSite::GetItemInfo来获取calc对象的IUnknown，然后通过IDispatch::Invoke调用Add方法。

从C++调用脚本中定义的函数：脚本执行后，可能会定义一些函数供C++回调。这需要用到IActiveScript::GetScriptDispatch来获取脚本的顶层对象（脚本的全局命名空间），然后通过IDispatch::Invoke来调用。

HRESULT CScriptHost::CallScriptFunction(LPCOLESTR szFuncName, VARIANT* pArgs, int cArgs, VARIANT* pResult) { if (!m_spScriptEngine) return E_FAIL; CComPtr<IDispatch> spScriptDisp; HRESULT hr = m_spScriptEngine->GetScriptDispatch(NULL, &spScriptDisp); if (FAILED(hr)) return hr; DISPID dispid; // 获取脚本中函数的DISPID hr = spScriptDisp->GetIDsOfNames(IID_NULL, const_cast<LPOLESTR*>(&szFuncName), 1, LOCALE_SYSTEM_DEFAULT, &dispid); if (FAILED(hr)) return hr; // 函数未找到 // 准备调用参数 DISPPARAMS dispParams = {0}; dispParams.cArgs = cArgs; dispParams.rgvarg = pArgs; // 注意参数顺序是反向的（最后一个参数在数组第一个） // 调用函数 EXCEPINFO excepInfo = {0}; UINT uArgErr = 0; hr = spScriptDisp->Invoke(dispid, IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &dispParams, pResult, &excepInfo, &uArgErr); return hr; }

假设脚本中定义了函数function OnDataReady(data) { ... }，C++端在数据准备好后，就可以构造一个包含data的VARIANT数组，调用CallScriptFunction(L"OnDataReady", ...)来通知脚本。

4. 深入：错误处理、线程安全与性能优化

把引擎跑起来只是第一步，要让它在生产环境中稳定可靠，必须处理好以下几个深水区。

4.1 健壮的脚本错误处理

脚本是动态代码，错误不可避免。IActiveScriptSite::OnScriptError是我们的前线哨所。但仅仅记录错误信息是不够的。

获取详细的错误上下文：IActiveScriptError::GetSourceLineText能获取出错行的源代码，对于调试用户编写的长脚本至关重要。务必在错误日志中包含行号、列号和源代码片段。
区分语法错误与运行时错误：语法错误通常在ParseScriptText时通过EXCEPINFO返回。运行时错误则在OnScriptError中捕获。需要设计不同的用户提示。
防止脚本错误导致宿主崩溃：这是最关键的一点。脚本引擎运行在宿主进程内，脚本中的无限循环、内存爆炸性增长会直接拖垮你的主程序。必须设置脚本执行超时机制。一个常见的做法是，在单独的辅助线程中运行脚本引擎，主线程监控执行时间，超时则强制终止辅助线程。但这涉及到CoInitialize和COM套间的匹配，非常复杂。更实用（但粗暴）的方法是，在脚本中避免使用while(true)这类结构，或者通过宿主暴露的CheckAbort方法让脚本定期检查退出标志。

踩坑实录：我曾遇到一个脚本函数陷入死循环，导致UI线程完全卡死。后来我实现了一个“看门狗”机制：在调用ParseScriptText和切换到SCRIPTSTATE_CONNECTED之前，先启动一个定时器。如果脚本执行超过5秒，我就调用IActiveScript::InterruptScriptThread来尝试中断脚本执行。虽然这不是百分百有效（对于某些阻塞操作无效），但拦截了大部分逻辑死循环。

4.2 线程模型与套间兼容性

COM对象有线程模型（单线程套间STA、多线程套间MTA）。VBScript和JScript引擎通常是STA组件。

黄金法则：所有与脚本引擎的交互（创建、执行、调用），必须在同一个线程（通常是UI主线程）中进行。如果你在后台工作线程中创建了引擎，那么后续所有的AddNamedItem、ParseScriptText、GetScriptDispatch都必须在这个后台线程中调用，不能跨线程传递接口指针。
跨线程调用：如果非要从其他线程触发脚本执行，正确的做法是，将执行请求（脚本代码字符串）封装成一个消息或任务，投递到拥有脚本引擎的线程（如UI线程）的消息队列中去执行。可以使用PostMessage或QueueUserWorkItem配合事件同步。
暴露对象的线程安全：你暴露的CCalculator对象也可能被多个脚本引擎实例（或在多线程场景下）调用。确保你的C++对象实现是线程安全的，或者通过锁机制保护内部数据。如果对象不是线程安全的，最好确保它只在创建它的线程中被访问。

4.3 性能优化要点

脚本调用是跨语言边界的，存在一定的开销。在频繁调用的场景下，优化很有必要。

缓存DISPID：无论是C++调用脚本函数，还是脚本调用C++对象，都需要通过GetIDsOfNames根据字符串名称查找DISPID。这是一个相对耗时的操作。对于已知的、频繁调用的方法，应该在初始化阶段就查好DISPID并缓存起来，后续直接使用缓存的DISPID进行Invoke。
使用VARIANT的注意事项：VARIANT是脚本和C++之间传递数据的主要载体。频繁创建和销毁VARIANT（尤其是包含BSTR或SAFEARRAY的复杂类型）会有性能损耗。
- 重用VARIANT：在循环中，尽量重用VARIANT变量，调用前用VariantClear清空，然后赋值。
- 避免不必要的类型转换：脚本引擎和C++端尽量使用相同的数据类型。例如，在JScript中，数字默认是VT_R8（double），在C++接口中也使用DOUBLE，避免引擎内部做转换。
批量操作：如果脚本需要处理大量数据，不要通过属性一个个地get或set。考虑暴露一个方法，接受数组（SAFEARRAY）或结构化的字符串（如JSON），在C++端一次性处理完。这能极大减少跨边界调用的次数。
引擎实例复用：如果应用需要多次执行不同的脚本片段，尽量复用同一个脚本引擎实例，而不是每次都创建和销毁。可以在引擎中维护一个“脚本上下文”，通过ParseScriptText不断添加新的代码块。但要注意，这样会污染全局命名空间，可能需要定期清理或使用不同的“命名项”来隔离。

5. 常见问题排查与调试技巧

即使按照步骤来，集成过程中也难免遇到各种诡异的问题。这里记录几个我踩过的坑和解决方法。

5.1 脚本能执行，但调用C++对象方法时返回“对象不支持此属性或方法”

这是最常见的问题，根本原因是脚本引擎没有成功获取到你暴露对象的IDispatch接口。

检查清单：
1. AddNamedItem调用成功了吗？确保在调用ParseScriptText之前，已经成功调用了AddNamedItem，并且名称（如L"calc"）与脚本中引用的名称完全一致（大小写敏感）。
2. GetItemInfo实现正确吗？在IActiveScriptSite::GetItemInfo中，当dwReturnMask包含SCRIPTINFO_IUNKNOWN时，你是否正确返回了对象的IUnknown指针？用调试器设断点，确认这个函数被调用，并且成功返回了指针。
3. 你的COM对象真的实现了IDispatch吗？使用OleView.exe或Visual Studio的OLE/COM Object Viewer工具，查看你的COM对象的类型库，确认IDispatch接口下的方法是否正确定义，DISPID是否匹配。
4. 线程套间问题：确保脚本引擎调用GetItemInfo和你返回接口指针是在同一个线程。跨套间传递接口指针需要列集（Marshaling），如果没处理好，引擎拿到的是一个无效的代理。

5.2 执行脚本导致宿主程序崩溃（Access Violation）

这通常是内存管理或接口生命周期问题。

引用计数问题：COM基于引用计数。如果你在C++中手动AddRef了一个接口指针，必须在适当的时候Release。使用ATL的CComPtr智能指针可以极大地避免这个问题。确保所有接口指针都由CComPtr管理。
对象过早销毁：你暴露给脚本的C++对象，其生命周期必须长于脚本引擎。如果你在脚本还在运行或持有对象引用时，就销毁了C++对象，后续脚本再调用它就会崩溃。通常，让脚本宿主对象（CScriptHost）持有C++对象（m_spCalculator）的智能指针，确保宿主存活期间对象一直存在。
脚本引擎状态机错误：Active Scripting引擎有严格的状态机（未初始化、已初始化、已启动、已连接、已关闭）。不按顺序操作可能导致未定义行为。确保调用顺序是：CoCreateInstance->SetScriptSite->AddNamedItem->SetScriptState(INITIALIZED)->ParseScriptText->SetScriptState(STARTED)->SetScriptState(CONNECTED)。

5.3 如何调试脚本内部的执行？

调试用户脚本是个挑战。

输出调试信息：暴露一个Log或Echo方法给脚本，让脚本可以将中间变量输出到宿主程序的日志窗口或文件中。
使用Visual Studio调试JScript：对于JScript引擎，有一个鲜为人知的技巧。你可以在脚本代码中加入debugger;语句。然后，在Visual Studio中，打开“调试”->“附加到进程”，选择你的宿主程序，并确保“附加到”选项中选择了“脚本”或“自动”。当脚本执行到debugger;时，如果VS附加成功，就会中断并进入脚本调试模式，可以查看调用堆栈、变量值。这对于复杂脚本逻辑排查非常有用。
第三方脚本编辑器控件集成：如搜索热词中提到的QScintilla，它是一个强大的代码编辑组件。你可以将其集成到你的VC++应用中，为脚本编辑提供语法高亮、自动补全。QScintilla本身不直接分析JavaScript语法，但它可以通过设置词法分析器（Lexer）来实现。你需要为其配置JavaScript的词法规则文件（.lexer）。这能极大提升用户编写脚本的体验。

5.4 处理“内存不足”错误

热词中提到了“Fatal error: MarkCompactCollector: young object promotion failed Allocation failed - JavaScript heap out of memory”。这是Node.js V8引擎的典型错误，但在我们集成的Windows JScript引擎中较少见，因为老版本JScript引擎管理的内存池较小。但如果脚本创建了巨大的数组或字符串，也可能发生。

宿主端监控：在OnScriptError中捕获内存相关的异常信息。
脚本端约束：对于可能处理大量数据的脚本，引导用户使用分块处理的方式。例如，不要一次性让脚本处理一个包含10万条记录的数据，而是通过宿主暴露的ProcessBatch方法，分批传入数据。
引擎隔离：对于执行不可信脚本或重量级脚本，考虑在独立的进程或AppDomain中运行脚本引擎。但这超出了基础Active Scripting的范围，可能需要使用更复杂的宿主技术。

将VBScript和JavaScript集成到VC++应用中，是一个打通静态编译世界与动态脚本世界的桥梁工程。它带来的灵活性是巨大的，但同时也引入了复杂性。关键在于理解COM和Active Scripting这套“游戏规则”，谨慎地管理对象生命周期和线程边界，并构建起完善的错误处理和调试基础设施。当你看到用户用短短几行脚本就实现了原本需要你修改代码、重新编译的功能时，你会觉得这一切的折腾都是值得的。这个架构不仅适用于计算器，更可以扩展到文档处理、自动化测试、游戏模组、工业控制等无数场景，为你古老的C++应用注入新的活力。