C++博客-Hello World！-文章分类-技术相关

BSTR

hello wold! — Wed, 28 Mar 2012 02:52:00 GMT

概述

　　它被描述成一个与自动化相兼容的类型，由于操作系统提供相应的API函数(如SysAllocString)来管理它以及一些默认的调度代码。因此BSTR实际上就是一个COM字符串，但它却在自动化技术以外的多种场合下得到广泛使用。

为什么需要BSTR

　　COM是一种跨编程语言的平台，需要提供语言无关的数据类型。多数编程语言有自己的字符串表示。

　　●C++ 字符串是以0结束的ASCII或Unicode字符数组。

　　●Visual Basic字符串是一个ASCII字符数组加上表示长度的前缀。

　　●Java字符串是以0结束的Unicode字符数组。

　　需要定义一种通用的字符串类型，可以很容易的匹配到不同编程语言。在C++中，就是BSTR。

什么是BSTR

　　BSTR是“Basic STRing”的简称，微软在COM/OLE中定义的标准字符串数据类型。

　　对于C++，Windows头文件wtypes.h中定义如下：

　　typedef wchar_t WCHAR;

　　typedef WCHAR OLECHAR;

　　typedef OLECHAR __RPC_FAR *BSTR;;

　　使用以Null结尾的简单字符串在COM component间传递不太方便。因此，标准BSTR是一个有长度前缀和null结束符的OLECHAR数组。BSTR的前4字节是一个表示字符串长度的前缀。BSTR长度域的值是字符串的字节数，并且不包括0结束符。

　　由于是Unicode串，所以字符数是字节数的一半。这种方式的优点是允许程序员在BSTR串中间嵌入NULL字符。但是，BSTR的前四个字节表示长度，而OLECHAR数组的前四字节表示前两个字符。这种情况下，对于C++程序，如何实现BSTR和OLECHAR的交换？答案是COM提供了两个BSTR分配用的API：SysAllocString / SysReallocString。函数返回的指针指向BSTR的第一个字符，而不是BSTR在内存的第一个字节。

什么时候使用BSTR

　　只有在你不得不用的时候。

　　使用BSTR一般有以下几种情况：

　　●COM interface接口定义，并且不希望额外提供custom marshaling库（MDIL生成或开发人员自己订制），必须使用BSTR传递字符串。使用C/C++类型的字符串在COM DLL传递字符串，表面上可以使用，但违背了COM的基本规则，并且给以后的扩展留下了隐患。例如，把一个In-process COM Object(简单说COM DLL)改成out-of-process object（COM EXE）。理论上，客户端的代码应该不做任何改变。但如果是用了C/C++字符串，又希望只使用系统的automation mashaller（Oleaut32.dll），就会出错。

　　●如果可以提供custom marshaling，也推荐使用BSTR。

　　●客户要求接口必须使用BSTR，和客户讨论后，不能修改。

　　●使用的外部库的接口使用BSTR

　　不使用的情况：

　　●不推荐在IDL结构体中定义BSTR成员，会给结构体的复制和释放带来麻烦。最好直接使用限定最大长度的TCHAR数组。如果确实需要传递变长字符串，BSTR应该被定义成独立的参数或者使用独立的get/set接口。

　　●尽可能缩小的BSTR及相关类型的作用域范围。类的成员变量和函数参数不使用BSTR。局部变量要尽快释放类的内部不使用BSTR。代码处理逻辑中只在接口直接相关部分使用BSTR。接收到一个BSTR时，尽量立刻变成C/C++的字符串副本进行处理。在需要传递BSTR参数前产生BSTR，用过立即释放。

BSTR、char*和CString转换

　　(1) char*转换成CString

　　若将char*转换成CString，除了直接赋值外，还可使用CString::Format进行。例如：

char chArray[] = "This is a test";

char * p = "This is a test";

　　或

LPSTR p = "This is a test";

　　或在已定义Unicode应的用程序中

TCHAR * p = _T("This is a test");

　　或

LPTSTR p = _T("This is a test");

CString theString = chArray;

theString.Format(_T("%s"), chArray);

theString = p;

　　(2) CString转换成char*

　　若将CString类转换成char*(LPSTR)类型，常常使用下列三种方法：

　　方法一，使用强制转换。例如：

CString theString( "This is a test" );

LPTSTR lpsz =(LPTSTR)(LPCTSTR)theString;

　　方法二，使用strcpy。例如：

CString theString( "This is a test" );

LPTSTR lpsz = new TCHAR[theString.GetLength()+1];

_tcscpy(lpsz, theString);

　　需要说明的是，strcpy(或可移值Unicode/MBCS的_tcscpy)的第二个参数是 const wchar_t* (Unicode)或const char* (ANSI)，系统编译器将会自动对其进行转换。

　　方法三，使用CString::GetBuffer。例如：

CString s(_T("This is a test "));

LPTSTR p = s.GetBuffer();

// 在这里添加使用p的代码

if(p != NULL) *p = _T('\0');

s.ReleaseBuffer();

// 使用完后及时释放，以便能使用其它的CString成员函数

　　(3) BSTR转换成char*

　　方法一，使用ConvertBSTRToString。例如：

#include

#pragma comment(lib, "comsupp.lib")

int _tmain(int argc, _TCHAR* argv[]){

BSTR bstrText = ::SysAllocString(L"Test");

char* lpszText2 = _com_util::ConvertBSTRToString(bstrText);

SysFreeString(bstrText); // 用完释放

delete[] lpszText2;

return 0;

}

　　方法二，使用_bstr_t的赋值运算符重载。例如：

_bstr_t b = bstrText;

char* lpszText2 = b;

　　(4) char*转换成BSTR

　　方法一，使用SysAllocString等API函数。例如：

BSTR bstrText = ::SysAllocString(L"Test");

BSTR bstrText = ::SysAllocStringLen(L"Test",4);

BSTR bstrText = ::SysAllocStringByteLen("Test",4);

　　方法二，使用COleVariant或_variant_t。例如：

//COleVariant strVar("This is a test");

_variant_t strVar("This is a test");

BSTR bstrText = strVar.bstrVal;

　　方法三，使用_bstr_t，这是一种最简单的方法。例如：

BSTR bstrText = _bstr_t("This is a test");

　　方法四，使用CComBSTR。例如：

BSTR bstrText = CComBSTR("This is a test");

　　或

CComBSTR bstr("This is a test");

BSTR bstrText = bstr.m_str;

　　方法五，使用ConvertStringToBSTR。例如：

char* lpszText = "Test";

BSTR bstrText = _com_util::ConvertStringToBSTR(lpszText);

　　(5) CString转换成BSTR

　　通常是通过使用CStringT::AllocSysString来实现。例如：

CString str("This is a test");

BSTR bstrText = str.AllocSysString();

…

SysFreeString(bstrText); // 用完释放

　　(6) BSTR转换成CString

　　一般可按下列方法进行：

BSTR bstrText = ::SysAllocString(L"Test");

CStringA str;

str.Empty();

str = bstrText;

　　或

CStringA str(bstrText);

　　(7) ANSI、Unicode和宽字符之间的转换

　　方法一，使用MultiByteToWideChar将ANSI字符转换成Unicode字符，使用WideCharToMultiByte将Unicode字符转换成ANSI字符。

　　方法二，使用“_T”将ANSI转换成“一般”类型字符串，使用“L”将ANSI转换成Unicode，而在托管C++环境中还可使用S将ANSI字符串转换成String*对象。例如：

TCHAR tstr[] = _T("this is a test");

wchar_t wszStr[] = L"This is a test";

String* str = S”This is a test”;

　　方法三，使用ATL 7.0的转换宏和类。ATL7.0在原有3.0基础上完善和增加了许多字符串转换宏以及提供相应的类，它具有如图3所示的统一形式：

　　其中，第一个C表示“类”，以便于ATL 3.0宏相区别，第二个C表示常量，2表示“to”，EX表示要开辟一定大小的缓冲。SourceType和DestinationType可以是A、T、W和OLE，其含义分别是ANSI、Unicode、“一般”类型和OLE字符串。例如，CA2CT就是将ANSI转换成一般类型的字符串常量。下面是一些示例代码：

LPTSTR tstr= CA2TEX<16>("this is a test");

LPCTSTR tcstr= CA2CT("this is a test");

wchar_t wszStr[] = L"This is a test";

char* chstr = CW2A(wszStr);

　　六、结语

　　几乎所有的程序都要用到字符串，而Visual C++.NET由于功能强大、应用广泛，因而字符串之间的转换更为频繁。本文几乎涉及到目前的所有转换方法。当然对于.NET框架来说，还可使用Convert和Text类进行不同数据类型以及字符编码之间的相互转换。

hello wold! 2012-03-28 10:52 发表评论

MFC 教程MFC 教程 MFC 教程

hello wold! — Tue, 27 Mar 2012 05:52:00 GMT

作者序
-----------
我曾写一本关于MFC的书，分析了MFC的结构和设计(《MFC深入浅出》)，华中理工大学出版。书的内容建立在对MSDN和MFC SOURCE CODE的大量分析上，该书对于希望学习MFC的人来说，是较有价值的。可惜出版社好象只在几个城市针对学生作销售，虽然学生反应不错，但是外界知道不多。

名称

来源 http://www.vczx.com/tutorial/mfc/mfc.php

hello wold! 2012-03-27 13:52 发表评论

vs2008 ActiveX控件测试容器的生成以及调试ActiveX控件

hello wold! — Tue, 27 Mar 2012 03:36:00 GMT

vs2008 ActiveX控件测试容器的生成以及调试ActiveX控件分类：ActiveXVS20082011-04-28 17:10277人阅读评论(0)收藏举报 1、ActiveX控件测试容器的生成：用TSTCON生成测试容器 http://msdn.microsoft.com/zh-cn/library/f9adb5t5(v=vs.90).aspx 在搜索里搜索tstcon,双击TstCon文件夹，将此文件夹里的东西全部复制到另外一个新的空文件里，然后打开解决方案 tstcon.sln，记住要把平台选为win32,然后Build即可。在生成的Debug或Release文件夹中找到TstCon32.exe，双击即可ActiveX Control Test Container，然后在里面进行相应的操作就行了。 2、调试ActiveX控件: http://technet.microsoft.com/zh-cn/office/w54zfak1.aspx 按照以上网页中的步骤配置完后，设置断点，按F5，会打开ActiveX Control Test Container，在Edit菜单里选择Insert New Control...就可以进行调试了。

hello wold! 2012-03-27 11:36 发表评论

VS2008 在IE中调试 ActiveX控件

hello wold! — Tue, 27 Mar 2012 00:29:00 GMT

VS2008 在IE中调试 ActiveX控件

分类： C++/VC Tech 2008-08-31 23:12 4035人阅读评论(0) 收藏举报

不知道是不是微软的粗心大意，VS2008中竟然没有ActiveX控件测试容器。

幸好需要在IE中测试控件，就不需要那个测试容器啦。

1. 生产测试控件的HTML：

Test

CLASSID="CLSID:5228A02F-8FBD-424C-B457-EEBD4E748504">

2. 设置debug选项

command: C:/Program Files/Internet Explorer/iexplore.exe

command arguments: F:/test.htm

3. 全路径

注册ocx时，需要使用全路径。否则就有错误：The sepcified module could not be found.

4. 在Vista下的问题

由于UAC的控制，需要用"Run as Admin"的方式运行

否则就有“1>Project : error PRJ0050: Failed to register output.”错误。

hello wold! 2012-03-27 08:29 发表评论

libjson编译好之后需要设置jsonoptions选项

hello wold! — Mon, 26 Mar 2012 03:42:00 GMT

用libjson的时候，怎么也找不到parse方法，后来一查才知道，需要设置选项，把jsonOptions.h粘上来

#ifndef JSON_OPTIONS_H
#define JSON_OPTIONS_H

/**
*  This file holds all of the compiling options for easy access and so
*  that you don't have to remember them, or look them up all the time
*/

/*
*  JSON_LIBRARY must be declared if libjson is compiled as a static or dynamic
*  library.  This exposes a C-style interface, but none of the inner workings of libjson
*/
//#define JSON_LIBRARY

/*
*  JSON_STRICT removes all of libjson's extensions.  Meaning no comments, no special numbers
*/
//#define JSON_STRICT

/*
*  JSON_DEBUG is used to perform extra error checking.  Because libjson usually
*  does on the fly parsing, validation is impossible, so this option will allow
*  you to register an error callback so that you can record what is going wrong
*  before the library crashes.  This option does not protect from these errors,
*  it simply tells you about them, which is nice for debugging, but not preferable
*  for release candidates
*/
#define JSON_DEBUG

/*
*  JSON_ISO_STRICT turns off all code that uses non-standard C++.  This removes all
*  references to long long and long double as well as a few others
*/
//#define JSON_ISO_STRICT

/*
*  JSON_SAFE performs similarly to JSON_DEBUG, except this option does protect
*  from the errors that it encounters.  This option is recommended for those who
*  feel it's possible for their program to encounter invalid json.
*/
#define JSON_SAFE

/*
*  JSON_STDERROR routes error messages to cerr instead of a callback, this
*  option hides the callback registering function.  This will usually display
*  messages in the console
*/
//#define JSON_STDERROR

/*
*  JSON_PREPARSE causes all parsing to be done immediately.  By default, libjson
*  parses nodes on the fly as they are needed, this makes parsing much faster if
*  your program gets a lot of information that it doesn't need.  An example of
*  this would be a client application communicating with a server if the server
*  returns things like last modified date and other things that you don't use.
*/
//#define JSON_PREPARSE

/*
*  JSON_LESS_MEMORY will force libjson to let go of memory as quickly as it can
*  this is recommended for software that has to run on less than optimal machines.
*  It will cut libjson's memory usage by about 20%, but also run slightly slower.
*  It's recommended that you also compile using the -Os option, as this will also
*  reduce the size of the library
*/
//#define JSON_LESS_MEMORY

/*
*  JSON_UNICODE tells libjson to use wstrings instead of regular strings, this
*  means that libjson supports the full array of unicode characters, but also takes
*  much more memory and processing power.
*/
//#define JSON_UNICODE

/*
*  JSON_REF_COUNT causes libjson to reference count JSONNodes, which makes copying
*  and passing them around much faster.  It is recommended that this stay on for
*  most uses
*/
#define JSON_REF_COUNT

/*
*  JSON_BINARY is used to support binary, which is base64 encoded and decoded by libjson,
*  if this option is not turned on, no base64 support is included
*/
//#define JSON_BINARY

/*
*  JSON_EXPOSE_BASE64 is used to turn on the functionality of libjson's base64 encoding
*  and decoding.  This may be useful if you want to obfuscate your json, or send binary data over
*  a network
*/
//#define JSON_EXPOSE_BASE64

/*
*  JSON_ITERATORS turns on all of libjson's iterating functionality.  This would usually
*  only be turned off while compiling for use with C
*/
#define JSON_ITERATORS

/*
*  JSON_STREAM turns on libjson's streaming functionality.  This allows you to give parts of
*  your json into a stream, which will automatically hit a callback when full nodes are
*  completed
*/
//#define JSON_STREAM

/*
*  JSON_MEMORY_CALLBACKS exposes functions to register callbacks for allocating, resizing,
*  and freeing memory.  Because libjson is designed for customizability, it is feasible
*  that some users would like to further add speed by having the library utilize a memory
*  pool.  With this option turned on, the default behavior is still done internally unless
*  a callback is registered.  So you can have this option on and not use it.
*/
//#define JSON_MEMORY_CALLBACKS

/*
*  JSON_MEMORY_MANAGE is used to create functionality to automatically track and clean
*  up memory that has been allocated by the user.  This includes strings, binary data, and
*  nodes.  It also exposes bulk delete functions.
*/
//#define JSON_MEMORY_MANAGE

/*
*    JSON_MEMORY_POOL Turns on libjson's iteraction with mempool++.  It is more efficient that simply
*    connecting mempool++ to the callbacks because it integrates things internally and uses a number
*    of memory pools.  This value tells libjson how large of a memory pool to start out with.  500KB
*    should suffice for most cases.  libjson will distribute that within the pool for the best
*    performance depending on other settings.
*/
//#define JSON_MEMORY_POOL 524288

/*
*  JSON_MUTEX_CALLBACKS exposes functions to register callbacks to lock and unlock
*  mutexs and functions to lock and unlock JSONNodes and all of it's children.  This
*  does not prevent other threads from accessing the node, but will prevent them from
*  locking it. It is much easier for the end programmer to allow libjson to manage
*  your mutexs because of reference counting and manipulating trees, libjson automatically
*  tracks mutex controls for you, so you only ever lock what you need to
*/
//#define JSON_MUTEX_CALLBACKS

/*
*  JSON_MUTEX_MANAGE lets you set mutexes and forget them, libjson will not only keep
*  track of the mutex, but also keep a count of how many nodes are using it, and delete
*  it when there are no more references
*/
//#define JSON_MUTEX_MANAGE

/*
*  JSON_NO_C_CONSTS removes consts from the C interface.  It still acts the same way, but
*  this may be useful for using the header with languages or variants that don't have const
*/
//#define JSON_NO_C_CONSTS

/*
*  JSON_OCTAL allows libjson to use octal values in numbers.
*/
//#define JSON_OCTAL

/*
*  JSON_WRITE_PRIORITY turns on libjson's writing capabilties.  Without this libjson can only
*  read and parse json, this allows it to write back out.  Changing the value of the writer
*  changes how libjson compiles, and how fast it will go when writing
*/
#define JSON_WRITE_PRIORITY MED

/*
*  JSON_READ_PRIORITY turns on libjson's reading capabilties.  Changing the value of the reader
*  changes how libjson compiles, and how fast it will go when writing
*/
#define JSON_READ_PRIORITY HIGH

/*
*  JSON_NEWLINE affects how libjson writes.  If this option is turned on, libjson
*  will use whatever it's defined as for the newline signifier, otherwise, it will use
*  standard unix \n.
*/
//#define JSON_NEWLINE "\r\n"  //\r\n is standard for most windows and dos programs

/*
*  JSON_INDENT affects how libjson writes.  If this option is turned on, libjson
*  will use \t to indent formatted json, otherwise it will use the number of characters
*  that you specify.  If this is not turned on, then it will use the tab (\t) character
*/
//#define JSON_INDENT "    "

/*
*  JSON_ESCAPE_WRITES tells the libjson engine to escape special characters when it writes
*  out.  If this option is turned off, the json it outputs may not adhere to JSON standards
*/
//#define JSON_ESCAPE_WRITES

/*
*  JSON_COMMENTS tells libjson to store and write comments.  libjson always supports
*  parsing json that has comments in it as it simply ignores them, but with this option
*  it keeps the comments and allows you to insert further comments
*/
//#define JSON_COMMENTS

/*
*  JSON_WRITE_BASH_COMMENTS will cause libjson to write all comments in bash (#) style
*  if this option is not turned on, then it will use C-style comments.  Bash comments are
*  all single line
*/
//#define JSON_WRITE_BASH_COMMENTS

/*
*  JSON_WRITE_SINGLE_LINE_COMMENTS will cause libjson to write all comments in using //
*  notation, or (#) if that option is on.  Some parsers do not support multiline C comments
*  although, this option is not needed for bash comments, as they are all single line anyway
*/
//#define JSON_WRITE_SINGLE_LINE_COMMENTS

/*
*  JSON_ARRAY_SIZE_ON_ON_LINE allows you to put small arrays of primitives all on one line
*  in a write_formatted.  This is common for tuples, like coordinates.  If must be defined
*  as an integer
*/
//#define JSON_ARRAY_SIZE_ON_ONE_LINE 2

/*
*  JSON_VALIDATE turns on validation features of libjson.
*/
//#define JSON_VALIDATE

/*
*  JSON_CASE_INSENSITIVE_FUNCTIONS turns on funtions for finding child nodes in a case-
*  insenititve way
*/
//#define JSON_CASE_INSENSITIVE_FUNCTIONS

/*
*  JSON_INDEX_TYPE allows you th change the size type for the children functions. If this
*  option is not used then unsigned int is used.  This option is useful for cutting down
*  on memory, or using huge numbers of child nodes (over 4 billion)
*/
//#define JSON_INDEX_TYPE unsigned int

/*
*  JSON_BOOL_TYPE lets you change the bool type for the C interface.  Because before C99 there
*  was no bool, and even then it's just a typedef, you may want to use something else.  If this
*  is not defined, it will revert to int
*/
//#define JSON_BOOL_TYPE char

/*
*  JSON_INT_TYPE lets you change the int type for as_int.  If you ommit this option, the default
*  long will be used
*/
//#define JSON_INT_TYPE long

/*
*  JSON_STRING_HEADER allows you to change the type of string that libjson uses both for the
*  interface and internally.  It must implement most of the STL string interface, but not all
*  of it.  Things like wxString or QString should wourk without much trouble
*/
//#define JSON_STRING_HEADER "../TestSuite/StringTest.h"

/*
*  JSON_UNIT_TEST is used to maintain and debug the libjson.  It makes all private
*  members and functions public so that tests can do checks of the inner workings
*  of libjson.  This should not be turned on by end users.
*/
//#define JSON_UNIT_TEST

/*
*  JSON_NO_EXCEPTIONS turns off any exception throwing by the library.  It may still use exceptions
*  internally, but the interface will never throw anything.
*/
//#define JSON_NO_EXCEPTIONS

/*
*  JSON_DEPRECATED_FUNCTIONS turns on functions that have been deprecated, this is for backwards
*  compatibility between major releases.  It is highly recommended that you move your functions
*  over to the new equivalents
*/
#define JSON_DEPRECATED_FUNCTIONS

/*
*  JSON_CASTABLE allows you to call as_bool on a number and have it do the 0 or not 0 check,
*  it also allows you to ask for a string from a number, or boolean, and have it return the right thing.
*  Without this option, those types of requests are undefined.  It also exposes the as_array, as_node, and cast
*  functions
*/
//#define JSON_CASTABLE

/*
*  JSON_SECURITY_MAX_NEST_LEVEL is a security measure added to make prevent against DoS attacks
*  This only affects validation, as if you are worried about security attacks, then you are
*  most certainly validating json before sending it to be parsed.  This option allows you to limitl how many
*  levels deep a JSON Node can go.  128 is a good depth to start with
*/
//#define JSON_SECURITY_MAX_NEST_LEVEL 128

/*
*  JSON_SECURITY_MAX_STRING_LENGTH is another security measure, preventing DoS attacks with very long
*  strings of JSON.  32MB is the default value for this, this allows large images to be embedded
*/
//#define JSON_SECURITY_MAX_STRING_LENGTH 33554432

/*
*    JSON_SECURITY_MAX_STREAM_OBJECTS is a security measure for streams.  It prevents DoS attacks with
*    large number of objects hitting the stream all at once.  128 is a lot of objects, but not out of
*    the question for high speed systems.
*/
#define JSON_SECURITY_MAX_STREAM_OBJECTS 128

#endif

hello wold! 2012-03-26 11:42 发表评论

C++博客-Hello World！-文章分类-技术相关

BSTR

为什么需要BSTR

什么是BSTR

什么时候使用BSTR

MFC 教程MFC 教程 MFC 教程

vs2008 ActiveX控件测试容器的生成以及调试ActiveX控件

VS2008 在IE中 调试 ActiveX控件

VS2008 在IE中 调试 ActiveX控件

libjson编译好之后需要设置jsonoptions选项

VS2008 在IE中调试 ActiveX控件

VS2008 在IE中调试 ActiveX控件