附录 A 语法总结

本附录描述一般 C++ 语言中的语法 , 按在 Microsoft C++ 编译器中的实现。它是按本书的章节结构松散地按如下进行组织 :

在第 1 章 “ 词汇规定 ” 的 “ 关键字 ” 一节中描述关键字。
在第 4 章 “ 表达式 ” 的 “ 表达式 ” 一节中描述表达式语法。
在第 6 章 “ 说明 ” 的 “ 说明 ” 一节中描述说明的语法。
在第 7 章 “ 说明符 ” 的 “ 说明符 ” 一节中描述说明符语法。
在第 8 章 “ 类 ” 的 “ 类 ” 一节中讨论用于说明类的语法。
在第 5 章 “ 语句 ” 的 “ 语句 ” 一节中讨论用于写语句的语法。
在 “ Microsoft 扩展 ” 一节上讨论只适用于 Microsoft C++ 的特性。很多这些特性在附录 B “ Microsoft 特殊修饰符 ” 中涉及。

关键字

类名称 :

标识符枚举名称 :

标识符

typedef 名称 :

标识符

标识符 : 以下之一

非数字

标识符非数字标识符数字

非数字 : 以下之一

_ a b c d e f g h I j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M

N O P Q R S T U V W X Y Z 数字 : 以下之一

0 1 2 3 4 5 6 7 8 9

表达式

表达式 :

赋值表达式

表达式 , 赋值表达式赋值表达式 :

条件表达式

单目表达式赋值运算符赋值表达式

赋值运算符 : 以下之一

= *= /= %= += -= >= <= &= ^= |= 条件表达式 :

逻辑或表达式

逻辑或表达式 ? 表达式 : 条件表达式逻辑或表达式 :

逻辑与表达式

逻辑或表达式 || 逻辑与表达式逻辑与表达式：

逻辑或表达式

逻辑与表达式 && 或表达式或表达式 :

异或表达式

或表达式 | 异或表达式异或表达式 :

与表达式

异或表达式 ^ 与表达式与表达式 :

相等表达式

与表达式 & 相等表达式相等表达式 :

关系表达式

相等表达式 == 关系表达式相等表达式 != 关系表达式

关系表达式 :

移位表达式

关系表达式 < 移位表达式关系表达式 > 移位表达式关系表达式 <= 移位表达式关系表达式 >= 移位表达式

移位表达式 :

加法表达式

移位表达式 << 加法表达式移位表达式 >> 加法表达式

加法表达式 :

乘法表达式

加法表达式 + 乘法表达式加法表达式 - 乘法表达式

乘法表达式 :

段表达式

乘法表达式 * 段表达式乘法表达式 / 段表达式乘法表达式 % 段表达式

段表达式 :

指向成员指针表达式

段表达式 :> 指向成员指针表达式指向成员指针表达式 :

类型转换表达式

指向成员指针表达式 .* 类型转换表达式指向成员指针表达式 ->* 类型转换表达式

类型转换表达式 : 单目表达式

( 类型名称 ) 类型转换表达式单目表达式 :

后缀表达式

++ 单目表达式

-- 单目表达式

单目运算符类型转换表达式sizeof 单目运算符

sizeof ( 类型名称 ) 分配表达式

取消分配表达式单目运算符 : 以下之一

* & + - ! ~ 分配表达式：

:: _opt new 位置 _opt new 类型名称 new 初始化符 _opt

:: _opt new 位置 _opt ( 类型名称 ) new 初始化符 _opt

位置 :

( 表达式表 ) new 类型名称 :

类型指示符表 new 说明符 _opt

new 说明符 :

ms 修饰符表 _opt * cv 限定符表 _opt new 说明符 _opt ms 修饰符表 _opt 完整类名称 :: *cv 限定符表 _opt new 说明符 _opt

new 说明符 _opt [ 表达式 ] new 初始化器 :

( 初始化器表 ) 取消分配表达式 :

::opt delete 造型表达式

::opt delete[ ] 造型表达式后缀表达式 :

基本表达式

后缀表达式 [ 表达式 ] 后缀表达式 ( 表达式表 )

简单类型名称 ( 表达式表 ) 后缀表达式 . 名称

后缀表达式 -> 名称

后缀表达式 ++ 后缀表达式 -

dynamic_cast< 类型标识 > ( 表达式 ) static_cast< 类型标识 > ( 表达式 ) const_cast< 类型标识 > ( 表达式 ) reinterpret_cast< 类型标识 > ( 表达式 ) typeid( 表达式 )

typeid( 类型标识 ) 表达式表 :

赋值表达式

表达式表 , 赋值表达式基本表达式 :

literal this

:: 标识符

:: 运算符函数名称

:: 限定名 ( 表达式 ) 名称

名称 :

标识符

运算符函数名称转换函数名称

～类名称限定名

限定名 :

ms 修饰符表 _opt 限定类名称 :: 名称literal:

整型常量字符型常量浮点型常量字符串文字

整型常量 :

十进制常量整型后缀 _opt 八进制常量整型后缀 _opt 十六进制常量整型后缀 _opt

c 字符序列 ′ 十进制常量 :

非零数字

十进制常量数字八进制常量 :

八进制常量八进制数字十六进制常量 :

0x 十六进制数字

0X 十六进制数字

十六进制常量十六进制数字非零数字 : 以下之一

1 2 3 4 5 6 7 8 9 八进制数字 : 以下之一

0 1 2 3 4 5 6 7 十六进制数字 : 以下之一

0 1 2 3 4 5 6 7 8 9 a b c d e f

A B C D E F 整型后缀 :

无符号后缀长整型后缀 _opt

长整型后缀无符号后缀 _opt

无符号后缀 : 以下之一u U

长整型后缀 : 以下之一l L

字符常量 :

'c 字符序列 ' L'c 字符序列 '

c 字符序列 :

c 字符

c 字符序列 c 字符c 字符 :

源字符集中除单引号 ( ′ ) 、反斜线 (\) 、换行字符以外的任何字符转义字符

转义字符 :

简单转义字符八进制转义字符

十六进制转义字符简单转义序列 : 以下之一

\ ′ \" \? \\

\a \b \f \n \r \t \v 八进制转义序列 :

\ 八进制数字

\ 八进制数字八进制数字

\ 八进制数字八进制数字八进制数字十六进制转义序列 :

\x 十六进制数字

十六进制转义序列十六进制数字浮点常量 :

分数常量指数部分 _opt 浮点后缀 _opt

数字序列指数部分浮点后缀 _opt

分数常量 :

数字序列 _opt . 数字序列数字序列 .

指数部分 :

e 符号 _opt 数字序列E 符号 _opt 数字序列

符号 : 以下之一

+ - 数字序列 :

数字

数字序列数字浮点后缀 : 以下之一

f l F L 字符串文字 :

"s 字符串序列 _opt " L"s 字符串序列 _opt"

s 字符序列 :

s 字符

s 字符序列 s 字符s 字符 :

源字符集中除双引号 (") 、反向斜线 (\) 、换行字符以外的任何字符转义序列

说明

说明 :

说明说明符 _opt 说明符表 _opt

asm 说明函数定义连接规格模板说明

asm 说明 :

_asm( 字符串文字 ); 说明指示符表

说明指示符表 _opt 说明指示符说明指示符 :

存储类指示符类型指示符函数指示符friend typedef

_{__}declspec( 扩展说明修饰符序列 ) 存储类型指示符：

auto register

static extern

函数指示符：

inline virtual

类型指示符：

简单类型名称类指示符

枚举指示符全类型指示符const volatile

扩展说明修饰符序列 : 扩展说明修饰符 _opt

扩展说明修饰符扩展说明修饰符序列扩展说明修饰符：

thread naked dllimport dllexport

简单类型名称 :

完整类型名称

char short int long signed unsigned float double void

全类型指示符：

类关键字标识符类关键字类名称枚举名称

类关键字：

class struct union

限定类型名称 : typedef 名称

类名称 :: 限定类型名称完整类名称 :

:: 限定类型名称限定类型名称 :

类名称

类名称 :: 限定类型名称枚举指示符 :

enum 标识符 _opt { 枚举列表 _opt } 枚举列表 :

枚举符

枚举列表 , 枚举符枚举符 :

标识符

标识符 = 常量表达式常量表达式 :

条件表达式连接规格 :

extern 字符串文字 { 说明表 _opt }

extern 字符串文字说明说明表 :

说明

说明表说明模板说明 :

模板参量表 :

模板参量

模板参量表 , 模板参量模板参量 :

类型参量参量说明

类型参量 :

class 标识符模板类名称 :

模板名称 < 模板参量表 > 模板参量表 :

模板参量

模板参量表 , 模板参量模板参量表 :

模板参量

模板参量表 , 模板参量模板参量 :

表达式类型名称

原始名称空间名称 : 标识符

名称空间定义 :

原始名称空间定义扩展名称空间定义无名名称空间定义

原始名称空间定义 :

namespace 标识符 { 名称空间体 } 扩展名称空间定义 :

namespace 原始名称空间名称 { 名称空间体 } 无名名称空间定义：

namespace { 名称空间体 } 名称空间体 :

说明序列 _opt

id 表达式 :

无限定 id 限定 id

嵌套名称指示符 :

类或名称空间名称 :: 嵌套名称指示符 _opt

类或名称空间名称 : 类名称

名称空间名称名称空间名称 :

原始名称空间名称

名称空间别名名称空间别名 :

标识符

名称空间别名定义 :

namespace 标识符 = 限定名称空间指示符 ; 限定名称空间指示符 :

:: _opt 嵌套名称指示符 _opt 类或名称空间名称用法说明 :

using:: _opt 嵌套名称指示符未限定 id using:: 未限定 id

用法命令 :

using namespace :: _opt 嵌套名称指示符 _opt 名称空间名称

说明符

说明符表 :

初始化说明符

说明符表 , 初始化说明符初始化说明符 :

ms 修饰符表 _opt 说明符初始化器 _opt

说明符 :

说明名称

指针运算符说明符

说明符 ( 参量说明表 ) cv 修饰符表 _opt

说明符 [ 常量表达式 _opt ] ( 说明符 )

cv 修饰符表 :

cv 限定符 cv 修饰符表 _opt

指针运算符 :

ms 修饰符表 _opt * cv 限定符表 _opt

ms 修饰符表 _opt & cv 限定符表 _opt

ms 修饰符表 _opt 完整类型名称 :: *cv 限定符表 _opt

cv 修饰符表 :

cv 修饰符 cv 修饰符表 _opt

cv 限定符 :

const volatile

dname:

名称类名称

～类型名称typedef 名称限定类型名称

类型名称 :

类型指示符表 ms 修饰符表 _opt 抽象说明符 _opt

类型指示符表 :

类型指示符类型指示符表 _opt

抽象说明符 :

指针运算符 ms 修饰符表 _opt 抽象说明符 _opt 抽象说明符 _opt ( 参量说明表 ) cv 限定符表抽象说明符 _opt [ 常量表达式 _opt ]

(ms 修饰符表 _opt 表抽象说明符 ) 参数说明表 :

参量说明表 _opt _opt

参量说明表 , . . .

参量说明表 :

参数说明

参量说明表 , 参数说明参数说明 :

decl 指示符 ms 修饰符表 _opt 说明符

decl 指示符 ms 修饰符表 _opt 说明符 = 表达式decl 指示符 ms 修饰符表 _opt 抽象说明符 _opt

decl 指示符 ms 修饰符表 _opt 抽象说明符 _opt = 表达式函数定义 :

decl 指示符 _opt ms 修饰符表 _opt 说明符 ctor 初始化器 _opt 函数体函数体 :

复合语句初始化器 :

= 表达式

= { 初始化器表 _opt } ( 表达式表 )

初始化器表 :

表达式

初始化器表 , 表达式

{ 初始化器表 , _opt }

类

类指示符 :

类头 { 成员表 _opt } 类头 :

类关键字环境模式 _opt 标识符 _opt 基类指示符 _opt

类关键字环境模式 _opt 类名称基类指示符 _opt

成员表 :

成员说明成员表 _opt

访问指示符 : 成员表 _opt

成员说明 :

说明指示符成员说明符表 _opt ;

函数定义 ; _opt

限定名 ;

成员说明符表 : 成员说明符

成员说明符表 , 成员说明符成员说明符 :

ms 修饰符表 _opt 说明符纯指示符 _opt

标识符 _opt : 常量表达式纯指示符 :

基类指示符 :

: 基类表基类表 :

基类指示符

基类表 , 基类指示符基类指示符 :

完整类名称

virtual 访问指示符 _opt 完整类名称

访问指示符 virtual _opt 完整类名称访问指示符 :

private protected

public

转换函数名称 :

operator 转换类型名称转换类型名称 :

类型指示符表指针运算符 _opt

ctor 初始化器 :

: 成员初始化器表成员初始化器表 :

成员初始化器

成员初始化器 , 成员初始化器表成员初始化器 :

完整类名称 ( 表达式表 _opt) 标识符 ( 表达式表 _opt )

运算符函数名称 : operator 运算符

运算符 : 以下之一

new delete

+	-	*	/	%	^	&	\|	~
!	=	<	>	+=	-=	*=	/=	%=
^=	&=	\|=	<<	>>	>>=	<<=	==	!=
<=	>=	&&	\|\|	++	--	,	->*	->
()	[]

语句

语句 :

标号语句

表达式语句

复合语句

选择语句

迭代语句

跳转语句

说明语句

try-except 语句

try-finally 语句标号语句

标识符 : 语句

case 常量表达式 : 语句

default : 语句表达式语句 :

表达式 _{opt ; 复合语句 :}

{ 语句表 _opt } 语句表 :

语句

语句表语句选择语句 :

if ( 表达式 ) 语句

if ( 表达式 ) 语句 else 语句

switch ( 表达式 ) 语句迭代语句 :

while ( 表达式 ) 语句

do 语句 while ( 表达式 ) ;

for (for 初始化语句表达式 _opt ; 表达式 _opt) 语句for 初始化语句 :

表达式语句

说明语句跳转语句 :

break;

continue;

return 表达式 _opt ;

goto 标识符 ; 说明语句 :

说明

try-except 语句 :

_{__} try 复合语句

_{__} excep t ( 表达式 ) 复合语句

try-finally 语句 :

_{__} try 复合语句

_{__} finally ( 表达式 ) 复合语句

M icrosoft 扩展

asm 说明 :

_{__}asm 汇编指令 ; _opt

_{__}asm { 汇编指令表 } ; _opt

汇编指令表 : 汇编指令 ; _opt

汇编指令 ; 汇编指令表 ; _opt

ms 修饰符表 :

ms 修饰符 ms 修饰符表 _opt

ms 修饰符 :

_{__}cdecl

_{__}fastcall

_{__}stdcall

_{__}syscall( 为将来实现而保留 )

_{__}oldcall( 为将来实现而保留 )

_{__}unaligned( 为将来实现而保留 ) 基修饰符

基修饰符 :

_{__}based ( 基类型 ) 基类型 :

名称

附录 B M icrosoft 特殊修饰符

很多 Microsoft 特殊的关键字可以用来修饰说明符以形成派生类型 ( 有关说明符的更多信息参见第 7 章 “ 说明符 ” ) 。

表 B.1 Microsoft 特殊的关键字

关键字	意义	是否用于形成派生类
_{__} asm	加入后续的汇编语言代码	否
_{__} based	把后续的名称说明为相对于说明中所包含的 32 位基址的一个 32 位的偏移	是
	地址
_{__} cdecl	把后面跟着的名称按 C 语言规则命名并用 C 语言的调用规则。	是
_{__} declspec	把后面跟着的名称 (thread,naked, dllimport,dllexport) 说明为	否
	Microsoft 特殊的存储属性
_{__} fastcall	把后面所说明的函数名称说明为只要有可能就使用寄存器来传递参数而不	是
	是用堆栈来传递参数

_{__} stdcall 把后面所说明的函数名称说明为遵循

标准转换规则

续表

是

下面的几节讨论有关 Microsoft 的特殊修饰符的句法使用和语义上的意义。

基地址

这一节包括下面一些主题 :

__ based
基指针
基于指针的指针

在 32 位的编辑环境中使用 _{__} based

当你要显式控制分配静态和动态基址数据对象的段时 , 基地址是很有用的。

在 32 位编辑环境中 , 基地址的唯一可接受形式是 “ 基于一个指针 ” , 该指针定义了一个对于一个 32 位的基址所含的 32 位的偏址 ; 或者基于 void 型。

语法

基范围修饰符 :

_{__} based ( 基表达式 ) 基表达式 :

基变量

基抽象说明符段名称

段造型基变量 :

标识符

基抽象说明符 : 抽象说明符

基类型 :

类型名称

基指针

在 32 位的编辑环境中 , _{__}based 关键字的唯一有效形式是基于指针地址的指针。在这种编辑环境中 , 基指针是一个对 32 位基地址的 32 位的偏移量。

当对一个基地址指针进行间接引用时 , 基地址要么是显式地说明了的 , 要么是通过说明已经隐含知道了的。

基于指针的指针

基地址的 “ 基于指针 ” 的变量使得可以把一个指针说明为 “ 基表达式 ”。这个基指针就成为了一个段的偏移量 , 此段开始于这个基指针所基于的地址的开始。

基于指针的指针的一个用途是为了保留含有指针的对象。一个基于指针的指针的链表可以保存到磁盘上并能重新载入到存储器的其他地方 , 并且指针依然是有效的。下面的例子说明了一个这样的链表 :

struct llist_t

{

void __ based(vpBuffer) *vpData;

llist_t __ based(vpBuffer) *llNext;

};

指针 vpBuffer 赋值为在程序后面分配的存储器地址 ; 然后该链表可以相对于vpBuffer 的值重新装载。

在 32 位的编辑环境中 , 基于指针地址的指针是 _{__} base 有效的唯一形式。在这种编辑环境中 , 它们是 32 位基址的 32 位的位置。

调用和命名的常规修饰符

调用规则决定了函数是如何调用的 ; 命名规则决定了如何对待外部名。有关详情参见联机 “ Microsoft Visual C++ 6.0 程序员指南 ” 中的 “ 调用规定主题 ”。

扩展存储类属性

这一节描述扩展属性语法 , 它精简并规范化了对 Miscrosoft C/C++ 的扩展。使用扩展属性语法的存储类属性包括 :thread 、 naked 、 dllimport 及 dllexport 。

扩展属性语法

扩展属性语法是用 __declspec 关键字说明存储类信息 , 它说明了一个给定类型的对象的实例是按 Microsoft 特殊的存储类属性 ( thread 、 naked 、 dllimport 、dllexport 、 nothrow 、 property 、 selectany 或 uuid) 进行存储。其他的存储类修饰符的例子包括 :static 和 extern 关键字。然而 , 这些关键字是 ANSI 规范的 C 和 C++ 语言的一部分 , 故而扩展属性语法不涉及它们。

下面是 C++ 的扩展属性语法 :

语法

说明指示符 :

_{__}declspec( 扩展的说明修饰符序列 ) 扩展的说明修饰符序列 :

扩展的说明修饰符 _opt

扩展的说明修饰符扩展的说明修饰符序列扩展的说明修饰符 :

thread naked dllimport dllexport nothrow property

selectany uuid("ComObjectGUID")

空白符用于分隔说明修饰符序列。语法的例子将在后面几节上给出。

存储类属性 thread 、naked 、dllimport 、dllexport 、nothrow 、property 、selectany 和 uuid 仅仅只是它们所作用的对象说明和函数说明的属性。不象 _{__}near 和 _{_
_} far 关键字 , 它们实际上影响对象或函数的类型 ( 在这种情况下 ,2 字节和 4 字节的地址 ), 这些存储类属性并不重新定义对象自身的类型属性。 thread 属性仅影响数据和对象。 naked 属性仅影响函数。 dllimport 属性和 dllexport 属性仅影响函数、数据和对象。 property 、 selectany 和 uuid 属性仅影响 COM 对象。

thread 属性

线程局部存储 (TLS) 是一种机制 , 通过这种机制，在一个多线程的进程中每个线程可以为线程特有的数据分配存储。在标准多线程的程序中 , 数据是在给定进程的所有线程中共享的 , 然而线程局部存储是一种可以为每个线程分配数据的机制。有关线程的完整讨论参见联机 “ Visual C++ 程序员指南 ” 中的 “ 多线程主题 ” 。

C/C++ 语言包括扩展存储类属性 thread 。 thread 属性必须同 _{_ _} declspec 关键字一起使用来说明一个线程变量。例如 , 下面的代码说明为一个整型线程局部变量并把它用一个值进行初始化 :

__ declspec(thread) int tls_i = 1;

在说明一个线程局部对象和变量时 , 必须遵循如下的一些准则 :

thread 属性只能适用于数据的说明和定义以及不含成员函数的类。

它还能用于函数的说明和定义。例如 , 下面的代码会产生一个编译错误 :

#define Thread _{__}declspec(thread) Thread void func(); // 错误

你只能对具有静态存储期的数据项说明 thread 属性。这包括全局数据对象 ( 包括 static 和 exte rn ) 、局部静态对象和类的静态数据成员。你不能说明一个自动类型数据对象具有 thread 属性。例如 , 下面的代码会引起编译错误 :

#define Thread __ declspec(thread) void func1()

{

Thread int tls_i; // 错误

}

int func2(Thread int tls_i) // 错误

{

return tls_i;

}

无论说明和定义是出现在同一文件中还是不同的文件中 , 对于线程局部对象的说明和定义要都使用 thread 属性。如下例子 , 下述代码会产生错误 :

#define Thread __ declspec(thread)

extern int tls_i; // 这将产生错误 ,

int Thread tls_i; // 因为说明与定义不同

你不能把 thread 属性作为类型修饰符使用。例如 , 下述代码会产生编译错误 :

char __ declspec(thread) *ch;// 错误

如果类不含有成员函数 , 则类可以用 thread 属性进行实例化。如果在类的说明部分没有说明对象则 thread 属性将被忽略。例如 :

__ declspec(thread) class X { public:

int I; } x; //x 是个线程对象X y; //y 不是一个线程对象

因为允许说明具有 thread 属性的对象 , 下面的两个例子在意义上完全一样 : #define Thread __ declspec(thread)

Thread class B

{

// 代码

} BObject;// 可以 :BObject 说明为线程局部对象class B

{

// 代码

}

Thread B BObject; // 可以 :BObject 说明为线程局部对象

标准的 C 允许用一个包含对自身引用的表达式对一个对象或变更进行初始化 , 但仅能对非静态领域的对象进行初始化。尽管 C++ 通常允许有一个包含有对自身引用的表达式对外对象进行动态初始化 , 但这种类型的初始化不能用于对线程局部对象进行初始化。例如 :

#define Thread __ declspec(thread)

Thread int tls_i = tls_i; // 在 C 和 C++ 中均是错误的int j = j; // 在 C++ 是正确的但在 C 中是错误的

Thread int tls_i = sizeof(tls_i)// 在 C 和 C++ 中均是正确的

注意 sizeof 表达式中包含了要被初始化的对象 , 但并不构成一个对自身的引用 , 因而在 C 和 C++ 中均是允许的。

naked 属性

对于用 naked 属性定义的函数 , 编译器产生的代码不会包括前言和结尾部分代码。利用这种特性你可以用内嵌汇编代码写出自己的前言和结尾部分代码序列。带 naked 属性的函数在写虚拟设备驱动程序时特别有用。

因为 naked 属性仅仅同函数的定义有关并且又不是一个类型修饰符 , 故如前面所述 , 带 naked 属性的函数使用扩展属性语法。例如如下代码定义了一个带 naked 属性的函数 :

__ declspec(naked) int func(formal_parameters)

{

// 函数体

}

或者可以写成 :

#define Naked __ declspec(naked) Naked int func(formal_parameters)

{

// 函数体

}

naked 属性只影响编译器为函数的前言和结尾部分序列产生代码的性质。它并不会影响到调用此函数所生成的代码。因此 ,naked 属性还能视为函数类型的一部分 , 并且函数指针也不能具有 naked 属性。而且 naked 属性也不能用于数据的定义。例如 , 下面的示例代码会产生错误 :

__ declspec(naked) int i; // 错误 :naked 属性不能用于数据的定义

naked 属性仅只同函数的定义有关并不能在函数的原型中说明。例如 : 下面的说明会产生编译错误 :

__ declspec(naked) int func(); // 错误 :naked 属性不能用于函数的说明

规则与限制

一个带 naked 属性的函数中不允许有返回语句。但是 , 可以通过在 RET 指令之前把一个值放入到 EAX 寄存器来返回一个整型。
结构异常处理结构在带 naked 属性的函数中是不允许的 , 因为这一结构必须交叉展开堆栈框架。
setjmp 进行时间函数也还能在带 naked 属性的函数中使用 , 因为它必须是交叉展开堆栈框架。但是使用 longjmp 运行时间函数是允许

的。

在带 naked 属性的函数中不允许使用 _alloca 函数
要保证在前言序列之前不能有对局部变量的初始化代码 , 在函数范围中初始化局部变量是不允许的。特别的 , 在函数范围中说明 C++ 对象是不允许的。然而 , 在一个嵌套的范围是可以初始化对象的。
不推荐对框架指针进行优化 (/Oy 编译器选项 ), 对于带 naked 属性的函数该指示是自动关闭的。

写前言 / 结尾部分代码考虑的事情

在写你自己的前言和结尾部分代码序列之前 , 理解堆栈框架如何布置是很重要。理解符号 _{__} LOCAL _{_} SIZE 的使用也很重要。

C++ 堆栈框架的布置

这一例子给出了可能出现在 32 位函数中的标准前言代码 : push ebp; 存储 ebp

mov ebp, esp ; 设置堆栈框架指针sub esp, localbytes; 为 locals 分配空间push<registers>; 存储 registers

localbytes 变量代表了在堆栈上为局部变量所需的字节数 , 而 <registers> 变量是一个位置容器代表了一系列要保存在堆栈上的寄存器。在保存了寄存器以后 , 你可以在堆栈上放置任何合适的数据了。下面是相应的结尾部分代码 :

pop <registers> ; 恢复 registers

mov esp, ebp ; 恢复堆栈指针pop ebp ; 恢复 ebp

ret ; 从函数返回

堆栈总是向下生长的 ( 从存储器高地址向存储器低地址生长 ) 。基指针 (ebp) 指向是由 ebp 压入的值。这一局部区开始于 ebp-2 。要存储局部变量 , 只要通过从 ebp 中减去一个合适的值 , 从 ebp 中计算出正确的偏移量即可。

_{__} LOCAL _ SIZE

编译器提供了一个符号 ( _{__} LOCAL _{_} SIZE) 用于在函数前言代码的内嵌汇编块中使用。

在自定义的前言代码中 , 这一符号是用于在堆栈框架上为局部变量分配空间。

编译器决定了 _{__} LOCAL _{_}SIZE 值的大小。它的值是所有用户自定义的局部变量和编译器生成的临时变量的整体字节大小。_{__} LOCAL _{_}SIZE 只能作为直接操作数来使用 ; 它不能在表达式中使用。也不能够重定义或改变该符号的值。例如 :

mov eax, __ LOCAL_SIZE ; 直接操作数 , 正确mov eax, [ebp - __ LOCAL_SIZE] ; 错误

下面的例子上一个含有自定义的前言和结尾部分序列的带 naked 属性的函数 , 在前言序列中使用了 _{__} LOCAL _{_} SIZE 符号 :

__ declspec (naked) func()

{

int i;

int j;

__ asm /* 前言代码 */

{

push ebp

move e bp, esp

sub esp, __ LOCAL_SIZE

}

/* 函数体 */

__ asm /* 结尾部分代码 */

{

move e sp, ebp

pop ebp

ret

}

dllexport 和 dllimport 属性

存储类修饰符 dllexport 和 dllimport 是为了从一个 DLL 中输出及输入函数、数据和对象。这些修饰符或者属性 , 显式定义了 DLL 对用户端的接口 , 用户端可以是一个可执行文件或另一个 DLL 。把函数说明为具有 dllexport 属性可以不

需要模块定义文件 (.DEF), 至少可以不需要输出函数的说明部分。注意 dllexport 代替了 _{_ _}export 关键字。

说明 dllexport 和 dllimport 要用扩展属性语法。

__ declspec(dllexport) void func();

为了增加你的代码的可读性 , 可以用下面的宏定义。#define DllImport __ declspec(dllimport) #define DllExport __ declspec(dllexport)

DllExport void func(); DllExport int i = 10; DllImport int j; DllExport int n;

定义和说明

DLL 的接口涉及到由系统中的其他程序显式输出的项 ( 函数和数据 ); 也即 , 所有说明为 dllimport 和 dllexport 的项。包括在 DLL 接口中的所有说明必须说明为要么具有 dllimport 属性 , 要么具有 dllexport 属性。然而 , 定义仅只能说明为具有 dllexport 属性。例如下面的函数定义会产生编译错误 :

__ declspec(dllimport) int func() // 错误 : 在定义中不能用 dllimport 属性

{

return 1;

}

下面的代码也会产生错误 :

#define DllImport __ declspec(dllimport)

__ declspec(dllimport) int i = 10; // 错误 : 这是一个定义然而下面的代码是正确的 :

__ declspec(dllexport) int i = 10; // 正确 :export 定义

使用 dllexport 隐含了一个定义 , 而使用 dllimport 隐含了一个说明。你必须把extern 关键字同 dllexport 一起使用以强制一个说明 ; 否则将隐含一个定义。因此 , 下面的代码是正确的 :

#define DllImport __ declspec(dllimport) #define DllExport __ declspec(dllexport)

extern DllImport int k; // 这两个都是正确的DllImport int j; // 并隐含了一个说明

下面的例子阐明了前面所解释的 :

static __ declspec(dllimport) int l; // 错误 : 没有说明为 extern 的

void func()

{

st atic __ declspec(dllimport) int s; // 错误 : 没有说明为 extern 的

__ declspec(dllimport) int m; // 正确 : 这是一个说明

__ declspec(dllexport) int n; // 错误 : 隐含了一个在局部范围

// 的外部定义

extern __ declspec(dllimport) int i; // 正确 : 这是一个说明

extern __ declspec(dllexport) int k; // 正确 :extern 暗示了是一个说明

__ declspec(dllexport) int x = 5; // 错误 : 隐含了一个在局部范围

// 的外部定义

}

用 dllexport 和 dllimport 定义 C++ 函数

可以定义一个有 dllexport 属性的内嵌函数。在此情况下 , 无论是否有程序中的其他模块引用了该函数 , 函数总是被实例化的并且是被输出的。该函数假定是被其他程序输入的。

也可以用 dllimport 属性定义一个联编函数。在此情况下 , 函数是可扩充的 ( 遵循编译指示 /Ob), 但从不被实例化的。特别是 , 如果取一个输入联编函数的地址 , 则将返回该函数驻留在 DLL 中的地址。这种行为就象取一个非联编的输入函数的地址一样。

这一规则适用于其定义出现在类定义中的联编函数。而且 , 在联编函数中的静态局部数据和字符串将在 DLL 和用户端中保持同样的标识 , 因为它们是在同一程序中的 ( 即 , 一个没有 DLL 接口的可执行文件 ) 。

在提供一个输入的联编函数时要非常小心。例如 : 如果你更新了 DLL, 你不能假定用户端会使用改变后的 DLL 版本。要保证能够载入正确的 DLL 版本 , 得重新编译 DLL 客户程序。

一般规则及限制

如果你没有用 dllexport 和 dllimport 属性说明一个函数和对象 , 该函数和对象就不会作为 DLL 接口的一部分。因此 , 必须在此模块中或者同一程序的其他模块中提供对该函数和对象的定义。要使函数和对象成为 DLL 接口的一部分 , 你必须在其他模块中用 dllexport 说明对函数及对象的定义。否则会产生一个链接器错误。

如果你用 dllexport 和 dllimport 属性说明一个函数和对象 , 则它们的定义必须出现在同一程序的某个模块中。否则会产生一个链接器错误。

如果在你的程序的单一模块中 , 对同一函数或对象同时包含了dllexport 和 dllimport 属性的说明 , 则 dllexport 属性将取代dllimport 属性处于优先权地位。但编译器会给出一个警告错误 : 例如 :

__ declspec(dllimport) int i;

__ declspec(dllexport) int i; // 警告 : 不一致 ;

// dllexport 处于优先地位

在 C++ 中 , 你可以用一个带有 dllimport 属性的数据对象的地址去初始化一个全局说明的或静态局部的数据指针。然而在 C 中 , 这种初始化会产生错误。而且在 C++ 中 , 也可以用一个带有 dllimport 属性的函数的地址去初始化一个静态局部函数指针。在 C 中 , 这种赋值会把指针指向 DLL 输入 thunk 区 (thunk, 是一种用于传递控制给函数的残留代码 ) 的地址 , 而并未把函数的地址赋给指针。在 C++ 中 , 则会使指针指向函数的地址。例如 :

__ declspec(dllimport) void func1(void);

__ declspec(dllimport) int i;

int *pi = &i; // 在 C 中错误

static void (*pf)(void) = &func1; // 在 C 中是 thunk 区的地址 , 在 C++

// 中是函数的地址void func2()

{

static int *pi = &i; // 在 C 中错误

static void (*pf)(void) = &func1; // 在 C 中是 thunk 区的地址 ,

// 在 C++ 中是函数的地址

}

然而 , 因为一个程序如果包含了有 dllexport 属性说明的对象 , 它必须在程序的某个地方为该对象提供定义。因此 , 你可以用一个带有 dllexport 属性的函数地址去初始化一个全局的或者局部静态的函数指针。同样，也可以用一个带有dllexport 属性的数据对象地址去初始化一个全局的或者局部静态的数据指针。例如 : 下面的代码在 C 或 C++ 中不会产生错误 :

__ declspec(dllexport) void func1(void);

__ declspec(dllexport) int i;

int *pi = &i; // 可以static void (*pf)(void) = &func1; // 可以

void func2()

{

static int *pi = &i; // 可以static void (*pf)(void) = &func1; // 可以

}

在 C++ 中使用 dllimport 和 dllexport

可用 dllimport 和 dllexport 属性说明 C++ 的类。这一形式隐含了整个类是输入的或者是输出的。以这种方法输出的类称为可输出类。

下面的例子定义了一个可输出类。它的所有成员函数和静态数据是输出的 : #define DllExport __ declspec(dllexport)

class DllExport C

{

int i;

virtual int func(void)

{ return 1; }

};

注意在一个可输出类的成员函数上禁止显式使用 dllimport 和 dllexport 属性。

输出类

在说明一个输出类时 , 它的所有成员函数和静态数据成员是输出的。必须在同一程序中提供所有这些成员的定义。否则 , 会产生一个链接错误。这一规则在应用于纯虚拟函数时有一个异常 , 对于纯虚拟函数不必提供显式的定义。然而 , 因为抽象类的析构函数总是由基类的析构函数调用的 , 所以纯虚拟析构函数总是必须要提供一个定义的。这一规则对于非可输出的类也是同样的。

如果你输出了类类型数据或者返回类的函数 , 一定要输出该类。

输入类

在你说明一个输入类时 , 它的所有成员函数和静态数据成员是输入的。同dllimport 和 dllexport 属性作用在非类类型上的行为不同 , 静态数据成员不能在定义输入类的同一程序中说明一个定义。

继承和输出类

可输出类的所有基类必须是可输出的。如果不是这样 , 会产生一个编译警告。而且 , 所有可访问的类类型成员也必须是可输出的。这一规则允许一个输出类继承一个输入类 , 而一个输入类继承一个输出类 ( 尽管不推荐后者的用法 ) 。作为一个规则 , 对于 DLL 的客户端可访问的每一个成员 ( 按照 C++ 的访问规则 ) 应该是可输出接口的一部分。这包括在联编函数中引用的私有数据成员。

有选择地输入 / 输出成员

因为在一个类中的成员函数和静态数据隐含地具有外部连接 , 除非整个类被输出

了。你可以用 dllimport 和 dllexport 属性说明它们。如果类是被输入的或输出的 , 则禁止显式说明成员函数和数据为 dllimport 和 dllexport 属性。如果你在类定义中说明一个静态数据成员具有 dllexport 属性 , 必须在同一程序的某个地方提供定义 ( 因为具有非类的外部连接 ) 。

同样地 , 你可以说明具有 dllimport 和 dllexport 属性的成员函数。在这种情形下 , 你必须在同一程序的某个地方提供一个 dllexport 定义。

关于有选择地输入 / 输出成员有以下一些关键点值得注意 :

有选择地输入 / 输出成员能很好地用于提供一种更加严谨的输出类接口 ; 也就是 , 用这种接口设计一个 DLL 能够比不用时暴露更少的公有及私有的属性。在微调输出接口中 , 这也是很有用的 : 通过定义 , 在你了解了客户端不能访问某些私有数据时 , 不必输出整个类。
如果输出了类中的一个虚拟函数 , 必须输出所有的虚拟函数 , 否则至少要提供一个客户端能直接调用的版本。
如果定义了一个类 , 其中对于虚拟函数使用了有选择的输入 / 输出成员 , 则这些函数必须在输出接口中被定义为联编的 ( 对客户端可见 ) 。
如果你把一个成员定义为 dllexport 属性的 , 但并没有在类定义中包含它 , 则会产生一个编译器错误。你必须在类头中定义该成员。
尽管用 dllimport 和 dllexport 属性定义类成员是允许的 , 但你不能重载在类定义中说明的接口。
如果你在说明类定义的定义体以外的地方定义了一个函数 , 并把它说明为有 dllimport 和 dllexport 属性的 ( 如果这一定义同类说明

中所说明的不同 ) 就会产生一个警告。

联编汇编器

联编汇编器使你能够在 C 语言源代码中直接包含汇编语言指令而不需要额外的汇编及链接步骤。联编汇编器是内置于编译器中的 , 所以不需要一个单独的汇编器如 Microsoft 的宏汇编 (MASM) 。

因为联编汇编器不需要单独的汇编及链接步骤 , 它比单独的汇编器更方便。联编汇编器代码能够使用处在同一范围中的任何 C 的变量名称和函数名称 , 因此它很容易同你编写的 C 代码集成在一起。并且正是因为汇编代码能和 C 语句混合使用 , 它可以用来解决一些很麻烦的任务以及单独用 C 不可解决的任务。

_{__}asm 关键字将激活联编汇编器，并能出现在 C 语句可合法出现的任何地方。该关键字之后必须跟有汇编指令 , 或由大括号括起的一组指令 , 或者 , 最少应有一对空的大括号 ; 而不能仅仅只出现这一关键字。这里，“ _{__} asm 块 ” 是指任何指令或一组指令 , 无论是否在大括号中。

下面的代码是一个简单的括在大括号中的 _{__} asm 块 ( 这一代码是一个函数的前言序列 ) 。

__ asm

{

push ebp

mov ebp, esp

sub esp, __ LOCAL_SIZE

}

当然 , 也可以选择把 _{__} asm 放在每一条汇编指令之前 :

__ asm push ebp

__ asm mov ebp, esp

__ asm sub esp, _{__} LOCAL _ SIZE

因为 _{__} asm 关键字是一个语句的分隔符，也可以在同一行中放置多条汇编指令 :

__ asm push ebp _{__} asm mov ebp, esp __ asm sub esp, _{__} LOCAL_SIZE

附录 C 编译器 C O M 支持类

Microsoft 特殊处 →

一些标准类用于支持某些 COM 类型。这些类在 COMDEF.H 和从类型库中生成的头文件中定义。

#include <comdef.h>

类目的

_com_error 定义在大多数失败中由 _com_raise_error 丢弃的错误对象

_com_ptr_t 封装 COM 接口指针 , 并使对 AddRef 、 Release 、QueryInterface 的调用自动化

_bstr_t 封装 BSTR 类型以提供有用的操作和方法

_variant_t 封装 VARIANT 类型以提供有用的操作和方法

而且 , 有一个支持例程叫作 _com_raise_error, 它用于所有由编译器生成的 COM 支持代码以丢弃一个 _com_error 来响应失败。

_com_raise_error 在 comdef.h 中定义如下 :

void __ stdcall com_raise_error(HRESULT hr,IErrorInfo* perrinfo=0)

throw(_com_error); 实际的源代码是 :

void __ stdcall com_raise _ error(HRESULT hr,IErrorInfo* perrinfo)

throw(_com_error)

{

throw _com_error(hr, perrinfo);

}

_com_raise_error 可以由用户提供的具有同样名称及原型的函数版本所替代。如果你要用 #import, 但又不想用 C++ 的异常处理 , 就可以这样做。在这种情况下 , 用户自定义的 _com_raise_error 版本可以决定是作一个 longjmp 还是弹出一个消息框或者停机。这一用户版本不应返回 , 尽管因为编译器 COM 支持代码并不希望它返回。

Microsoft 特殊处结束

_com_error

Microsoft 特殊处 →

一个 _com_error 对象代表了一个异常条件 , 这一异常条件能由从类型库生成的头文件中的错误处理封装函数检测到或者能由 COM 支持类检测到。类 _com_error 封装了 HRESULT 错误代码和相关联的 IErrorInfo 对象。

#include <comdef.h>

构造函数

_com_error 构造一个 _com_error 对象

运算符

operator =\ 把一个已存在的 _com_error 对象赋值给另外一个

Extractor 函数

Error 检索传递给构造函数的 HRESULT 值

ErrorInfo 检索传递给构造函数的 IErrorInfo 对象

WCode 检索映射到封装的 HRESULT 上的 16 位错误代码

IErrorInfo 函数

Description 调用 IErrorInfo::GetDescription 函数

HelpContext 调用 IErrorInfo::GetHelpContext 函数

HelpFile 调用 IErrorInfo::GetHelpFile 函数

Source 调用 IErrorInfo::GetSource 函数

GUID 调用 IErrorInfo::GetGUID 函数

格式消息 Extractor 函数

ErrorMessage 为存储在 _com_error 对象中的 HRESULT 检索字符串消息

ExepInfo.wCode to HRESULT Mappers

HRESULTToWCode 把 32 位的 HRESULT 映射为 16 位的 wCode

WCodeToHRESULT 把 16 位的 wCode 映射为 32 位的 HRESULT

Microsoft 特殊处结束

成员函数

_com_error::_com_error

Microsoft 特殊处 →

_com_error(HRESULT hr , IErrorInfo* perrinfo = NULL) throw();

_com_error(const _com_error& that ) throw();

参数

HRESULT 信息

perrinfo

IErrorInfo 对象

that

一个存在的 _com_error 对象

注释

构造一个 _com_error 对象。第一种构造函数用一个 HRESULT 以及一个可选的IErrorInfo 对象来构造一个 _com_error 对象。第二种构造函数是创建一个已有

_com_error 对象的拷贝。

Microsoft 特殊处结束

_com_error::Description

Microsoft 特殊处 →

_bstr_t Description() const throw ();

返回值

对于记录在 _com_error 对象中的 IErrorInfo 对象 , 返回IErrorInfo::GetDescription 的结果。结果 BSTR 是封装在一个 _bstr_t 对象中的。如果没有记录 IErrorInfo, 将返回一个空的 _bstr_t 对象。

注释

调用函数 IErrorInfo::GetDescription 并检索记录在 _com_error 对象中的IErrorInfo 。在调用 IErrorInfo::GetDescription 时的任何失败都将忽略。Microsoft 特殊处结束

_com_error::Error

Microsoft 特殊处 →

HRESULT Error() const throw();

返回值

传递给构造函数的原始 HRESULT 项。

注释

检索封装在 _com_error 对象中的 HRESULT 项。

Microsoft 特殊处结束

_com_error::ErrorInfo

Microsoft 特殊处 →

IErrorInfo * ErrorInfo() const throw();

返回值

传递给构造函数的原始 IErrorInfo 项。

注释

检索封装在 _com_error 对象中的 IErrorInfo 项 , 如果没有记录 IErrorInfo 项则返回 NULL 。当调用者完成了对返回对象的使用后 , 必须对其调用 Release 。Microsoft 特殊处结束

_com_error::ErrorMessage

Microsoft 特殊处 →

const TCHAR * ErrorMessage() const throw();

返回值

为记录在 _com_error 对象中的 IErrorInfo 返回字符串消息。如果 HRESULT 是一个映射为 16 位的 wCode, 则返回一条普通的 "IDispatch error #<wCode>" 消息。如果没有发现消息 , 则返回一条普通的 "Unknown error #<hresult>" 消息。返回的字符串可以是单代码或者多字节字符串 , 这一点有赖于 _UNICODE 宏的状态。

注释

为记录在 _com_error 对象中的 IErrorInfo 返回合适的系统消息文本。此系统消息文本是通过调用 Win32 函数 FormatMessage 获得的。返回的字符串是由FormatMessage API 分配的 , 并在 _com_error 对象消毁后将被释放。

Microsoft 特殊处结束

_com_error::GUID

Microsoft 特殊处 →

GUID GUID() const throw();

返回值

为记录在 _com_error 对象中的 IErrorInfo 返回 IErrorInfo::GetGUID 的结果。如果没有记录 IErrorInfo, 将返回 GUID_NULL 。

注释

调用 IErrorInfo::GetGUID 方法。在调用 IErrorInfo::GetGUID 方法时的任何失败都将被忽略。

Microsoft 特殊处结束

_com_error::HelpContext

Microsoft 特殊处 →

DWORD HelpContext() const throw();

返回值

为记录在 _com_error 对象中的 IErrorInfo 对象返回 IErrorInfo::GetHelpContext 的结果。如果没有记录 IErrorInfo 对象 , 将返回 0 值。

注释

调用 IErrorInfo::GetHelpContext 接口方法。调用 IErrorInfo::GetHelpContext 方法时的任何失败都将被忽略。

Microsoft 特殊处结束

_com_error::HelpFile

Microsoft 特殊处 →

_bstr_t HelpFile() const throw();

返回值

为记录在 _com_error 对象中的 IErrorInfo 对象返回 IErrorInfo::GetHelpFile 的结果。结果 BSTR 是封装在 _bstr_t 对象中的。如果没有记录 IErrorInfo, 将返回一个空的 _bstr_t 。

注释

调用 IErrorInfo::GetHelpFile 接口方法。调用 IErrorInfo::GetHelpFile 方法时的任何失败都将被忽略。

Microsoft 特殊处结束

_com_error::HRESULTToWCode

Microsoft 特殊处 →

static WORD HRESULTToWCode(HRESULT hr ) throw();

返回值

从 32 位的 HRESULT 映射的 16 位 wCode 值。

参数

要映射为 16 位 wCode 值的 32 位的 HRESULT 。

注释

完成一个 32 位 HRESULT 到 16 位 wCode 值的映射。详细的信息参见

_com_error::WCode 。

参见

_com_error::WCode ， _com_error::WCodeToHRESULT ， _com_error 概述

Microsoft 特殊处结束

_com_error::Source

Microsoft 特殊处 →

_bstr_t Source() const throw();

返回值

为记录在 _com_error 对象中的 IErrorInfo 对象返回 IErrorInfo::GetSource 的结果。

结果 BSTR 是封装在 _bstr_t 对象中的。如果没有记录 IErrorInfo, 将返回一个空的 _bstr_t 。

注释

调用 IErrorInfo::GetSource 接口方法。调用 IErrorInfo::GetSource 方法时的任何失败都将被忽略。

Microsoft 特殊处结束

_com_error:: WCode

Microsoft 特殊处 →

WORD WCode () const throw();

返回值

如果 HRESULT 是在 0x80040200 ～ 0x8004FFFF 的范围内 , 则 WCode 方法将返回最小的 HRESULT 值 0x80040200; 否则返回 0 值。

注释

WCode 方法检索的是一个由封装的 HRESULT 映射的 16 位错误码。

WCode 方法是用于解除发生在 COM 支持代码中的映射。 dispinterface 属性的封

装器或者方法调用一个支持例程 , 该支持例程封装了参数并调用了IDispatch::Invoke 函数。在返回时 , 如果返回了一个 DISP_E_EXCEPTION 的失败 HRESULT , 则从 EXCEPINFO 结构中检索错误信息 , 并传递给 IDispatch::Invoke 函数。错误码可以是存储在 EXCEPINFO 结构 wCode 成员中的 16 位值 , 或者是EXCEPINFO 结构的 scode 成员中的完全的 32 位值。如果返回的是 16 位 wCode, 则它必定先映射为了 32 位的失败 HRESULT 。

参见

_com_error::HRESULTToWCod e ， _com_error::WCodeToHRESULT ， _com_error 概述

Microsoft 特殊处结束

_com_error:: WCodeToHRESULT

Microsoft 特殊处 →

static HRESULT WCodeToHRESULT(WORD w Code ) throw();

返回值

从一个 16 位的 wCode 映射为 32 位 HRESULT 值。

参数

wCode

是一个映射为 32 位 HRESUL T 的 16 位 wCode 值。

注释

完成一个 16 位的 wCode 到 32 位 HRESULT 的映射。参见 WCode 成员函数。

参见

_com_error::W C ode ， _com_error::HRESULTToWCode ， _com_error 概述

Microsoft 特殊处结束运算符

_com_error::operator =

Microsoft 特殊处 →

_com_error& operator = (const _com_error& that ) throw ();

参数

that

一个 _com_error 对象

注释

把一个已有的 _com_error 对象赋值给另外一个。

Microsoft 特殊处结束

_com_ptr_t

Microsoft 特殊处 →

个 _com_prt_t 对象封装了一个 COM 接口指针 , 被称为是 “ 灵敏 ” 指针。这一个模板类通过对 IUnknown 的成员函数 QueryInterface 、 AddRef 及 Release 的调用 , 来管理资源的分配和回收。
个 “ 灵敏 ” 指针通常由 _COM_SMARTPTR_TYPEDEF 宏提供的类

型定义来引用。

此宏带有一个接口名称和一个 IID, 并说明了一具带有接口名加上 Ptr 前缀的特殊的 _com_ptr_t 。例如 :

_COM_SMARTPTR_TYPEDEF(IMyInterface, __uuidof(IMyInterface)); 说明了 _com_ptr_t 特例化的 IMyInterfacePtr 。

系列的函数模板 ( 非此模板类的成员 ) 支持在比较运算符的右手边出现 “ 灵敏 ” 指针的比较。

#include <comdef.h>

构造函数

_com_ptr_t 构造一个 _com_ptr_t 对象

低级操作

AddRef 在封装的接口指针上调用 IUnknown 的成员函数 AddRef

Attach 封装这一灵敏指针类型的原始接口指针

CreateInstance 按所给的 CLSID 或 ProgID 创建一个新的对象实例

Detach 抽出并返回封装的接口指针

GetInterfacePtr 返回封装的接口指针

QueryInterface 在封装的接口指针上调用 IUnknown 的成员函数 QueryInterface

Release 在封装的接口指针上调用 IUnknown 的成员函数 Release

运算符

operator = 把一个新值赋给一个已有的 _com_ptr _t 对象

operators ==, !=,

<,>,<=,>=

把一个 “ 灵敏 ” 指针同另外一个 “ 灵敏 ” 指针、原始接口指针、及 NULL 进行比较

Extractors 提取封装的 COM 接口指针

Microsoft 特殊处结束成员函数

_com_ptr_t::_com_ptr_t

Microsoft 特殊处 →

_com_ptr_t() throw();

_com_ptr_t(Interface* pInterface) throw();

_com_ptr_t(Interface* pInterface , bool f AddRef ) throw();

_com_ptr_t(int NULL) throw(_com_error);

template< > _com_ptr_t(const _com_ptr_t& cp ) throw(); template<typename _InterfacePtr> _com_ptr_t(const _InterfacePtr& p) throw(_com_error);

template< > _com_ptr_t(const _variant_t& varSrc ) throw(_com_error);

explicit _com_ptr_t(const CLSID& clsid , DWORD dwClsContext = CLSCTX_ALL) throw( _com_error);

explicit _com_ptr_t(LPOLESTR lpOleStr , DWORD dwClsContext = CLSCTX_ALL) throw( _com_error);

explicit _com_ptr_t(LPCSTR lpcStr , DWORD dwClsContext = CLSCTX_ALL) throw(_com_error);

参数

pInterface

一个原始的接口指针

fAddRef

如果为真 , 则调用 AddRef 函数以增加对象封装的接口指针的引用计数

个 _com_ptr_t 对象

个原始接口指针 , 其类型同这个 _com_ptr_t 对象的灵
敏指针类型不同

varSrc

个 _variant_t 型对象

clsid

联合类的 CLSID

dwClsContext

正在运行的代码的上下文

lpOleStr

一个含有 lpcStr	CLSID( 以 “ { ” 开始 ) 或者	ProgID 的单代码字符串
一个含有注释	CLSID( 以 “ { ” 开始 ) 或者	ProgID 的多字节字符串

一个含有

注释

CLSID( 以 “ { ” 开始 ) 或者

ProgID 的多字节字符串

构造一个 _com_ptr_t 对象。

_com_ptr_t() 构造一个 NULL 的灵敏指针。
_com_ptr_t( pInterface ) 从这种灵敏指针类型的原始接口指针中构造一个灵敏指针。调用 AddRef 函数以增加对象封装的接口指针的引用计数。
_com_ptr_t( pInterface , fAddRe f) 从这种灵敏指针类型的原始接口指针中构造一个灵敏指针。如果 fAddRef 是真 , 则调用 AddRef 函数以增加对象封装的接口指针的引用计数。如果 fAddRef 是假 , 则此构造函数对这一原始接口指针具有所有权 , 并也不调用 AddRef 函数。
_com_ptr_t(NULL) 构造一个 NULL 的灵敏指针。该 NULL 参数必须是 0 。
_com_ptr_t( cp ) 以其它的同类型的灵敏指针的拷贝来构造一个灵敏指针。调用 AddRef 函数以增加对象封装的接口指针的引用计数。
_com_ptr_t( p ) 从一个不同的灵敏指针类型或者一个不同的原始指针来构造一个灵敏指针。调用 QueryInterface 函数以找出此灵敏指针类型的接口指针。如果函数 QueryInterface 以带一个E_NOINTERFACE 错误的失败而告终 , 则构造一个 NULL 灵敏指针。其它任何错误将会引起产生一个 _com_error 。
_com_ptr_t( varSrc ) 从一个 _variant_t 对象中构造一个灵敏指针。封装的 VARIANT 必须是 VT_DISPATCH 类型的或者是 VT_UNKNOWN 类型的 , 或者是一个能够转换为这两者之一的类型。如果函数QueryInterface 以带一个 E_NOINTERFACE 错误的失败而告终 , 则构造一个 NULL 灵敏指针。其它任何错误将会引起产生一个

_com_error 。

_com_ptr_t( clsid, dwClsContext ) 从一个联合类的 CLSID 中构造一个灵敏指针。这一函数调用 CoCreateInstance 通过成员函数CreateInstance 创建一个新的 COM 对象然后为此灵敏指针进行查询。如果函数 QueryInterface 以带一个 E_NOINTERFACE 错误的失败而告终 , 则构造一个 NULL 灵敏指针。其它任何错误将会产生一个

_com_error 。

_com_ptr_t( lpOleStr, dwClsContext) 从一个含有 CLSID ( 以 “ { ” 开始 ) 或者含有 ProgID 的 Unicode 型字符串中构造一个灵敏指针。这一函数调用 CoCreateInstance 通过成员函数 CreateInstance 创建一个新的 COM 对象然后对此灵敏指针进行查询。如果函数QueryInterface 以带一个 E_NOINTERFACE 错误的失败而告终 , 则构造一个 NULL 灵敏指针。其它任何错误将会产生一个 _com_error 。
_com_ptr_t( lpcStr , dwClsContext ) 从一个含有 CLSID ( 以 “ { ” 开

始 ) 或者含有 ProgID 的多字节型字符串中构造一个灵敏指针。这一函数调用 CoCreateInstance 通过成员函数 CreateInstance 创建一个新的 COM 对象然后对此灵敏指针进行查询。如果函数

QueryInterface 以带一个 E_NOINTERFACE 错误的失败而告终 , 则构造一个 NULL 灵敏指针。其它任何错误将会产生一个 _com_error 。

Microsoft 特殊处结束

_com_ptr_t::AddRef

Microsoft 特殊处 →

void AddRef() throw(_com_error);

注释

在封装的接口指针上调用 IUnknown::AddRef 函数。如果指针是 NULL 则产生一个 _POINTER 错误。

Microsoft 特殊处结束

_com_ptr_t::Attach

Microsoft 特殊处 →

void Attach(Interface* pInterface ) throw();

void Attach(Interface* pInterface , bool fAddRef ) throw();

参数

pInterface

个原始的接口指针

fAddRef

如果是真 , 则调用函数 AddRef; 如果是假 , 则此 _com_ptr_t 对象对原始接口指针具有所有权 , 并也不调用函数 AddRef 。

注释

封装一个此灵敏指针类型的原始接口指针。

Attach( pInterface ) 不调用 AddRef 。接口的所有权传送给了此

_com_ptr_t 对象。调用 Release 为以前封装的指针减少引用次数。

Attach( pInterface , fAddRef ) 如果 fAddRef 是真 , 则调用 AddRef 函数以增加对象封装的接口指针的引用计数。如果 fAddRef 是假 , 则此

_com_ptr_t 对象对这一原始接口指针具有所有权 , 并也不调用AddRef 函数。调用 Release 为以前封装的指针减少引用次数。

Microsoft 特殊处结束

_com_ptr_t::CreateInstance

Microsoft 特殊处 →

HRESULT CreateInstance(const CLSID& rclsid , IUnknown * pOuter =NULL, DWORD dwClsContext = CLSCTX_ALL) throw();

HRESULT CreateInstance(LPOLESTR clsidString , IUnknown * pOuter =NULL, DW ORD dwClsContext = CLSCTX_ALL) throw();

HRESULT CreateInstance(LPCSTR clsidStringA , IUnknown * pOuter =NULL, DWORD dwClsContext = CLSCTX_ALL) throw();

参数

rclsid

个 CLSID 对象。

clsidString

个含有 CLSID( 以 "{" 开始 ) 或者含有 ProgID 的单代码字符
串

clsidStringA

个含有 CLSID( 以 "{" 开始 ) 或者含有 ProgID 的多字节字符
串

dwClsContext

正在执行的代码的上下文

pOuter

对于集合体的外部未知对象

注释

按给定的 CLSID 或 ProgID 创建一个对象的新的可运行的实例。这一函数调用CoCreateInstance 通过成员函数 CreateInstance 创建一个新的 COM 对象然后对此灵敏指针进行查询。这一结果指针立即封装在 _com_ptr_t 对象之中。调用Release 为以前封装的指针减少引用次数。这一例程返回 HRESULT 以表示是成功还是失败。

CreateInstance( rclsid , dwClsContext ) 按给定的 CLSID 创建一个对象的新的可运行的实例。
CreateInstance( clsidString , dwClsContext ) 从一个含有 CLSID( 以“ { ” 开始 ) 或者含有 ProgID 的单代码字符串中创建一个对象的新的可运行的实例。
CreateInstance( clsidStringA , dwClsContext ) 从一个含有 CLSID( 以“ { ” 开始 ) 或者含有 ProgID 的多字节字符串中创建一个对象的新的可运行的实例。调用 MultiByteToWideChar, 它假设字符串是按ANSI 代码页而不是 OEM 代码页。

Microsoft 特殊处结束

_com_ptr_t::Detach

Microsoft 特殊处 →

Interface* Detach() throw();

注释

提取并返回封装的接口指针 , 然后把封装的指针存储清除为 NULL 。这将从封装中清除接口指针。程序员有责任对返回的接口指针调用 Release 函数。Microsoft 特殊处结束

_com_ptr_t::GetAcitveObject

Microsoft 特殊处 →

HRESULT GetActiveObject(const CLSID& rclsid ) throw(); HRESULT GetActiveObject(LPOLESTRE clsidString ) throw(); HRESULT GetActiveObject(LPCSTR clsidStringA ) throw(); 参数

rclsid

CLSID 对象。

clsidString

个含有 CLSID ( 以 “ { ” 开始 ) 或者 ProgID 的单代码字符串。

clsidStringA

个含有 CLSID( 以 “ { ” 开始 ) 或者 ProgID 的多字节字符串。

注释

按给定的 CLSID 或 ProgID 同一个对象的已存在的实例进行连接。这些成员函数

调用 GetActiveObject 以检索一个按 OLE 进行注册的运行对象的指针 , 然后为此接口灵敏指针的接口类型进行查询。返回的这一结果指针立即封装在 _com_ptr_t 对象之中。调用 Release 为以前封装的指针减少引用次数。这一例程返回 HRESULT 以表示是成功还是失败。

GetActiveObject( rclsid ) 按给定的 CLSID 同一个对象的已存在的实例进行连接。
GetAcitveObject( clsidString ) 按一个含有 CLSID( 以 “ { ” 开始 ) 或者含有 ProgID 的单代码字符串同一个对象的已存在的实例进行连接。
GetActiveObject( clsidStringA ) 按一个含有 CLSID( 以 “ { ” 开始 ) 或者含有 ProgID 的多字节字符串同一个对象的已存在的实例进行连接。调用 MultiByteToWideChar, 它假设字符串是按 ANSI 代码页而还是 OEM 代码页。

Microsoft 特殊处结束

_com_ptr_t::GetInterfacePtr

Microsoft 特殊处 →

Interface* GetInterfacePtr() const throw();

注释

返回封装的接口指针 , 其值可以是 NULL 。

Microsoft 特殊处结束

_com_ptr_t::QueryInterface

Microsoft 特殊处 →

template<typename _InterfaceType> HRESULT QueryInterface (const IID& iid , _InterfaceType*& p ) throw (); template<typename _InterfaceType> HRESULT QueryInterface

(const IID& iid , _InterfaceType** p ) throw();

参数

iid

个接口指针的 IID

个原始接口指针

注释

在封装的接口指针上用说明的 IID 调用 IUnknown::QueryInterface, 并在 p 中返回查询的原始接口指针。这一例程返回 HRESULT 以表示是成功还是失败。Microsoft 特殊处结束

_com_ptr_t::Release

Microsoft 特殊处 →

void Release() throw(_com_error);

注释

在封装的接口指针上调用 IUnknown::Release 函数。如果指针是 NULL 则产生一个 _POINTER 错误。

Microsoft 特殊处结束

运算符

_com_ptr_t::operator =

Microsoft 特殊处 →

_com_ptr_t& operator=(Interface* pInterface ) throw();

_com_ptr_t& operator=(int NULL) throw(_com_error);

template<> _com_ptr_t& operator=(const _com_ptr_t& cp ) throw(); template<> _com_ptr_t& operator=(const _variant_t& varSrc ) throw(_com_error);

template<typename _InterfacePtr> _com_ptr_t& operator=(const

_InterfacePtr& p)

throw(_com_error);

注释

把一个接口指针赋值给一个 _com_ptr_t 对象 :

operator=( pInterface ) 封装一个同此灵敏指针类型相同的原始接口指针。调用 AddRef 函数以增加对象封装的接口指针的引用计数 , 调用 Release 为以前封装的指针减少引用次数。
operator=(NULL) 把一个灵敏指针设为 NULL 。此 NULL 参数必须是0 。
operator=( cp ) 把一个灵敏指针设置为同此灵敏指针有相同类型的另一实例的拷贝。调用 AddRef 函数以增加对象封装的接口指针的引用计数 , 并调用 Release 为以前封装的指针减少引用次数。
operator=( varSrc ) 用一个 _variant_t 对象设置一个灵敏指针。封装的 VARIANT 必须是 VT_DISPATCH 类型或者是 VT_UNKNOWN 类型 , 或者是可以转换为上述两者之一的类型。如果函数 QueryInterface 以带一个 E_NOINTERFACE 错误的失败而告终 , 则构造一个 NULL 灵敏指针。其它任何错误将会产生一个 _com_error 。
operator=( p ) 把一个灵敏指针设置为一个有不同类型的灵敏指针或者一个不同的原始指针。调用 QueryInterface 函数以找出此灵敏指针类型的接口指针。如果函数 QueryInterface 以带一个E_NOINTERFACE 错误的失败而告终 , 则构造一个 NULL 灵敏指针。其它任何错误将会产生一个 _com_error 。

Microsoft 特殊处结束

_com_ptr_t 关系运算符

Microsoft 特殊处 →

template<typename _InterfacePtr> bool operator==(_InterfacePtr p )

throw(_com_error);

template<> bool operator==(Interface* p ) throw(_com_error); template<> bool operator==(_com_ptr_t& p ) throw(); template<> bool operator==(int NULL) throw(_com_error);

template<typename _InterfacePtr> bool operator!=(_InterfacePtr p )

throw(_com_error);

template<> bool operator!=(Interface* p ) throw(_com_error);

template<> bool operator!=(_com_ptr_t& p ) throw(_com_error); template<> bool operator!=(int NULL) throw(_com_error); template<typename _InterfacePtr> bool operator<(_InterfacePtr p )

throw(_com_error);

template<typename _InterfacePtr> bool operator>(_InterfacePtr p )

throw(_com_error);

template<typename _InterfacePtr> bool operator<=(_InterfacePtr p )

throw(_com_error);

template<typename _InterfacePtr> bool operator>=(_InterfacePtr p )

throw(_com_error)

注释

把一个灵敏指针同另外一个灵敏指针、原始接口指针或者 NULL 进行比较。除了对 NULL 指针的测试 , 这些操作首先由 IUnknown 查询指针 , 然后比较结果。Microsoft 特殊处结束

_com_ptr_t Extractors

Microsoft 特殊处 →

operator Interface*() const throw();

operator Interface&() const throw(_com_error); Interface& operator*() const throw(_com_error); Interface* operator->() const throw(_com_error); Interface** operator&() throw();

operator bool() const throw();

注释

operator Interface* 返回封装的接口指针 , 其值可能是 NULL 。
operator Interface& 返回对封装的接口指针的引用 , 如果指针是NULL 就发出一个错误。
operator* 在指针间接引用中 , 让一个灵敏指针对象行为就象一个实际封装的接口一样。
operator-> 在指针间接引用中 , 让一个灵敏指针对象行为就象一个实际封装的接口一样。
operator& 释放任何封装的接口指针 , 用 NULL 代替它 , 并返回封装指针的地址。这使得一个灵敏指针可以作为地址传递给函数 , 该函数有一个外部参数 , 通过它此函数能返回一个接口指针。
operator bool 使得灵敏指针能够用于条件表达式。如果指针不是 NULL, 这一操作返回真。

Microsoft 特殊处结束

关系函数模板

Microsoft 特殊处 →

template<typename _InterfaceType> bool operator==(int NULL,

_com_ptr_t<_InterfaceType>& p ) throw(_com_error); template<typename _Interface, typename _InterfacePtr> bool operator==

(_Interface* i , _com_ptr_t<_InterfacePtr>& p ) throw(_com_error);

template<typename _Interface> bool operator!=(int NULL,

_com_ptr_t<_Interface>& p ) throw(_com_error);

template<typename _Interface, typename _InterfacePtr> bool operator!=

(_Interface* i , _com_ptr_t<_InterfacePtr>& p ) throw(_com_error); template<typename _Interface> bool operator<(int NULL,

_com_ptr_t<_Interface>& p ) throw(_com_error);

template<typename _Interface, typename _InterfacePtr> bool operator<

(_Interface* i , _com_ptr_t<_InterfacePtr>& p ) throw(_com_error); template<typename _Interface> bool operator>(int NULL, _com_ptr_t<

_Interface>& p ) throw(_com_error);

template<typename _Interface, typename _InterfacePtr> bool operator>

(_Interface* i , _com_ptr_t<_InterfacePtr>& p ) throw(_com_error); template<typename _Interface> bool operator<=(int NULL, _com_ptr_t<

_Interface>& p ) throw(_com_error);

template<typename _Interface, typename _InterfacePtr> bool operator<=

(_Interface* i , _com_ptr_t<_InterfacePtr>& p ) throw(_com_error); template<typename _Interface> bool operator>=(int NULL, _com_ptr_t<

_Interface>& p ) throw(_com_error);

template<typename _Interface, typename _InterfacePtr> bool operator>=

(_Interface* i , _com_ptr_t<_InterfacePtr>& p ) throw(_com_error);

参数

个原始接口指针。

个灵敏指针。

注释

这些函数模板允许灵敏指针出现在比较运算符右边的比较。以上这些不是

_com_ptr_t 的成员函数。

Microsoft 特殊处结束

_bstr_t

Microsoft 特殊处 →

一个 _bstr_t 对象封装了 BSTR 数据类型。通过对函数 SysAllocString 和SysFreeString 以及其他一些 BSTR APIs 的调用 , 该类管理资源的分配和回收。类 _bstr_t 采用引用计数来避免过度的开销。

#include <comdef.h>

构造函数

_bstr_t 构造一个 _bstr_t 对象

操作

copy 构造一个封装的 BSTR 的拷贝

length 返回一个封装的 BSTR 的长度

运算符

operator = 对一个已有的 _bstr_t 对象赋新值

operator += 在一个 _bstr_t 对象的尾部增加新的字符

operator + 连接两个字符串

operator ! 检查封装的 BSTR 是否是一个空串

operator ==, !=, <, >, <=,

比较两个 _bstr_t 对象

operator wchar_t*, char* 从封装的 Unicode 或多字节 BSTR 对象中提取

指针

Microsoft 特殊处结束成员函数

_bstr_t::_bstr_t

Microsoft 特殊处 →

_bstr_t() throw();

_bstr_t(const _bstr_t& s1 ) throw();

_bstr_t(const char* s2 ) throw(_com_error);

_bstr_t(const wchar_t* s3 ) throw(_com_error);

_bstr_t(const _variant_t& var ) throw (_com_error);

_bstr_t(BSTR bstr , bool fCopy ) throw (_com_error);

参数

个要拷贝的 _bstr_t 对象。

个多字节的字符串。

个单代码字符串。

var

个 _variant_t 对象。

bstr

个已存在的 BSTR 对象。

fCopy

如果是假 ,bstr 参数将同一个新的对象相联 , 并也会调用函数 SysAllocString 创建一个拷贝。

注释

构造一个 _bstr_t 对象。

_bstr_t() 构造一个封装一个 NULL BSTR 对象的缺省 _bstr_t 对象。
_bstr_t(_bstr_t& s1) 把一个 _bstr_t 对象构造为另一个的拷贝。这是一个 “ 影子 ” 拷贝 , 因为它只增加对封装的 BSTR 对象的引用计数 , 而不是创建一个新的对象。
_bstr_t(char* s2 ) 通过调用 SysAssocString 函数创建新的 BSTR

对象来构造一个 _bstr_t 对象 , 并封装此 BSTR 对象。此构造函数首先采用一个从多字节至单代码的转换。

_bstr_t(wchar_t* s3 ) 通过调用 SysAssocString 函数创建新的BSTR 对象来构造一个 _bstr_t 对象 , 并封装此 BSTR 对象。
_bstr_t(_variant_t& var ) 通过从封装的 VARIANT 对象中提取BSTR 对象来从一个 _variant_t 对象构造 _bstr_t 对象。
_bstr_t(BSTR bstr, bool fCopy ) 从一个已存在的 BSTR 对象 ( 同wchar_t* 字符串相反 ) 中构造一个 _bstr_t 对象。如果 fCopy 是假 , 则提供的 BSTR 将同新的对象连接 , 并不是通过调用函数SysAllocString 创建一个新的拷贝。在类型库头文件中的包装器(wrapper) 函数使用这种方法封装并取一个 BSTR 对象拥用者 , 该方法是在一个 _bstr_t 对象中通过接口方法返回。

Microsoft 特殊处结束

_bstr_t::copy

Microsoft 特殊处 →

BSTR copy() const throw(_com_error);

注释

返回一个封装的 BSTR 对象的最新分配的拷贝。

Microsoft 特殊处结束

_bstr_t::length

Microsoft 特殊处 →

unsigned int length () const throw();

注释

返回一个封装的 BSTR 对象的长度。

Microsoft 特殊处结束运算符

_bstr_t::operator =

Microsoft 特殊处 →

_bstr_t& operator=(const _bstr_t& s1 ) throw ();

_bstr_t& operator=(const char* s2 ) throw(_com_error);

_bstr_t& operator=(const wchar_t* s3 ) throw(_com_error);

_bstr_t& operator=(const _variant_t& var ) throw(_com_error);

参数

个要赋值给已存在的 _bstr_t 对象的 _bstr_t 对象。

个要赋值给已存在的 _bstr_t 对象的多字节字符串。

个要赋值给已存在的 _bstr_t 对象的单代码字符串。

var

个要赋值给已存在的 _bstr_t 对象的 _variant_t 对象。

注释

对一个已存在的 _bstr_ 对象赋一个新值。

Microsoft 特殊处结束

_bstr_t::operator +=, +

Microsoft 特殊处 →

_bstr_t& operator+=(const _bstr_t& s1 ) throw(_com_error);

_bstr_t operator+(const _bstr_t& s1 ) const throw(_com_error); friend _bstr_t operator+(const char* s2 , const _bstr_t& s1 ); friend _bstr_t operator+(const wchar_t* s3 , const _bstr_t& s1 ); 参数

个 _bstr_t 对象。

个多字节字符串。

个单代码字符串。

注释

这些操作完成字符串的连接 :

operator+=( s1 ) 把 s1 封装对象 BSTR 中的字符加到此对象封装的BSTR 的尾部。
operator+( s1 ) 把该对象的 BSTR 同 s1 中的 BSTR 相连并返回新的

_bstr_t 。

operator+( s2 ， s1 ) 把一个多字节字符串 s2( 转换为 Unicode 型 ) 同 s1 中封装的 BSTR 相连 , 并返回新的 _bstr_t 。
operator+( s3 , s1 ) 把一个单代码字符串 s3 同 s1 中封装的 BSTR 相连 , 并返回新的 _bstr_t 。

Microsoft 特殊处结束

_bstr_t::operator !

Microsoft 特殊处 →

bool operator!() const throw();

注释

检查封装的 BSTR 对象是否为 NULL 字符串。如果是返回真 , 否则返回假。

Microsoft 特殊处结束

_bstr_t 关系运算符

Microsoft 特殊处 →

bool operator==(const _bstr_t& str ) const throw(); bool operator!=(const _bstr_t& str ) const throw(); bool operator<(const _bstr_t& str ) const throw(); bool operator>(const _bstr_t& str ) const throw(); bool operator<=(const _bstr_t& str ) const throw(); bool operator>=(const _bstr_t& str ) const throw();

注释

这些操作按字典次序比较两个 _bstr_t 对象。如果能进行比较 , 则返回真 ; 否则返回假。

Microsoft 特殊处结束

_bstr_t::wchar_t*, _bstr_t::char*

Microsoft 特殊处 →

operator const wchar_t*() const throw(); operator wchar_t*() const throw();

operator const char*() const throw(_com_error); operator char*() const throw(_com_error);

注释

这些操作可用于提取封装的单代码或多字节 BSTR 对象的原始指针。这些运算符返回指向实际内部的缓冲区的指针 , 因此结果字符串是不能被修改的。Microsoft 特殊处结束

_variant_t

Microsoft 特殊处 →

一个 _variant_t 对象封装了 VARIANT 数据类型。该类管理的分配和回收 , 并在合适的时候对函数 VariantInit 和 VariantClear 进行调用。

#include <comdef.h>

构造函数

_variant_t 构造一个 _variant_t 对象

运算符

Attach 把一个 VARIANT 对象连接到一个 _variant_t 对象中

Clear 清除封装的 VARIANT 对象

ChangeType 把一个 _variant_t 对象的类型改变为说明的 VARTYPE Detach 把一个 VARIANT 对象从一个 _variant_t 对象中除去连

接

SetString 把一个字符串赋值给一个 _variant_t 对象

运算符

operator = 对一个已存在的 _variant_t 对象赋以新值。

operator ==, != 比较两个 _variant_t 对象相等还是不等。

Extractors 从一个封装的 VARIATN 对象中提取数据。

Microsoft 特殊处结束

成员函数

_variant_t::_variant_t

Microsoft 特殊处 →

_variant_t() throw();

_variant_t(const VARIANT& varSrc ) throw(_com_error);

_variant_t(const VARIANT* pVarSrc ) throw(_com_error);

_variant_t(const _variant_t& var_t_Src ) throw(_com_error);

_variant_t(VARIANT& varSrc, bool fCopy ) throw(_com_error);

_variant_t(short sSrc , VARTYPE vtSrc = VT_I2) throw(_com_error);

_variant_t(long lSrc , VARTYPE vtSrc = VT_I4) throw(_com_error);

_variant_t(float fltSrc ) throw();

_variant_t(double dblSrc , VARTYPE vtSrc = VT_R8) throw(_com_error);

_variant_t(const CY& cySrc ) throw();

_variant_t(const _bstr_t& bstrSrc ) throw(_com_error);

_variant_t(const wchar_t * wstrSrc ) throw(_com_error);

_variant_t(const char* strSrc ) throw(_com_error);

_variant_t(bool bSrc) throw();

_variant_t(IUnknown* pIUknownSrc , bool fAddRef = true) throw();

_variant_t(IDispatch* pDispSrc , bool fAddRef = true) throw();

_variant_t(const DECIMAL& decSrc ) throw();

_variant_t(BYTE bSrc ) throw();

参数

varSrc

要被拷贝到一个新的 _variant_t 对象的 VARIANT 对象。

pVarSrc

要被拷贝到一个新的 _variant_t 对象的 VARIANT 对象的指针。

var_t_Src

要被拷贝到一个新的 _variant_t 对象的 _variant_t 对象。

fCopy

如果是假 , 则提供的 VARIANT 对象就同新的 _variant_t 对象连接 , 而不会调用VariantCopy 以创建一个新的拷贝。

ISrc , sSrc

一个要拷贝到新的 _variant_t 对象中的整型值。

vtSrc

为新 _variant_t 对象的 VARTYPE 。

fltSrc, dblSrc

个要拷贝到新的 _variant_t 对象中的数字值。

cySrc

个要拷贝到新的 _variant_t 对象中的 CY 对象。

bstrSrc

个要拷贝到新的 _variant_t 对象中的 _bstr_t 对象。

strSrc, wstrSrc

个要拷贝到新的 _variant_t 对象中的字符串。

bSrc

个要拷贝到新的 _variant_t 对象中的布尔型值。

pIUknownSrc

将要封装在新的 _variant_t 对象中的指向 VT_UNKNOWN 对象的 COM 接口指针。

pDispSrc

将要封装在新的 _variant_t 对象中的指向 VT_DISPATCH 对象的 COM 接口指针。

decSrc

个要拷贝到新的 _variant_t 对象中的十进制值。

bSrc

个要拷贝到新的 _variant_t 对象中的字节值。

注释

构造一个 _variant_t 对象。

_variant_t() 构造一个空的 _variant_ 对象 VT_EMPTY 。
_variant_t(VARIANT& varSrc ) 用一个 VARIANT 对象的拷贝构造一个 variant_t 对象。 variant 类型被保留。
_variant_t(VARIANT* pVarSrc ) 用一个 VARIANT 对象的拷贝构造一个 variant_t 对象。 variant 类型被保留。
_variant_t( _variant_t & var_t_Src ) 从其它的 _variant_t 对象中构造一个 _variant_t 对象。 variant 类型被保留。
_variant_t(VARIANT& varSrc , bool fCopy ) 从其它已存在的VARIANT 对象中构造一个 _variant_t 对象。如果 fCopy 是假 , 则VARIANT 对象将同新的对象连接而不会创建一个拷贝。
_variant_t(short sSrc , VARTYPE vtSrc = VT_I2) 从一个短整型值中构造一个有 VT_I2 或者 VT_BOOL 类型的 _variant_t 对象。任何其它的 VARTYPE 会导致一个 E_INVALIDARG 错误。
_variant_t(long lSrc , VARTYPE vtSrc = VT_I4) 从一个长整型值中构造一个有 VT_I4 或者 VT_BOOL 或者 VT_ERROR 类型的 _variant_t 对象。任何其它的 VARTYPE 会导致一个 E_INVALIDARG 错误。
_variant_t(float fltSrc ) 从一个浮点数值中构造一个有 VT_R4 类型的 _variant_t 对象。
_variant_t(double dblSrc , VARTYPE vtSrc = VT_R8) 从一个双精度型数值中构造一个有 VT_R8 或者 VT_DATE 类型的 _variant_t 对象。任何其它的 VARTYPE 会导致一个 E_INVALIDARG 错误。
_variant_t(CY& cySrc) 从一个 CY 对象中构造一个有 VT_CY 类型的 _variant_t 对象。
_variant_t(_bstr_t& bstrSrc ) 从一个 _bstr_t 对象中构造一个有VT_BSTR 类型的 _variant_t 对象。将会分配一个新的 BSTR 。
_variant_t(wchar_t * wstrSrc ) 从一个 Unicode 型字符串中构造一个有 VT_BSTR 类型的 _variant_t 对象。将会分配一个新的 BSTR 。
_variant_t(char* strSrc) 从一个字符串中构造一个有 VT_BSTR 类型的 _variant_t 对象。将会分配一个新的 BSTR 。
_variant_t(bool bSrc ) 从一个 Bool 型值中构造一个有 VT_BOOL 类型的 _variant_t 对象。
_variant_t(IUnknown* pIUknownSrc , bool fAddRef = true) 从

一个 COM 接口指针中构造一个有 VT_UNKNOWN 类型的 _variant_t 对象。如果 fAddRef 的值是真 , 对提供的接口指针调用 AddRef 函数以匹配当 _variant_t 对象在消毁时将要调用的 Release 函数。程序员有责任对提供的接口指针调用 Release 。如果 fAddRef 是假 , 由此构造函数对提供的接口指针有所有用 , 并且也不对提供的接口指针调用 Release 。

_variant_t(IDispatch* pDispSrc , bool fAddRef = true) 从一个

COM 接口指针中构造一个有 VT_DISPATCH 类型的 _variant_t 对象。如果 fAddRef 的值是真 , 对提供的接口指针调用 AddRef 函数以匹配当 _variant_t 对象在消毁时将要调用的 Release 函数。程序员有责任对提供的接口指针调用 Release 。如果 fAddRef 是假 , 由此构造函数对提供的接口指针有所有用 , 并且也不对提供的接口指针调用Release 。

_variant_t(DECIMAL& decSrc ) 从一个数字值构造一个具有

VT_DECIMAL 类型的 _variant_t 对象。

_variant_t(BYTE bSrc ) 从一个 BYTE 值构造一个具有 VT_UI1 类型的

_variant_t 对象。

Microsoft 特殊处结束

_variant_t::Attach

Microsoft 特殊处 →

void Attach(VARIANT& varSrc ) throw(_com_error);

参数

varSrc

一个将要同此 _variant_t 对象连接的 VARIANT 对象。

注释

通过封装此 VARIANT 而取得其所有权。这一成员函数释放任何存在的封装的VARIANT, 然后拷贝所提供的 VARIANT, 并把它的 VARTYPE 设置为 VT_EMPTY 以使得其资源仅仅只能由 _variant_t 的析构函数释放。

Microsoft 特殊处结束

_variant_t::Clear

Microsoft 特殊处 →

void Clear() throw(_com_error);

注释

对封装的 VARIANT 对象调用 VariantClear 。

Microsoft 特殊处结束

_variant_t::ChangeType

Microsoft 特殊处 →

void ChangeType(VARTYPE vartype , const _variant_t* pSrc = NULL) throw(_com_error);

参数

vartype

_variant_t 对象的 VARTYPE 。

个指向要被转换的 _variant_t 对象的指针。如果它的值是 NULL, 则会适当地进行转换。

注释

此成员函数转换一个 _variant_t 对象为被说明的 VARTYPE 。如果 pSrc 是 NULL, 会适当地进行转换 , 否则，此 _variant_t 对象会从 pSrc 拷贝并进行转换。Microsoft 特殊处结束

_variant_t::Detach

Microsoft 特殊处 →

VARIANT Detach() throw(_com_error);

返回值

封装的 VARIANT

注释

提取并返回封装的 VARIANT, 然后清除 _variant_t 对象但并不消毁它。此成员函数从封装中移去 VARIANT 并把 _variant_t 对象的 VARTYPE 设置为 VT_EMPTY 。可通过调用 Varia n tInit 函数释放返回的 VARIANT 。

Microsoft 特殊处结束

_variant_t::SetString

Microsoft 特殊处 →

void SetString(const char* pSrc ) throw(_com_error);

参数

指向一个多字节字符串的指针。

注释

把一个多字节字符串转换为单代码 BSTR 对象 , 然后把它赋给 _variant_t 对象。

Microsoft 特殊处结束运算符

_variant_t::operator =

Microsoft 特殊处 →

_variant_t& operator=(const VARIANT& varSrc ) throw(_com_error);

_variant_t& operator=(const VARIANT* pVarSrc ) throw(_com_error);

_variant_t& operator=(const _variant_t& var_t_Src ) throw(_com_error);

_variant_t& operator=(short sSrc ) throw(_com_error);

_variant_t& operator=(long lSrc ) throw(_com_error);

_variant_t& operator=(float fltSrc ) throw(_com_error);

_variant_t& operator=(double dblSrc ) throw(_com_error);

_variant_t& operator=(const CY& cySrc ) throw(_com_error);

_variant_t& operator=(const _bstr_t& bstrSrc ) throw(_com_error);

_variant_t& operator=(const wchar_t* wstrSrc ) throw(_com_error);

_variant_t& operator=(const char* strSrc ) throw(_com_error);

_variant_t& operator=(IDispatch* pDispSrc ) throw(_com_error);

_variant_t& operator=(bool bSrc ) throw(_com_error);

_variant_t& operator=(IUnknown* pSrc ) throw(_com_error);

_variant_t& operator=(const DECIMAL& decSrc ) throw(_com_error);

_variant_t& operator=(BYTE bSrc ) throw(_com_error);

注释

这些运算符把一个新的值赋给 _variant_t 对象 :

operator=( varSrc ) 把一个已存在的 VARIANT 赋给一个 _variant_t 对象。
operator=( pVarSrc ) 把一个已存在的 VARIANT 赋给一个

_variant_t 对象。

operator=( var_t_Src ) 把一个已存在的 _variant_t 赋给一个

_variant_t 对象。

operator=( sSrc ) 把一个短整型值赋给一个 _variant_t 对象。
operator=( lSrc ) 把一个长整型值赋给一个 _variant_t 对象。
operator=( fltSrc ) 把一个 float 数值赋给一个 _variant_t 对象。
operator=( dblSrc ) 把一个 double 数值赋给一个 _variant_t 对象。
operator=( cySrc ) 把一个 CY 对象赋给一个 _variant_t 对象。
operator=( bstrSrc ) 把一个 BSTR 对象赋给一个 _variant_t 对象。
operator=( wstrSrc ) 把一个 Unicode 字符串赋给一个 _variant_t 对象。
operator=( strSrc ) 把一个多字节字符串赋给一个 _variant_t 对

象。

operator=( bSrc ) 把一个 Bool 值赋给一个 _variant_t 对象。
operator=( pDispSrc ) 把一个 VT_DISPATCH 对象赋给一个

_variant_t 对象。

operator=( pIUnknownSrc ) 把一个 VT_UNKNOWN 对象赋给一个

_variant_t 对象。

operator=( decSrc ) 把一个十进制值赋给一个 _variant_t 对象。
operator=( bSrc ) 把一个字节值赋给一个 _variant_t 对象。

Microsoft 特殊处结束

_variant_t 关系运算符

Microsoft 特殊处 →

bool operator==(const VARIANT& varSrc ) const throw(_com_error); bool operator==(const VARIANT* pSrc ) const throw(_com_error); bool operator!=(const VARIANT& varSrc ) const throw(_com_error); bool operator!=(const VARIANT* pSrc ) const throw(_com_error); 参数

varSrc

个要同 _variant_t 对象进行比较的 VARIANT

pSrc

指向要同 _variant_t 对象进行比较的 VARIANT 的指针

注释

把一个 _variant_t 对象同一个 VARIANT 进行比较 , 检查是否相等。如果比较可以进行 , 返回真 , 否则返回假。

Microsoft 特殊处结束

_variant_t 提取符

Microsoft 特殊处 →

operator short() const throw(_com_error); operator long() const throw(_com_error); operator float() const throw(_com_error); operator double() const throw(_com_error); operator CY() const throw(_com_error); operator bool() const throw(_com_error); operator DECIMAL() const throw(_com_error); operator BYTE() const throw(_com_error); operator _bstr_t() const throw(_com_error); operator IDispatch*() const throw(_com_error); operator IUnknown*() const throw(_com_error); 注释

从一个封装的 VARIANT 中提取原始数据。如果 VARIANT 还不是正确的类型 , 则采

用函数 VariantChangeType 试图进行转换 , 若失败会产生一个错误。

operator short() 提取一个短整型值。
operator long() 提取一个长整型值。
operator float() 提取一个 float 型数值。
operator double() 提取一个 double 型数值。
operator CY() 提取一个 CY 对象。
operator bool() 提取一个 BOOL 型值。
operator DECIMAL() 提取一个十进制数值。
operator BYTE() 提取一个 BYTE 型数值。
operator _bstr_t() 提取一个封装在 _bstr_t 对象中的字符串。
operator IDispatch*() 从一个封装的 VARIANT 中提取一个dispinterface 指针。对结果指针调用了 AddRef 函数 , 故有责任调用 Release 去释放它。
operator IUnknown*() 从一个封装的 VARIANT 中提取一个 COM 接口指针。对结果指针调用了 AddRef 函数 , 故有责任调用 Release 去释放它。

Microsoft 特殊处结束

附录 D 图表

本附录包含以下一些图表 :

ASCII 字符代码
ASCII 多语言代码
ANSI 字符代码
关键字代码

ASCII 字符代码

ASCII 字符代码表含有扩展 ASCII 字符集的十进制和十六进制值。这些扩展字符集包括 ASCII 字符集和 128 个其它为图形和画线的字符 , 通常叫作 “ IBM 字符集 ” 。

图表 1( 代码 0 ～ 127)
图表 2( 代码 128 ～ 255)

ASCII 多语言代码

在 IBM 字符集上存在着很多不同的变型 , 称为 “ 代码页 ”。在一些欧洲国家出售的系统中作用的多语言代码是代码页 850, 其中含有较少的图形字符、较多的重音字符以及其它特殊字符。

ANSI 字符代码

ANSI 字符代码表列出了在 Windows 程序中使用的扩展字符。ANSI 字符集中从 32 ～ 126 是来自于 ASCII 字符集的可显示代码。显示为实心块的 ANSI 字符是未定义

的字符以及在输出设备上会表现得不同的字符。

关键字代码

有些键 , 如功能键、光标键以及 ALT+KEY 的组合键没有 ASCII 代码。当一个键被按下的时候 , 在键盘中的微处理器产生一个两字节的 “ 扩展扫描码 ”。第一个字节 ( 低位 ) 包含了 ASCII 码 ( 如果有的话 ) 。第二个字节 ( 高位 ) 含有扫描码 — — 当键盘的键被按下或者被释放时由键盘所产生的一个唯一码。因为此扩展扫描码比标准 ASCII 码用得更广泛 , 程序可以用它确定哪些键没有 ASCII 码。

ASCII 字符代码图表 1

附录 A 语法总结 - 图1

ASCII 代码 127 有代码 DEL 。在 MS-DOS 下 , 这个代码与 ASCII8(BS) 的作用相同。DEL 是由 CTRL+BKSP 按键产生的。

ASCII 字符代码图表 2

附录 A 语法总结 - 图2

ASCII 多语言代码图表

附录 A 语法总结 - 图3

ANSI 字符代码图表

指出这个字符不被 Windows 支持

T T 指出这个字符仅在 TrueType 字体下可用

关键字代码图表 1

附录 A 语法总结 - 图4

关键字代码图表 2

附录 A 语法总结 - 图5

↑ 在初始字符时扩展的代码返回 0(NUL) 或 E0( 十进制 224) 。这是键盘缓冲区中第二个 ( 扩展的 ) 带有可用的信号。

§ 这些组合键仅在扩展的键盘上识别。

￡这些键仅在扩展的键盘上可用。大多数在光标 / 控制键盘区。如果从键盘端口 (60h) 读扫描码 , 它以两个字节 (E0h) 后跟正常扫描码方式出现。但是 , 当通过BIOS 中断 16h 读 ENTER 和 / 键时 , 只看见 E0h, 因为该中断仅给出一位扫描码。

↑ ↑ 在 MS-DOS 下 ,SHIFT+PRTSC 引起中断 5, 它打印屏幕 , 除非己经定义一个中断处理器代替该缺省的中断 5 处理器。

附 录 A 语 法 总 结

附 录 A 语 法 总 结

关 键 字

表 达 式

说 明

说 明 符

类

语 句

M icrosoft 扩 展

基 地 址

调 用 和 命 名 的 常 规 修 饰 符

扩 展 存 储 类 属 性

联 编 汇 编 器

_com_error

_com_ptr_t

_bstr_t

_variant_t

_variant_t::_variant_t

附录 A 语法总结

附录 A 语法总结

关键字

表达式

说明

说明符

语句

M icrosoft 扩展

基地址

调用和命名的常规修饰符

扩展存储类属性

联编汇编器