自学教程：C++ sprintfW函数代码示例

static HRESULT WINAPI CategoryMgr_UnregisterCategory ( ITfCategoryMgr *iface,        REFCLSID rclsid, REFGUID rcatid, REFGUID rguid){    WCHAR fullkey[110];    WCHAR buf[39];    WCHAR buf2[39];    HKEY tipkey;    CategoryMgr *This = impl_from_ITfCategoryMgr(iface);    static const WCHAR ctg[] = {'C','a','t','e','g','o','r','y',0};    static const WCHAR itm[] = {'I','t','e','m',0};    static const WCHAR fmt[] = {'%','s','//','%','s',0};    static const WCHAR fmt2[] = {'%','s','//','%','s','//','%','s','//','%','s',0};    TRACE("(%p) %s %s %s/n",This,debugstr_guid(rclsid), debugstr_guid(rcatid), debugstr_guid(rguid));    StringFromGUID2(rclsid, buf, 39);    sprintfW(fullkey,fmt,szwSystemTIPKey,buf);    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,fullkey, 0, KEY_READ | KEY_WRITE,                &tipkey ) != ERROR_SUCCESS)        return E_FAIL;    StringFromGUID2(rcatid, buf, 39);    StringFromGUID2(rguid, buf2, 39);    sprintfW(fullkey,fmt2,ctg,ctg,buf,buf2);    sprintfW(fullkey,fmt2,ctg,itm,buf2,buf);    RegDeleteTreeW(tipkey, fullkey);    sprintfW(fullkey,fmt2,ctg,itm,buf2,buf);    RegDeleteTreeW(tipkey, fullkey);    RegCloseKey(tipkey);    return S_OK;}

static WCHAR *build_args( int argc, WCHAR **argvW ){	int i, wlen = 1;	WCHAR *ret, *p;	static const WCHAR FormatQuotesW[] = { ' ', '/"', '%', 's', '/"', 0 };	static const WCHAR FormatW[] = { ' ', '%', 's', 0 };	for (i = 0; i < argc; i++ )	{		wlen += strlenW(argvW[i]) + 1;		if (strchrW(argvW[i], ' '))			wlen += 2;	}	ret = HeapAlloc( GetProcessHeap(), 0, wlen*sizeof(WCHAR) );	ret[0] = 0;	for (i = 0, p = ret; i < argc; i++ )	{		if (strchrW(argvW[i], ' '))			p += sprintfW(p, FormatQuotesW, argvW[i]);		else			p += sprintfW(p, FormatW, argvW[i]);	}	return ret;}

BSTR get_value_bstr( const struct table *table, UINT row, UINT column ){    static const WCHAR fmt_signedW[] = {'%','d',0};    static const WCHAR fmt_unsignedW[] = {'%','u',0};    static const WCHAR fmt_signed64W[] = {'%','I','6','4','d',0};    static const WCHAR fmt_unsigned64W[] = {'%','I','6','4','u',0};    static const WCHAR fmt_strW[] = {'/"','%','s','/"',0};    static const WCHAR trueW[] = {'T','R','U','E',0};    static const WCHAR falseW[] = {'F','A','L','S','E',0};    LONGLONG val;    BSTR ret;    WCHAR number[22];    UINT len;    if (table->columns[column].type & CIM_FLAG_ARRAY)    {        FIXME("array to string conversion not handled/n");        return NULL;    }    if (get_value( table, row, column, &val ) != S_OK) return NULL;    switch (table->columns[column].type & COL_TYPE_MASK)    {    case CIM_BOOLEAN:        if (val) return SysAllocString( trueW );        else return SysAllocString( falseW );    case CIM_DATETIME:    case CIM_STRING:        if (!val) return NULL;        len = strlenW( (const WCHAR *)(INT_PTR)val ) + 2;        if (!(ret = SysAllocStringLen( NULL, len ))) return NULL;        sprintfW( ret, fmt_strW, (const WCHAR *)(INT_PTR)val );        return ret;    case CIM_SINT16:    case CIM_SINT32:        sprintfW( number, fmt_signedW, val );        return SysAllocString( number );    case CIM_UINT16:    case CIM_UINT32:        sprintfW( number, fmt_unsignedW, val );        return SysAllocString( number );    case CIM_SINT64:        wsprintfW( number, fmt_signed64W, val );        return SysAllocString( number );    case CIM_UINT64:        wsprintfW( number, fmt_unsigned64W, val );        return SysAllocString( number );    default:        FIXME("unhandled column type %u/n", table->columns[column].type & COL_TYPE_MASK);        break;    }    return NULL;}

/* create the platform-specific environment registry keys */static void create_environment_registry_keys( void ){    static const WCHAR EnvironW[]  = {'S','y','s','t','e','m','//',                                      'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','//',                                      'C','o','n','t','r','o','l','//',                                      'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','//',                                      'E','n','v','i','r','o','n','m','e','n','t',0};    static const WCHAR NumProcW[]  = {'N','U','M','B','E','R','_','O','F','_','P','R','O','C','E','S','S','O','R','S',0};    static const WCHAR ProcArchW[] = {'P','R','O','C','E','S','S','O','R','_','A','R','C','H','I','T','E','C','T','U','R','E',0};    static const WCHAR x86W[]      = {'x','8','6',0};    static const WCHAR IA64W[]     = {'I','A','6','4',0};    static const WCHAR AMD64W[]    = {'A','M','D','6','4',0};    static const WCHAR ProcIdW[]   = {'P','R','O','C','E','S','S','O','R','_','I','D','E','N','T','I','F','I','E','R',0};    static const WCHAR ProcLvlW[]  = {'P','R','O','C','E','S','S','O','R','_','L','E','V','E','L',0};    static const WCHAR ProcRevW[]  = {'P','R','O','C','E','S','S','O','R','_','R','E','V','I','S','I','O','N',0};    static const WCHAR PercentDW[] = {'%','d',0};    static const WCHAR Percent04XW[] = {'%','0','4','x',0};    static const WCHAR IntelCpuDescrW[]  = {'%','s',' ','F','a','m','i','l','y',' ','%','d',' ','M','o','d','e','l',' ','%','d',                                            ' ','S','t','e','p','p','i','n','g',' ','%','d',',',' ','G','e','n','u','i','n','e','I','n','t','e','l',0};    HKEY env_key;    SYSTEM_CPU_INFORMATION sci;    WCHAR buffer[60];    const WCHAR *arch;    NtQuerySystemInformation( SystemCpuInformation, &sci, sizeof(sci), NULL );    if (RegCreateKeyW( HKEY_LOCAL_MACHINE, EnvironW, &env_key )) return;    sprintfW( buffer, PercentDW, NtCurrentTeb()->Peb->NumberOfProcessors );    set_reg_value( env_key, NumProcW, buffer );    switch(sci.Architecture)    {    case PROCESSOR_ARCHITECTURE_AMD64: arch = AMD64W; break;    case PROCESSOR_ARCHITECTURE_IA64:  arch = IA64W; break;    default:    case PROCESSOR_ARCHITECTURE_INTEL: arch = x86W; break;    }    set_reg_value( env_key, ProcArchW, arch );    /* TODO: currently hardcoded Intel, add different processors */    sprintfW( buffer, IntelCpuDescrW, arch, sci.Level, HIBYTE(sci.Revision), LOBYTE(sci.Revision) );    set_reg_value( env_key, ProcIdW, buffer );    sprintfW( buffer, PercentDW, sci.Level );    set_reg_value( env_key, ProcLvlW, buffer );    /* Properly report model/stepping */    sprintfW( buffer, Percent04XW, sci.Revision );    set_reg_value( env_key, ProcRevW, buffer );    RegCloseKey( env_key );}

static void ACTION_ConvertRegValue(DWORD regType, const BYTE *value, DWORD sz, LPWSTR *appValue){    static const WCHAR dwordFmt[] = { '#','%','d','/0' };    static const WCHAR binPre[] = { '#','x','/0' };    static const WCHAR binFmt[] = { '%','0','2','X','/0' };    LPWSTR ptr;    DWORD i;    switch (regType)    {        case REG_SZ:            if (*(LPCWSTR)value == '#')            {                /* escape leading pound with another */                *appValue = msi_alloc(sz + sizeof(WCHAR));                (*appValue)[0] = '#';                strcpyW(*appValue + 1, (LPCWSTR)value);            }            else            {                *appValue = msi_alloc(sz);                strcpyW(*appValue, (LPCWSTR)value);            }            break;        case REG_DWORD:            /* 7 chars for digits, 1 for NULL, 1 for #, and 1 for sign             * char if needed             */            *appValue = msi_alloc(10 * sizeof(WCHAR));            sprintfW(*appValue, dwordFmt, *(const DWORD *)value);            break;        case REG_EXPAND_SZ:            sz = ExpandEnvironmentStringsW((LPCWSTR)value, NULL, 0);            *appValue = msi_alloc(sz * sizeof(WCHAR));            ExpandEnvironmentStringsW((LPCWSTR)value, *appValue, sz);            break;        case REG_BINARY:            /* #x<nibbles>/0 */            *appValue = msi_alloc((sz * 2 + 3) * sizeof(WCHAR));            lstrcpyW(*appValue, binPre);            ptr = *appValue + lstrlenW(binPre);            for (i = 0; i < sz; i++, ptr += 2)                sprintfW(ptr, binFmt, value[i]);            break;        default:            WARN("unimplemented for values of type %d/n", regType);            *appValue = NULL;    }}

static HRESULT WINAPI xmlwriter_WriteCharEntity(IXmlWriter *iface, WCHAR ch){    static const WCHAR fmtW[] = {'&','#','x','%','x',';',0};    xmlwriter *This = impl_from_IXmlWriter(iface);    WCHAR bufW[16];    TRACE("%p %#x/n", This, ch);    switch (This->state)    {    case XmlWriterState_Initial:        return E_UNEXPECTED;    case XmlWriterState_ElemStarted:        writer_close_starttag(This);        break;    case XmlWriterState_DocClosed:        return WR_E_INVALIDACTION;    default:        ;    }    sprintfW(bufW, fmtW, ch);    write_output_buffer(This->output, bufW, -1);    return S_OK;}

static void export_hex_data(HANDLE hFile, WCHAR **buf, DWORD type,                            DWORD line_len, void *data, DWORD size){    static const WCHAR fmt[] = {'%','0','2','x',0};    static const WCHAR hex_concat[] = {'//','/r','/n',' ',' ',0};    size_t num_commas, i, pos;    line_len += export_hex_data_type(hFile, type);    if (!size) return;    num_commas = size - 1;    *buf = heap_xalloc(size * 3 * sizeof(WCHAR));    for (i = 0, pos = 0; i < size; i++)    {        pos += sprintfW(*buf + pos, fmt, ((BYTE *)data)[i]);        if (i == num_commas) break;        (*buf)[pos++] = ',';        (*buf)[pos] = 0;        line_len += 3;        if (line_len >= MAX_HEX_CHARS)        {            write_file(hFile, *buf);            write_file(hFile, hex_concat);            line_len = 2;            pos = 0;        }    }}

HRESULT assembly_get_version(ASSEMBLY *assembly, LPWSTR *version){    static const WCHAR format[] = {'%','u','.','%','u','.','%','u','.','%','u',0};    ASSEMBLYTABLE *asmtbl;    LONG offset;    *version = NULL;    offset = assembly->tables[TableFromToken(mdtAssembly)].offset;    if (offset == -1)        return E_FAIL;    asmtbl = assembly_data_offset(assembly, offset);    if (!asmtbl)        return E_FAIL;    *version = HeapAlloc(GetProcessHeap(), 0, sizeof(format) + 4 * strlen("65535") * sizeof(WCHAR));    if (!*version)        return E_OUTOFMEMORY;    sprintfW(*version, format, asmtbl->MajorVersion, asmtbl->MinorVersion,             asmtbl->BuildNumber, asmtbl->RevisionNumber);    return S_OK;}

static HRESULT WINAPI HTMLLocation_get_port(IHTMLLocation *iface, BSTR *p){    HTMLLocation *This = impl_from_IHTMLLocation(iface);    DWORD port;    IUri *uri;    HRESULT hres;    TRACE("(%p)->(%p)/n", This, p);    if(!p)        return E_POINTER;    if(!(uri = get_uri(This))) {        FIXME("No current URI/n");        return E_NOTIMPL;    }    hres = IUri_GetPort(uri, &port);    if(FAILED(hres))        return hres;    if(hres == S_OK) {        static const WCHAR formatW[] = {'%','u',0};        WCHAR buf[12];        sprintfW(buf, formatW, port);        *p = SysAllocString(buf);    }else {        *p = SysAllocStringLen(NULL, 0);    }    if(!*p)        return E_OUTOFMEMORY;    return S_OK;}

static HRESULT WINAPI HTMLTable_put_cellSpacing(IHTMLTable *iface, VARIANT v){    HTMLTable *This = impl_from_IHTMLTable(iface);    nsAString nsstr;    WCHAR buf[64];    nsresult nsres;    TRACE("(%p)->(%s)/n", This, debugstr_variant(&v));    switch(V_VT(&v)) {    case VT_BSTR:        nsAString_InitDepend(&nsstr, V_BSTR(&v));        break;    case VT_I4: {        static const WCHAR formatW[] = {'%','d',0};        sprintfW(buf, formatW, V_I4(&v));        nsAString_InitDepend(&nsstr, buf);        break;    }    default:        FIXME("unsupported arg %s/n", debugstr_variant(&v));        return E_NOTIMPL;    }    nsres = nsIDOMHTMLTableElement_SetCellSpacing(This->nstable, &nsstr);    nsAString_Finish(&nsstr);    if(NS_FAILED(nsres)) {        ERR("SetCellSpacing failed: %08x/n", nsres);        return E_FAIL;    }    return S_OK;}

WCHAR *msi_font_version_from_file( const WCHAR *filename ){    static const WCHAR fmtW[] = {'%','u','.','%','u','.','0','.','0',0};    WCHAR *version, *p, *q, *ret = NULL;    if ((version = load_ttf_name_id( filename, NAME_ID_VERSION )))    {        int len, major = 0, minor = 0;        if ((p = strchrW( version, ';' ))) *p = 0;        p = version;        while (*p && !isdigitW( *p )) p++;        if ((q = strchrW( p, '.' )))        {            major = atoiW( p );            p = ++q;            while (*q && isdigitW( *q )) q++;            if (!*q || *q == ' ') minor = atoiW( p );            else major = 0;        }        len = strlenW( fmtW ) + 20;        ret = msi_alloc( len * sizeof(WCHAR) );        sprintfW( ret, fmtW, major, minor );        msi_free( version );    }    return ret;}

static HRESULT WINAPI HTMLObjectElement_put_height(IHTMLObjectElement *iface, VARIANT v){    HTMLObjectElement *This = impl_from_IHTMLObjectElement(iface);    nsAString height_str;    PRUnichar buf[12];    nsresult nsres;    TRACE("(%p)->(%s)/n", This, debugstr_variant(&v));    switch(V_VT(&v)) {    case VT_I4: {        static const WCHAR formatW[] = {'%','d',0};        sprintfW(buf, formatW, V_I4(&v));        break;    }    default:        FIXME("unimplemented for arg %s/n", debugstr_variant(&v));        return E_NOTIMPL;    }    nsAString_InitDepend(&height_str, buf);    nsres = nsIDOMHTMLObjectElement_SetHeight(This->nsobject, &height_str);    nsAString_Finish(&height_str);    if(NS_FAILED(nsres)) {        FIXME("SetHeight failed: %08x/n", nsres);        return E_FAIL;    }    notif_container_change(&This->plugin_container, DISPID_UNKNOWN);    return S_OK;}

UINT MSIREG_OpenUserDataProductKey(LPCWSTR szProduct, HKEY *key, BOOL create){    UINT rc;    WCHAR squished_pc[GUID_SIZE];    WCHAR keypath[0x200];    LPWSTR usersid;    TRACE("%s/n", debugstr_w(szProduct));    if (!squash_guid(szProduct, squished_pc))        return ERROR_FUNCTION_FAILED;    TRACE("squished (%s)/n", debugstr_w(squished_pc));    rc = get_user_sid(&usersid);    if (rc != ERROR_SUCCESS || !usersid)    {        ERR("Failed to retrieve user SID: %d/n", rc);        return rc;    }    sprintfW(keypath, szUserDataProd_fmt, usersid, squished_pc);    if (create)        rc = RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key);    else        rc = RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key);    LocalFree(usersid);    return rc;}

UINT MSIREG_OpenLocalManagedProductKey(LPCWSTR szProductCode, HKEY *key, BOOL create){    WCHAR squished_pc[GUID_SIZE];    WCHAR keypath[0x200];    LPWSTR usersid;    UINT r;    TRACE("%s/n", debugstr_w(szProductCode));    if (!squash_guid(szProductCode, squished_pc))        return ERROR_FUNCTION_FAILED;    TRACE("squished (%s)/n", debugstr_w(squished_pc));    r = get_user_sid(&usersid);    if (r != ERROR_SUCCESS || !usersid)    {        ERR("Failed to retrieve user SID: %d/n", r);        return r;    }    sprintfW(keypath, szInstaller_LocalManagedProd_fmt, usersid, squished_pc);    LocalFree(usersid);    if (create)        return RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key);    return RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key);}

static void export_dword_data(WCHAR **buf, DWORD *data){    static const WCHAR fmt[] = {'d','w','o','r','d',':','%','0','8','x',0};    *buf = heap_xalloc(15 * sizeof(WCHAR));    sprintfW(*buf, fmt, *data);}

LPWSTR GetLastErrorText(LPWSTR lpwszBuf, DWORD dwSize){    DWORD  dwRet;    LPWSTR lpwszTemp = NULL;    static const WCHAR    wszFormat[] = {'%','s',' ','(','%','u',')',0};    dwRet = FormatMessageW( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_ARGUMENT_ARRAY,                           NULL,                           GetLastError(),                           LANG_NEUTRAL,                           (LPWSTR)&lpwszTemp,                           0,                           NULL );    /* supplied buffer is not long enough */    if (!dwRet || ( dwSize < dwRet+14)) {        lpwszBuf[0] = '/0';    } else {        lpwszTemp[strlenW(lpwszTemp)-2] = '/0';  /* remove cr and newline character */        sprintfW(lpwszBuf, wszFormat, lpwszTemp, GetLastError());    }    if (lpwszTemp) {        LocalFree(lpwszTemp);    }    return lpwszBuf;}

NTSTATUS HID_CreateDevice(DEVICE_OBJECT *native_device, HID_MINIDRIVER_REGISTRATION *driver, DEVICE_OBJECT **device){    WCHAR dev_name[255];    UNICODE_STRING nameW;    NTSTATUS status;    BASE_DEVICE_EXTENSION *ext;    sprintfW(dev_name, device_name_fmtW, driver->DriverObject, native_device);    RtlInitUnicodeString( &nameW, dev_name );    TRACE("Create base hid device %s/n", debugstr_w(dev_name));    status = IoCreateDevice(driver->DriverObject, driver->DeviceExtensionSize + sizeof(BASE_DEVICE_EXTENSION), &nameW, 0, 0, FALSE, device);    if (status)    {        FIXME( "failed to create device error %x/n", status );        return status;    }    ext = (*device)->DeviceExtension;    ext->deviceExtension.MiniDeviceExtension = ext + 1;    ext->deviceExtension.PhysicalDeviceObject = *device;    ext->deviceExtension.NextDeviceObject = native_device;    ext->device_name = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(dev_name) + 1) * sizeof(WCHAR));    lstrcpyW(ext->device_name, dev_name);    ext->link_name.Buffer = NULL;    IoAttachDeviceToDeviceStack(*device, native_device);    return STATUS_SUCCESS;}

static void ACTION_ConvertRegValue(DWORD regType, const BYTE *value, DWORD sz, LPWSTR *appValue){    static const WCHAR dwordFmt[] = { '#','%','d','/0' };    static const WCHAR expandSzFmt[] = { '#','%','%','%','s','/0' };    static const WCHAR binFmt[] = { '#','x','%','x','/0' };    DWORD i;    switch (regType)    {        case REG_SZ:            if (*(LPCWSTR)value == '#')            {                /* escape leading pound with another */                *appValue = msi_alloc(sz + sizeof(WCHAR));                (*appValue)[0] = '#';                strcpyW(*appValue + 1, (LPCWSTR)value);            }            else            {                *appValue = msi_alloc(sz);                strcpyW(*appValue, (LPCWSTR)value);            }            break;        case REG_DWORD:            /* 7 chars for digits, 1 for NULL, 1 for #, and 1 for sign             * char if needed             */            *appValue = msi_alloc(10 * sizeof(WCHAR));            sprintfW(*appValue, dwordFmt, *(const DWORD *)value);            break;        case REG_EXPAND_SZ:            /* space for extra #% characters in front */            *appValue = msi_alloc(sz + 2 * sizeof(WCHAR));            sprintfW(*appValue, expandSzFmt, (LPCWSTR)value);            break;        case REG_BINARY:            /* 3 == length of "#x<nibble>" */            *appValue = msi_alloc((sz * 3 + 1) * sizeof(WCHAR));            for (i = 0; i < sz; i++)                sprintfW(*appValue + i * 3, binFmt, value[i]);            break;        default:            WARN("unimplemented for values of type %d/n", regType);            *appValue = NULL;    }}

static void failure_msgbox(install_ctx_t *ctx, HRESULT hres){    WCHAR buf[1024], fmt[1024];    LoadStringW(urlmon_instance, IDS_AXINSTALL_FAILURE, fmt, sizeof(fmt)/sizeof(WCHAR));    sprintfW(buf, fmt, hres);    MessageBoxW(ctx->hwnd, buf, NULL, MB_OK);}

static BOOL CRYPT_FormatHexString(const BYTE *pbEncoded, DWORD cbEncoded, WCHAR *str, DWORD *pcchStr){    BOOL ret;    DWORD charsNeeded;    if (cbEncoded)        charsNeeded = (cbEncoded * 3);    else        charsNeeded = 1;    if (!str)    {        *pcchStr = charsNeeded;        ret = TRUE;    }    else if (*pcchStr < charsNeeded)    {        *pcchStr = charsNeeded;        SetLastError(ERROR_MORE_DATA);        ret = FALSE;    }    else    {        static const WCHAR fmt[] = { '%','0','2','x',' ',0 };        static const WCHAR endFmt[] = { '%','0','2','x',0 };        DWORD i;        LPWSTR ptr = str;        *pcchStr = charsNeeded;        if (cbEncoded)        {            for (i = 0; i < cbEncoded; i++)            {                if (i < cbEncoded - 1)                    ptr += sprintfW(ptr, fmt, pbEncoded[i]);                else                    ptr += sprintfW(ptr, endFmt, pbEncoded[i]);            }        }        else            *ptr = 0;        ret = TRUE;    }    return ret;}

/*********************************************************************** *      tapiGetLocationInfoW ([email
C++ sprintf_P函数代码示例
C++ sprintf函数代码示例