C++ 将输出文本格式化为.doc/.docx

我搜索了几周如何将文本格式化为.doc/.docx文件，但没有找到任何好的解决方案

所以我的问题是：

---

如何格式化文本以输出.doc/.docx文件？（粗体、居中等）

您需要一个库，或者进行Word自动化

---

Word的内部格式非常复杂，您不想直接这样做。

虽然您的问题格式不好，但我会尽力提供帮助

<>微软在C++中使用微软办公格式化。这看起来是一个相当艰难的过程

您关心的文件是：

Word 2002 | msword.olb

这是一个试图解决您的问题的方法，它可能有些过时。它允许你

CreateBankDocument（）
附录文本（CString szText）
GetLine（int-nLine）

OpenWordFile（CString文件名）

SaveWordFileAs（CString-szFileName）

好的：这将教会您自动化word文档的全部功能。我为接下来的文字墙道歉

#include "stdafx.h"
#include <ole2.h>

// 
// AutoWrap() - Automation helper function...
// 
HRESULT AutoWrap(int autoType, VARIANT *pvResult, IDispatch *pDisp, 
      LPOLESTR ptName, int cArgs...) 
{
      // Begin variable-argument list...
      va_list marker;
      va_start(marker, cArgs);

      if(!pDisp) {
            MessageBox(NULL, "NULL IDispatch passed to AutoWrap()", 
                       "Error", 0x10010);
            _exit(0);
      }

      // Variables used...
      DISPPARAMS dp = { NULL, NULL, 0, 0 };
      DISPID dispidNamed = DISPID_PROPERTYPUT;
      DISPID dispID;
      HRESULT hr;
      char buf[200];
      char szName[200];
   
      // Convert down to ANSI
      WideCharToMultiByte(CP_ACP, 0, ptName, -1, szName, 256, NULL, NULL);
   
      // Get DISPID for name passed...
      hr = pDisp->GetIDsOfNames(IID_NULL, &ptName, 1, LOCALE_USER_DEFAULT, 
                                &dispID);
      if(FAILED(hr)) {
            sprintf(buf, 
                    "IDispatch::GetIDsOfNames(\"%s\") failed w/err0x%08lx",
                    szName, hr);
            MessageBox(NULL, buf, "AutoWrap()", 0x10010);
            _exit(0);
            return hr;
      }
   
      // Allocate memory for arguments...
      VARIANT *pArgs = new VARIANT[cArgs+1];

      // Extract arguments...
      for(int i=0; i<cArgs; i++) {
            pArgs[i] = va_arg(marker, VARIANT);
      }
   
      // Build DISPPARAMS
      dp.cArgs = cArgs;
      dp.rgvarg = pArgs;
   
      // Handle special-case for property-puts!
      if(autoType & DISPATCH_PROPERTYPUT) {
            dp.cNamedArgs = 1;
            dp.rgdispidNamedArgs = &dispidNamed;
      }
   
      // Make the call!
      hr = pDisp->Invoke(dispID, IID_NULL, LOCALE_SYSTEM_DEFAULT, autoType, 
                         &dp, pvResult, NULL, NULL);
      if(FAILED(hr)) {
            sprintf(buf,
                    "IDispatch::Invoke(\"%s\"=%08lx) failed w/err 0x%08lx", 
                    szName, dispID, hr);
            MessageBox(NULL, buf, "AutoWrap()", 0x10010);
            _exit(0);
            return hr;
      }
      // End variable-argument section...
      va_end(marker);
   
      delete [] pArgs;
   
      return hr;

}

int main(int argc, char* argv[])
{
      // Initialize COM for this thread...
      CoInitialize(NULL);

      // Get CLSID for Word.Application...
      CLSID clsid;
      HRESULT hr = CLSIDFromProgID(L"Word.Application", &clsid);
      if(FAILED(hr)) {
            ::MessageBox(NULL, "CLSIDFromProgID() failed", "Error", 
                         0x10010);
            return -1;
      }

      // Start Word and get IDispatch...
      IDispatch *pWordApp;
      hr = CoCreateInstance(clsid, NULL, CLSCTX_LOCAL_SERVER, 
                            IID_IDispatch, (void **)&pWordApp);
      if(FAILED(hr)) {
            ::MessageBox(NULL, "Word not registered properly", 
                         "Error", 0x10010);
            return -2;
      }

      // Make Word visible
      {
            VARIANT x;
            x.vt = VT_I4;
            x.lVal = 1;
            AutoWrap(DISPATCH_PROPERTYPUT, NULL, pWordApp, L"Visible", 1, 
                     x);
      }

      // Get Documents collection
      IDispatch *pDocs;
      {
            VARIANT result;
            VariantInit(&result);
            AutoWrap(DISPATCH_PROPERTYGET, &result, pWordApp, L"Documents", 
                     0);

            pDocs = result.pdispVal;
      }

      // Call Documents.Open() to open C:\Doc1.doc
      IDispatch *pDoc;
      {
            VARIANT result;
            VariantInit(&result);
            VARIANT x;
            x.vt = VT_BSTR;
            x.bstrVal = ::SysAllocString(L"C:\\Doc1.doc");

            AutoWrap(DISPATCH_METHOD, &result, pDocs, L"Open", 1, x);
            pDoc = result.pdispVal;
            SysFreeString(x.bstrVal);
      }

      // Get BuiltinDocumentProperties collection
      IDispatch *pProps;
      {
            VARIANT result;
            VariantInit(&result);
            AutoWrap(DISPATCH_PROPERTYGET, &result, pDoc, 
                     L"BuiltinDocumentProperties", 0);
            pProps = result.pdispVal;
      }

      // Get "Subject" from BuiltInDocumentProperties.Item("Subject")
      IDispatch *pPropSubject;
      {
            VARIANT result;
            VariantInit(&result);
            VARIANT x;
            x.vt = VT_BSTR;
            x.bstrVal = ::SysAllocString(L"Subject");
            AutoWrap(DISPATCH_PROPERTYGET, &result, pProps, L"Item", 1, x);
            pPropSubject = result.pdispVal;
            SysFreeString(x.bstrVal);
      }

      // Get the Value of the Subject property and display it
      {
            VARIANT result;
            VariantInit(&result);
            AutoWrap(DISPATCH_PROPERTYGET, &result, pPropSubject, L"Value",
                     0);
            char buf[512];
            wcstombs(buf, result.bstrVal, 512);
            ::MessageBox(NULL, buf, "Subject", 0x10000);
         
      }

      // Set the Value of the Subject DocumentProperty
      {
            VARIANT x;
            x.vt = VT_BSTR;
            x.bstrVal = ::SysAllocString(L"This is my subject");
            AutoWrap(DISPATCH_PROPERTYPUT, NULL, pPropSubject, L"Value", 1, 
                     x);
            ::MessageBox(NULL, 
                         "Subject property changed, examine document.",
                         "Subject", 0x10000);
            SysFreeString(x.bstrVal);
      }

      // Get CustomDocumentProperties collection
      IDispatch *pCustomProps;
      {
            VARIANT result;
            VariantInit(&result);
            AutoWrap(DISPATCH_PROPERTYGET, &result, pDoc, 
                     L"CustomDocumentProperties", 0);
            pCustomProps = result.pdispVal;
      }

      // Add a new property named "CurrentYear"
      {     
            VARIANT parm1, parm2, parm3, parm4;
            parm1.vt = VT_BSTR;
            parm1.bstrVal = SysAllocString(L"CurrentYear");
            parm2.vt = VT_BOOL;
            parm2.boolVal = false;
            parm3.vt = VT_I4;
            parm3.lVal = 1; //msoPropertyTypeNumber = 1
            parm4.vt = VT_I4;
            parm4.lVal = 1999;

            AutoWrap(DISPATCH_METHOD, NULL, pCustomProps, L"Add", 4, parm4,
                     parm3, parm2, parm1);
            ::MessageBox(NULL, "Custom property added, examine document.",
                         "Custom Property", 0x10000);
            SysFreeString(parm1.bstrVal);
      }

      // Get the custom property "CurrentYear" and delete it
      IDispatch *pCustomProp;
      {
            VARIANT result;
            VariantInit(&result);
            VARIANT x;
            x.vt = VT_BSTR;
            x.bstrVal = ::SysAllocString(L"CurrentYear");
            AutoWrap(DISPATCH_PROPERTYGET, &result, pCustomProps, L"Item",
                     1, x);
            pCustomProp = result.pdispVal;
            SysFreeString(x.bstrVal);
            AutoWrap(DISPATCH_METHOD, NULL, pCustomProp, L"Delete", 0);
            ::MessageBox(NULL,
                         "Custom property removed, examine document.",
                         "Custom Property", 0x10000);
      }
      
      // Close the document without saving changes and quit Word
      {
            VARIANT x;
            x.vt = VT_BOOL;
            x.boolVal = false;
            AutoWrap(DISPATCH_METHOD, NULL, pDoc, L"Close", 1, x);
            AutoWrap(DISPATCH_METHOD, NULL, pWordApp, L"Quit", 0);
      }

      // Cleanup
      pCustomProp->Release();
      pCustomProps->Release();
      pPropSubject->Release();
      pProps->Release();
      pDoc->Release();
      pDocs->Release();
      pWordApp->Release();


      // Uninitialize COM for this thread...
      CoUninitialize();

      return 0;
}

#包括“stdafx.h”
#包括
// 
//AutoWrap（）-自动化辅助函数。。。
// 
HRESULT自动换行（整型、变量*pvResult、IDispatch*pDisp、，
LPOLESTR ptName，int cArgs…）
{
//开始变量参数列表。。。
va_列表标记；
va_启动（标记、cArgs）；
如果（！pDisp）{
MessageBox（NULL，“传递给AutoWrap（）的IDispatch为NULL”），
“错误”，0x10010）；
_出口（0）；
}
//使用的变量。。。
DISPPARAMS dp={NULL，NULL，0，0}；
DISPID DISPID name=DISPID_PROPERTYPUT；
DISPID DISPID；
HRESULT-hr；
char-buf[200]；
char-szName[200]；
//转换为ANSI
宽图表多字节（CP_ACP，0，ptName，-1，szName，256，NULL，NULL）；
//获取已传递名称的DISPID。。。
hr=pDisp->GetIDsOfNames（IID\u NULL，&ptName，1，LOCALE\u USER\u默认值，
&dispID）；
如果（失败（小时））{
斯普林特，
“IDispatch:：GetIDsOfNames（\“%s\”）失败，错误为0x%08lx”，
姓名（人力资源）；
MessageBox（NULL，buf，“AutoWrap（）”，0x10010）；
_出口（0）；
返回人力资源；
}
//为参数分配内存。。。
变量*pArgs=新变量[cArgs+1]；
//提取参数。。。
对于（inti=0；iInvoke）（dispID，IID\u NULL，LOCALE\u SYSTEM\u默认值，自动类型，
&dp、pvResult、NULL、NULL）；
如果（失败（小时））{
斯普林特，
“IDispatch:：Invoke（\%s\”=%08lx）失败，错误为0x%08lx”，
szName、dispID、hr）；
MessageBox（NULL，buf，“AutoWrap（）”，0x10010）；
_出口（0）；
返回人力资源；
}
//结束变量参数部分。。。
va_端（标记）；
删除[]个参数；
返回人力资源；
}
int main（int argc，char*argv[]）
{
//初始化此线程的COM。。。
共初始化（空）；
//获取Word.Application的CLSID。。。
CLSID-CLSID；
HRESULT hr=CLSIDFromProgID（L“Word.Application”、&clsid）；
如果（失败（小时））{
：：MessageBox（NULL，“CLSIDFromProgID（）失败”，“错误”，
0x10010）；
返回-1；
}
//启动Word并获取IDispatch。。。
IDispatch*pWordApp；
hr=CoCreateInstance（clsid，NULL，CLSCTX_本地_服务器，
IID_IDispatch（无效**）和pWordApp）；
如果（失败（小时））{
：：MessageBox（NULL，“Word未正确注册”，
“错误”，0x10010）；
返回-2；
}
//使单词可见
{
变体x；
x、 vt=vt_I4；
x、 lVal=1；
自动包装（DISPATCH_PROPERTYPUT，NULL，pWordApp，L“可见”，1，
x） )；
}
//获取文档集合
IDispatch*pDocs；
{
变异结果；
方差（和结果）；
自动包装（发送属性、结果、pWordApp、L“文档”，
0);
pDocs=result.pdispVal；
}
//调用Documents.Open（）打开C:\Doc1.doc
IDispatch*pDoc；
{
变异结果；
方差（和结果）；
变体x；
x、 vt=vt_BSTR；
x、 bstrVal=：：SysAllocString（L“C:\\Doc1.doc”）；
自动包装（分派方法和结果，pDocs，L“打开”，1，x）；
pDoc=result.pdispVal；
SysFreeString（x.bstrVal）；
}
//获取内置文档属性集合
IDispatch*pProps；
{
变异结果；
方差（和结果）；
自动包装（分派属性集和结果、pDoc、，
L“内置文档属性”，0）；
pProps=result.pdispVal；
}
//从内置文档属性中获取“主题”。项（“主题”）
IDispatch*pPropSubject；
{
变异结果；
方差（和结果）；
变体x；
x、 vt=vt_BSTR；
x、 bstrVal=：：SysAllocString（L“Subject”）；
自动包装（发送属性、结果、pProps、L“项”、1、x）；
pPropSubject=result.pdispVal；
SysFreeString（x.bstrVal）；
}
//获取主题属性的值并显示它
{
变异结果；
方差（和结果）；
自动换行（DISPATCH_PROPERTYGET，&result，pPropSubject，L“Value”，
0);
char-buf[512]；
wcstombs（buf，result.bstrVal，512）；
：：MessageBox（NULL，buf，“Subject”，0x10000）；
}
//设置主题DocumentProperty的值
{
变体x；
x、 vt=vt_BSTR；
x、 bstrVal=：：SysAllocString（L“这是我的主题”）；
自动换行（DISPATCH_PROPERTYPUT，NULL，pPropSubject，L“Value”，1，
x） )；
：：MessageBox（空，
#include <opc/opc.h>

int main( int argc, const char* argv[] )
{
    opcInitLibrary();
    opcContainer *c=opcContainerOpen(_X("sample.opc"), OPC_OPEN_READ_WRITE, NULL, NULL); 
    opcPart part1=opcPartCreate(c, _X("part1.xml"), _X("text/plain"), 0); 
    opcPart part2=opcPartCreate(c, _X("part2.xml"), _X("text/plain"), 0); 

    opcContainerOutputStream *stream1=opcContainerCreateOutputStream(c, part1); 
    opcContainerOutputStream *stream2=opcContainerCreateOutputStream(c, part2); 

    // WRITE to stream1 and stream2 concurrently using
    opcContainerWriteOutputStream(stream1, "HELLO", 5);
    opcContainerWriteOutputStream(stream2, "HELLO", 5);
    opcContainerWriteOutputStream(stream2, " WORLD", 6);
    opcContainerWriteOutputStream(stream1, " WORLD", 6);

    opcContainerCloseOutputStream(stream1); 
    opcContainerCloseOutputStream(stream2); 
    opcContainerClose(c, OPC_CLOSE_NOW);
    opcFreeLibrary();
    return 0;
}