第 2 章 编 译 指 示 指 令

C 和 C++ 的 每 个 实 现 对 它 的 主 机 或 操 作 系 统 都 支 持 一 些 独 有 的 特 征 。 例 如 , ±某 些程 序 须 对 存 放 数 据 的 存 储 器 区 域 进 行 精 确 的 控 制 , 或 必 须 控 制 特 定 函 数 接 受 参 量的 方 式 。 #pragma 指 令 对 每 个 编 译 器 给 出 了 一 个 方 法 , 在 保 持 与 C 和 C++ 语 言 完全 兼 容 的 情 况 下 , 给 出 主 机 或 操 作 系 统 专 有 的 特 征 。 依 据 定 义 , 编 译 指 示 是 机 器或 操 作 系 统 专 有 的 , 且 对 于 每 个 编 译 器 都 是 不 同 的 。

语 法

#pragma 语 言 符 号 字 符 串

语 言 符 号 字 符 串 是 给 出 特 有 编 译 器 指 令 和 参 量 的 字 符 序 列 。 数 字 符 号 (#) 必 须 是包 含 编 译 指 示 行 中 的 第 一 个 非 空 白 字 符 。 空 白 字 符 可 分 开 数 字 符 号 (#) 和 单 词pragma ±。 在 #pragma 之 后 , 可 以 编 写 翻 译 器 作 为 预 处 理 器 语 言 符 号 分 析 的 任 何文 本 。 #pragma 的 参 量 从 属 于 宏 扩 展 。

如 果 编 译 器 找 到 一 个 不 能 识 别 的 编 译 指 示 , 将 发 出 一 个 警 告 , 但 编 译 将 继 续 。

编 译 指 示 可 用 在 条 件 说 明 中 , 以 提 供 新 的 预 处 理 器 功 能 , 或 提 供 定 义 的 实 现 信 息给 编 译 器 。 C 和 C++ 编 译 器 可 识 别 下 面 的 编 译 指 示 :

alloc_text

comment

init_seg*

optimize

auto_inlin e

component

inline_depth

pack

续 表

bss_seg data_seg inline_recursion pointers_to_membe

rs* check_stack function intrinsic setlocale code_seg hdrstop message vtordisp*

const_seg include_ali as

once warning

* 仅 被 C++ 编 译 器 支 持

C++ 编 译 器 专 有 编 译 指 示

以 下 是 C++ 编 译 器 专 有 的 编 译 指 示 指 令 :

  • init_seg

  • pointer s _to_members

  • vtordisp

init_seg C++ 特 殊 处 →

# pragma init - seg({complier/lib/user/ " section-name " [," func-name "]}) 该 指 令 指 定 一 个 影 响 启 动 代 码 执 行 顺 序 的 关 键 字 或 代 码 段 。 由 于 全 局 静 态 对 象的 初 始 化 可 能 涉 及 执 行 代 码 , 因 此 必 须 指 定 创 建 对 象 时 定 义 的 一 个 关 键 字 。 在 动

态 连 接 库 (DLL) 或 需 初 始 化 的 库 中 使 用 init_seg 编 译 指 示 尤 其 重 要 。init_seg 编 译 指 示 的 选 项 如 下 :

complier

该 选 项 保 留 给 Microsoft C 运 行 库 初 始 化 。 这 个 组 中 的 对 象 最 先 被 创 建 。lib

用 于 第 三 方 类 库 供 应 商 的 初 始 化 。 该 组 中 的 对 象 在 complier 标 志 之 后 , 其 他 标记 之 前 创 建 。

user

用 于 任 何 用 户 。 此 组 对 象 最 后 创 建 。section _ name

允 许 初 始 化 段 的 显 示 规 格 。 在 一 个 用 户 指 定 section-name( 段 名 称 ) 中 的 对 象 不能 被 隐 含 地 创 建 , 但 它 们 的 地 址 可 放 在 以 section_name 命 名 的 段 中 。

func _name

指 定 在 程 序 退 出 时 在 exit() 地 方 调 用 的 函 数 。 指 定 的 函 数 必 须 与 exit 函 数 具有 相 同 的 特 征 :

int funcname( void( __ cdecl*)(void));

如 果 你 需 要 延 迟 初 始 化 过 程 ( 例 如 , 在 一 个 DLL 中 ), 你 可 以 选 择 显 式 地 指 定 该 段名 称 。 然 后 必 须 为 每 个 静 态 对 象 调 用 构 造 函 数 。

C++ 特 殊 处 结 束pointer s _to_members C++ 特 殊 处 →

#progma pointers _to_members( 指 针 说 明 ,[ 最 一 般 表 示 ])

该 指 令 指 定 一 个 类 成 员 的 指 针 能 否 在 其 相 关 定 义 之 前 被 说 明 , 且 用 于 控 制 该 指 针尺 寸 和 解 释 该 指 针 需 要 的 代 码 。 你 可 以 把 一 个 pointer s _to_members 编 译 指 示放 入 你 的 源 文 件 中 替 换 /vmx 编 译 器 选 项 。

指 针 说 明 参 量 指 定 你 在 一 个 关 联 函 数 定 义 之 前 还 是 之 后 说 明 了 一 个 成 员 的 指针 。 指 针 说 明 参 量 是 以 下 两 个 符 号 之 一 :

参量 说明

full_generalit y

生 成 安 全 、 但 常 常 并 非 最 优 的 代 码 。 如 果 在 关 联 类 定 义之 前 说 明 任 何 成 员 的 指 针 , 可 使 用 full_generality 。该参 量 通 常 使 用 最 一 般 表 示 参 量 指 定 的 指 针 表 示 形 式 。 等同于 /vmg 选项

best_case 为 所 有 成 员 指 针 使 用 最 佳 情 况 (best __ case) 表示生成安全的 最 优 代 码 。 使 用 该 参 量 是 需 在 定 义 一 个 类 的 成 员 指 针说明之前定义此类。其缺省值为 best_case

最 一 般 表 示 参 量 说 明 了 在 转 换 单 元 中 , 编 译 器 能 够 安 全 地 引 用 任 何 指 向 类 成 员 的

指 针 的 最 小 指 针 表 示 。 该 参 量 取 如 下 值 之 一 :

参量 说明

single_inheritanc e

最 一 般 表 示 是 单 继 承 的 , 即 一 个 成 员 函 数 的 指 针 。 对于 其 中 说 明 了 一 个 指 向 成 员 指 针 的 一 个 类 定 义 , 若 其继承模式说明为多重的或虚拟的 , 将导致错误

multiple_inherita nce

vitual_inheritanc e

C++ 特 殊 处 结 束vtordisp

续 表最 一 般 表 示 是 多 重 继 承 的 , 即 一 个 成 员 函 数 的 指 针 。 对 于 其 中 说 明 了 一 个 指 向 成 员 指 针 的 一 个 类 定 义 , 若 其继承模式是虚拟的 , 将导致错误

最 一 般 表 示 是 虚 拟 继 承 , 即 一 个 成 员 函 数 的 指 针 。 该函 数 不 会 导 致 错 误 。 当 使 用#pragma±pointers_to_members(full_generality) 时 这 是 个缺 省 参 量

C++ 特 殊 处 →

# pragma vtordisp({on|off})

该 指 令 允 许 增 加 隐 含 的 vtordisp 构 造 函 数 / 析 构 函 数 替 换 成 员 。 vtordisp 编 译指 示 只 使 用 虚 基 类 的 代 码 。 若 一 个 派 生 类 重 迭 一 个 从 虚 拟 基 类 继 承 的 虚 拟 函 数 , 且 如 果 派 生 类 的 一 个 构 造 函 数 或 析 构 函 数 调 用 那 个 使 用 该 虚 拟 基 类 指 针 的 函 数 , 则 编 译 器 可 能 将 增 加 的 隐 含 “ vtordisp ” 域 到 有 虚 拟 基 的 类 中 。

vtordisp 编 译 指 示 会 影 响 其 后 类 的 分 布 。 /Vd0 或 /Vd1 选 项 指 定 了 对 于 完 全 模式 的 相 同 动 作 。 指 定 off 将 抑 制 隐 含 的 vtordisp 成 员 。 指 定 缺 省 值 on, ±将 在需 要 的 位 置 打 开 它 们 。 Vtordisp 指 令 仅 在 类 的 构 造 / 析 构 函 数 在 用 this ±指 针 指向 的 对 象 处 不 可 能 调 用 虚 拟 函 数 时 关 闭 。

# pragma vtordisp(off)

class GetReal:virtual public{...}; # pragma vtordisp(on)

C++ 特 殊 处 结 束

C 和 C++ 编 译 器 编 译 指 示

以 下 是 为 C 和 C++ 编 译 器 定 义 的 编 译 指 示 :

alloc_text component init_seg* optimize auto_inline const_seg inline_depth pack

bss_seg data_seg inline_recursi on

pointers_to_membe rs*

check_stack function intrinsic setlocale code_seg hdrstop message vtordisp* comment include_alias once warning

* 仅 被 C++ 编 译 器 支 持

alloc_text

#pragma alloc_text( “ 文 本 段 ” , 函 数 1,...)

该 指 令 用 于 命 名 指 定 的 函 数 定 义 将 要 驻 留 的 代 码 段 。 该 编 译 指 示 对 已 命 名 的 函数 必 须 出 现 在 一 个 函 数 说 明 符 和 该 函 数 定 义 之 间 。

alloct_text 编 译 指 示 并 不 处 理 C++ 成 员 函 数 或 重 载 函 数 。 它 仅 用 于 以 C 连 接 方

式 说 明 的 函 数 , 这 指 的 是 用 extern “ C ” 连 接 规 格 说 明 的 函 数 。 如 果 你 试 图 将 此编 译 指 示 用 于 非 C++ 连 接 的 函 数 , 将 产 生 一 个 编 译 错 误 。

由 于 不 支 持 使 用 __ based 的 函 数 地 址 , 指 定 段 位 址 需 要 使 用 alloc_text 编 译 指 示 , 以 文 本 段 指 定 的 名 称 应 包 括 在 双 引 号 间 。

alloc_text 编 译 指 示 必 须 出 现 在 指 定 的 函 数 说 明 之 后 , 这 些 函 数 的 定 义 之 前 。 一 个 alloc_text 编 译 指 示 中 的 函 数 引 用 必 须 在 此 编 译 指 示 的 同 一 模 块 中 定 义 。如 果 未 这 样 做 , 且 一 个 未 定 义 的 函 数 随 后 被 编 译 到 一 个 不 同 的 文 本 段 , 则 这 个 错误 可 能 找 得 到 , 也 可 能 找 不 到 。 虽 然 该 程 序 一 般 会 正 常 运 行 , 但 该 函 数 不 会 分 配到 预 期 的 段 中 。

alloc_text 的 其 他 限 制 如 下 :

  • 它 不 能 用 在 一 个 函 数 的 内 部 。

  • 它 必 须 在 已 说 明 的 函 数 之 后 和 已 定 义 的 函 数 之 前 使 用 。

auto_inline

# pragma auto_inline([{on|off}])

排 除 自 动 内 联 扩 展 的 候 选 者 中 指 定 为 off 的 区 域 中 定 义 的 函 数 。 为 了 使 用auto_inline 编 译 指 示 , 把 它 放 在 一 个 函 数 定 义 之 前 或 立 即 之 后 ( 不 在 该 函 数 定义 之 内 ) 。 在 看 到 该 编 译 指 示 之 后 的 第 一 个 函 数 定 义 处 , 该 编 译 指 示 发 生 作 用 。编 译 指 示 auto_inline 不 能 应 用 于 显 式 内 联 函 数 。

bss_seg

# pragma data -seg([" section-nam e"[," section-class "]])

指 定 未 初 始 化 数 据 的 缺 省 段 。 data_seg 编 译 指 示 处 理 初 始 化 或 未 初 始 化 数 据 有相 同 的 作 用 。 在 某 些 情 况 下 , 你 可 以 使 用 bss_seg 通 过 把 所 有 未 初 始 化 数 据 放 在一 个 段 中 来 加 速 加 载 的 时 间 。

# pragma bss_seg("MY_DATA")

导 致 #pragma 语 句 后 未 初 始 化 的 数 据 分 配 到 一 个 名 称 为 MY_DATA 的 段 中 。用 bss_seg 编 译 指 示 分 配 的 数 据 不 会 保 留 关 于 它 的 位 置 的 任 何 信 息 。

第 二 个 参 量 section_class 用 于 与 Visual C++ 之 前 的 版 本 兼 容 , 现 在 已 被 忽 略 。

check_stack

# pragm a check_stack([{on|off}]) # pragma check_stack{+|-}

该 指 令 在 off( 或 -) 选 项 时 指 示 编 译 器 关 闭 栈 搜 索 。 在 on( 或 +) 选 项 指 定 时 , 打 开搜 索 。

若 无 参 量 , 栈 搜 索 就 按 缺 省 情 况 处 理 。 在 看 到 该 编 译 指 示 之 后 第 一 个 定 义 的 函 数处 发 生 作 用 。 栈 搜 索 既 不 是 宏 的 一 部 分 , 也 不 是 产 生 的 内 联 函 数 的 一 部 分 。

如 果 未 赋 予 一 个 参 量 给 check_stack 编 译 指 示 , 栈 检 查 将 还 原 成 在 命 令 行 中 说 明的 行 为 , 有 关 更 多 的 信 息 参 见 “ 编 译 器 参 考 ”。 #pragma check_stack 和 /Gs 选 项的 交 互 关 系 参 见 表 2.1 。

表 2.1 使用 check_stack 编 译 指 示

语法

是否用 /Gs 选项编译

行为

#pragma check_stack() 或

#pragma check_stack

是

关 闭

查

其

后

函

数

的

栈

检

#pragma check_stack() 或#pragma check_stack #pragma check_stack(on) 或

#pragma check_stack +

#pragma check_stack(off)

否

是或否

是或否

打 开查 打 开查

关 闭

其其

其

后后

后

函函

函

数数

数

的的

的

栈栈

栈

检检

检

或

查

#pragma check_stack -

code_seg

# pragma code_seg([" section-name "[," section-class "]])

该 指 令 用 于 指 定 一 个 分 配 函 数 的 代 码 段 。 code_seg 编 译 指 示 指 定 了 函 数 的 缺 省段 。

你 可 以 有 选 择 性 地 指 定 类 和 段 名 。 使 用 没 有 section-name 字 符 串 的 #pragma code_seg 可 在 编 译 开 始 时 将 其 复 位 。

const_seg

# pragma const_seg([" section-name "[," section-class "]])

该 指 令 用 于 指 定 对 于 常 量 数 据 的 缺 省 段 。 data_seg 编 译 指 示 对 所 有 数 据 具 有 相同 作 用 。 你 可 以 用 此 指 令 将 你 的 所 有 常 量 数 据 放 入 一 个 只 读 段 中 。

# pragma const_seg("MY_DATA")

导 致 该 指 令 将 #pragma 语 句 后 的 常 量 数 据 放 入 一 个 名 称 为 MY_DATA 的 段 里 。使 用 const_seg 编 译 指 示 分 配 的 数 据 不 会 保 留 有 关 它 的 位 置 的 任 何 信 息 。

第 二 个 参 数 section-class 用 于 与 Visual C++ 2.0 版 之 前 的 版 本 兼 容 , 现 在 已可 忽 略 。

comment

# pragma comment( comment-type ,[ commentstring ])

该 指 令 将 一 个 注 释 记 录 放 入 一 个 对 象 文 件 或 可 执 行 文 件 中 。 comment-type 是 下面 五 种 说 明 的 预 定 义 标 识 符 之 一 , 它 们 指 出 了 注 释 记 录 的 类 型 。 任 选 的commentstring 是 给 一 些 注 释 类 型 提 供 额 外 信 息 的 字 符 串 文 字 。 由 于commentstring 是 一 个 字 符 串 文 字 , ±因 此 它 必 须 遵 循 对 于 字 符 串 文 字 的 诸 如 转义 字 符 、 嵌 入 或 引 号 标 记 (") 以 及 合 并 的 所 有 规 则 。

complier

该 选 项 将 编 译 器 的 名 称 和 版 本 号 放 入 对 象 文 件 中 。 这 个 注 释 记 录 被 链 接 器 忽 略 , 如 果 你 为 这 个 记 录 类 型 给 出 一 个 commentstring 参量 , 该 编 译 器 将 产 生 一 个 警 告

信 息 。

e xestr

该 选 项 将 commentstring 放 入 对 象 文 件 中 。 在 连 接 时 , 该 字 符 串 被 置 入 可 执 行 文件 中 。

该 字 符 串 并 不 与 可 执 行 文 件 同 时 加 载 到 存 储 器 , 但 它 可 用 在 文 件 中 寻 找 可 打 印 字符 串 的 程 序 找 到 。 这 个 注 释 记 录 类 型 的 一 个 用 途 是 把 版 本 号 或 类 似 信 息 嵌 入 到一 个 可 执 行 文 件 中 。

lib

该 选 项 将 一 个 库 搜 索 记 录 放 入 对 象 文 件 。 该 注 释 类 型 必 须 带 有 一 个commentstring 参 数 。 这 个 参 数 包 含 你 想 要 的 链 接 器 搜 索 的 库 的 名 称 ( 有 可 能 包含 路 径 ) 。 由 于 在 对 象 文 件 中 该 库 名 称 在 缺 省 的 库 搜 索 记 录 之 前 , 所 以 链 接 器 搜索 该 库 就 象 你 在 命 令 行 中 命 名 了 它 一 样 。 你 可 以 把 多 个 库 搜 索 记 录 放 在 同 一 个源 文 件 中 , 每 个 记 录 在 对 象 文 件 中 都 以 其 在 源 文 件 中 出 现 的 同 样 顺 序 出 现 。

linker

该 选 项 将 一 个 链 接 器 选 项 放 入 对 象 文 件 中 。 可 以 用 该 注 释 类 型 指 定 一 个 链 接 器选 项 , 用 于 取 代 在 Project Setting 对 话 框 中 Link 选 项 卡 上 放 入 该 选 项 。 例 如 , 你 可 以 指 定 /include 选 项 来 强 行 包 括 一 个 符 号 :

# pragma comment(linker,"/include: __ symbol")

user

该 选 项 将 一 个 一 般 的 注 释 放 入 对 象 文 件 中 。 commentstring 参 量 包 含 了 该 注 释的 文 本 。 这 个 注 释 记 录 被 链 接 器 忽 略 。

以 下 编 译 指 示 导 致 链 接 器 在 连 接 时 搜 索 EMAPI.LIB 库 。 ±该 连 接 器 首 先 在 当 前 工作 目 录 中 搜 索 , 随 后 在 LIB 环 境 变 量 说 明 的 路 径 中 搜 索 。

# pragma comment(lib,"emapi")

以 下 编 译 指 示 导 致 编 译 器 把 编 译 器 的 名 称 和 版 本 号 放 入 对 象 文 件 : # pragma comment(complier)

注 意 : 对 于 一 个 带 commentstring 参 量 的 注 释 , ±你 可 以 在 任 何 要 使 用 一 个 字 符 串文 字 的 地 方 使 用 宏 , 让 这 个 宏 扩 展 为 一 个 字 符 串 文 字 。 你 也 可 以 把 任 何 一 个 字 符串 文 字 的 任 何 组 合 与 扩 展 为 字 符 串 文 字 的 宏 合 并 起 来 , 例 如 : 下 面 的 语 句 是 可 以接 受 的 :

# pragma comment(user,"Compiled on" __ DATA _ _ "at" _ _ TIME _ _ )

component

# pragma component(browser,{on|off}[,references[, nam e ]]) # pragma component(minrebuild,on|off)

该 指 令 用 于 控 制 源 文 件 内 的 浏 览 信 息 或 依 赖 信 息 的 集 合 。

browser

你 可 以 打 开 或 关 闭 集 合 , 并 可 以 在 收 集 信 息 时 指 定 忽 略 的 特 定 名 称 。

用 on 或 off 选 项 控 制 前 面 编 译 指 示 的 浏 览 信 息 的 集 合 。 例 如 : # pragma component(browser,off)

该 指 令 让 编 译 器 停 止 收 集 浏 览 信 息 。

注 意 : 用 此 指 令 打 开 浏 览 信 息 的 集 合 , 浏 览 信 息 必 须 先 用 Project Setting s 对 话框 或 命 令 行 打 开 。

reference s 选 项 可 带 也 可 不 带 name 参 量 。 不 带 name 参 量 的 reference s 选 项用 于 打 开 或 关 闭 引 用 的 集 合 ( 但 此 时 继 续 收 集 其 它 浏 览 信 息 ) 。 例 如 :

# pragma component(browser,off,references) 该 指 令 使 编 译 器 停 止 收 集 引 用 信 息 。

带 name 和 off 参 量 的 references 选 项 , 用 于 防 止 浏 览 信 息 窗 口 中 出 现 对 name 的 引 用 。 使 用 这 种 语 法 可 忽 略 你 不 感 兴 趣 的 名 称 和 类 型 , ±并 且 可 缩 短 浏 览 信 息的 尺 寸 。 例 如 :

# pragma component(browser,off,references,DWORD)

忽 略 该 点 之 前 对 于 DWORD 的 引 用 。 但 你 可 用 on 选 项 把 对 于 DWORD 引 用 的 集 合 重新 打 开 。

# pragma component(browser,on,references,DWORD)

这 是 恢 复 对 name 引 用 集 合 唯 一 的 方 式 ; 用 此 方 式 你 可 以 显 式 地 打 开 任 何 你 已 经关 闭 的 name 。

为 了 防 止 预 处 理 器 把 name 展开 ( 如 把 NULL 扩 展 为 0), 将 它 加 上 引 号 : # pragma component(browser,off,references,"NULL")

M in imal Rebuild

Visual C++ 的 mini mal rebuild( 最 小 重 建 ) 特 性 需 要 编 译 器 创 建 和 存 储 依 赖 信息 的 C++ 类 , 这 将 占 用 磁 盘 空 间 。 为 了 节 省 磁 盘 空 间 , 你 可 以 在 任 何 你 不 需 收 集依 赖 信 息 的 时 候 仅 用 #pragma component(minirebuild,off), 例 如 , 在 不 变 的 头文 件 中 。 在 不 变 的 类 后 插 入 #pragma component(minrebuild,on) 可 重 新 打 开 依赖 信 息 。

有 关 更 多 的 信 息 参 见 Enable Minimal Rebuild(/Gm) 编 译 器 选 项 。

data_seg

# pragma data_seg([" section-name "[," section-class "]]) 该 指 令 指 定 数 据 的 缺 省 段 。 例 如 :

# pragma data_seg("MY_DATA")

将 #pragma 语 句 后 分 配 的 数 据 放 在 以 名 称 为 MY_DATA 的 段 里 。

使 用 data_seg 编 译 指 示 分 配 的 数 据 不 会 保 留 关 于 它 的 位 置 的 任 何 信 息 。

第 二 个 参 量 section-class 用 于 与 Visual C++ 2.0 之 前 的 版 本 兼 容 , 现 在 已 可忽 略 。

function

# pragma function( function1 [, function2 ,...])

该 指 令 指 定 对 在 生 成 的 编 译 器 编 译 指 示 参 量 表 中 指 定 调 用 的 函 数 。 如 果 你 使 用intrinsic 编 译 指 示 ( 或 /Oi) 告 诉 编 译 器 生 成 内 在 函 数 ( 被 生 成 为 内 联 代 码 , 而 非

函 数 调 用 的 内 在 函 数 ), 就 能 用 function 编 译 指 示 来 显 式 地 强 制 调 用 一 个 函 数 。当 一 个 函 数 编 译 指 示 出 现 时 , 它 在 第 一 个 包 含 一 个 指 定 的 内 在 函 数 的 函 数 定 义 处发 生 作 用 , 这 个 作 用 持 续 到 源 文 件 的 结 尾 或 直 到 一 个 说 明 这 种 相 同 的 内 在 函 数 的编 译 指 示 出 现 为 止 。 在 全 局 层 时 , 该 function 编 译 指 示 只 能 用 在 一 个 函 数 外 。对 于 具 有 内 部 形 式 的 函 数 表 , 参 见 #pragma intrinsic 。

hdrstop

# pragma hdrstop[(" filenam e")]

该 指 令 用 于 控 制 预 编 译 头 文 件 的 工 作 方 式 。 filename 是 预 编 译 头 文 件 使 用 或 创建 的 名 称 ( 根 据 指 定 选 项 /Yu 或 /Yc 决 定 ) 。 如 果 filename 不 包 含 路 径 说 明 , 预 编译 头 文 件 将 被 假 定 在 与 源 文 件 相 同 的 目 录 中 。 当 指 定 /YX 自 动 预 编 译 头 文 件 选项 时 , 所 有 filename 都 被 忽 略 。

当 采 用 /YX 或 /Yc 编 译 时 , 一 个 C 或 C++ 文 件 包 含 一 个 hdrstop 编 译 指 示 , 该 编 译器 将 把 编 译 状 态 存 入 到 编 译 指 示 的 位 置 。 该 编 译 指 示 之 后 任 何 代 码 的 编 译 状 态都 不 存 储 。

hdrstop 编 译 指 示 不 可 能 出 现 在 一 个 头 文 件 中 。 它 必 须 出 现 在 源 文 件 中 。 这 指的 是 , 它 不 能 出 现 在 任 何 数 据 、 函 数 说 明 或 函 数 定 义 中 。

注 意 : 除 非 /YX 选 项 或 无 文 件 名 的 /Yu 或 /Yc 选 项 被 指 定 , 否 则 hdrstop 编 译 指 示将 被 忽 略 。

该 指 令 使 用 filename 命 名 编 译 状 态 存 储 的 预 编 译 头 文 件 。 hdrstop 和 filename 之 间 的 一 个 空 白 是 任 选 的 。 在 hdrstop 编 译 指 示 中 说 明 的 文 件 名 称 是 一 个 字 符串 , ±而 且 必 须 服 从 C 或 C++ 字 符 串 的 约 束 。 尤 其 重 要 的 是 必 须 将 其 置 于 括 号 中 ,

如 下 例 所 示 :

# pragma hdrstop("c:\projects\include\myinc.pch") 预 编 译 头 文 件 的 名 称 由 下 列 规 则 决 定 , 顺 序 如 下 :

  1. /Fp 编 译 器 选 项 的 参 量 。

  2. # pragma hdrstop 的 filename 参 量 。3. 以 .PCH 为 扩 展 名 的 源

    文 件 的 基 名 称 。

include_alias

# pragma include_alias(" long_filenam e"," short_filenam e") # pragma include_alias(< long_filenam e>,< short_filenam e>)

该 指 令 指 定 short_filename 作 为 long_filename 的 别 名 。 某 些 文 件 系 统 允 许 比8.3 FAT 文 件 系 统 限 定 更 长 的 文 件 名 。 编 译 器 不 能 够 简 单 地 把 更 长 的 头 文 件 名截 短 为 8.3 格 式 , 因 为 这 种 更 长 的 头 文 件 名 的 开 始 八 个 字 符 可 能 不 是 唯 一 的 。 只要 编 译 器 遇 到 long_filename 字 符 串 , 就用 short_filename 替 换 , 并 且 代 替 查 找short_filename 头 文 件 。 这 个 编 译 指 示 必 须 出 现 在 相 应 的 #include 指 令 之 前 , 例 如 :

// 这 两 个 文 件 的 开 头 八 个 字 符 不 是 唯 一 的

# pragma include_alias("AppleSystemHeaderQuickdraw.h","quickdra.h") # pragma include_alias("AppleSystemHeaderFruit.h","fruit.h")

# pragma include_alias( "GraphicsMenu. h ", "gramenu.h")

# include "AppleSystemHeaderQuickdraw.h" # include "AppleSystemHeaderFruit.h"

# include "GraphicsMenu.h"

无 论 是 拼 写 , 还 是 双 引 号 或 尖 括 号 的 用 法 , 被 搜 索 的 别 名 都 必 须 符 合 规 格 。include_alias 编 译 指 示 在 该 文 件 名 中 处 理 简 单 的 字 符 串 匹 配 , 而 在 其 它 的 文 件名 中 是 无 效 的 。 例 如 , 给 出 如 下 指 令 :

# pragma include_alias("mymath.h","math.h") # include "./mymath.h"

# include "sys/mymath.h"

没 有 别 名 使 用 ( 替 换 ) 被 执 行 , 因 为 头 文 件 字 符 串 并 不 匹 配 。 用 作 /Yu 、 /Yc 和 /YX 编 译 器 选 项 参 量 的 头 文 件 名 , 或 hdrstop 编 译 指 示 的 头 文 件 名 也 不 能 被 替 换 。 例如 , 若 你 的 源 文 件 包 含 下 列 指 令 :

# include <AppleSystemHeaderStop.h> 相 应 的 编 译 器 选 项 应 该 是 :

/YcAppleSystemHeaderStop.h

你 可 以 用 include_alias 编 译 指 示 把 任 何 头 文 件 名 映 射 为 另 一 个 。 例 如 : # pragma include_alias("api.h", "c:\version1.0\api.h")

# pragma include_alias(<stdio.h>, <newstdio.h>) # include "api.h"

# include <stdio.h>

不 要 把 双 引 号 内 的 文 件 名 和 尖 括 号 内 的 文 件 名 相 混 淆 , 例 如 , 对 于 上 面 给 出 的 两个 #pragma include_alias 指 令 , 编 译 器 在 下 面 的 #include 指 令 中 不 执 行 任 何 替

换 :

# include <api.h> include "stdio.h"

此 外 , 下 面 的 指 令 将 导 致 错 误 :

#pragma include_alias(<header.h>,"header.h") // 错 误

注 意 在 错 误 信 息 中 给 出 的 文 件 名 , 或 作 为 预 先 定 义 的 __ FILE __ 宏 的 值 , 是 替 换 执 行之 后 的 文 件 的 名 称 , 例 如 , 下 面 指 令 后 :

# pragma include_alias("VeryLongFileName.H","myfile.h" ) # include "VeryLongFileName.H"

在 VERYLONGFILENAME.H 中 的 一 个 错 误 将 导 致 如 下 错 误 消 息 : myfile.h(15) : error c2059 : syntax error

同 时 注 意 传 递 性 是 不 支 持 的 。 如 下 指 令 中 :

# pragma include_alias( "one.h", "two.h" ) # pragma include_alias( "two.h", "three.h") # include "one.h"

编 译 器 搜 索 的 是 文 件 TWO.H 而 不 是 THREE.H 。

inline_depth

# pragma inline_depth([0...255])

该 指 令 通 过 控 制 一 系 列 函 数 调 用 能 被 扩 展 的 次 数 ( 从 0 到 255 次 ), 来 控 制 内 联 扩展 可 发 生 的 次 数 。 这 个 编 译 指 示 控 制 标 记 为 inline 和 _ _ inline 的 函 数 的 联 编 或在 /Ob2 选 项 下 已 经 自 动 联 编 的 函 数 。

inline_depth 编 译 指 示 控 制 一 序 列 函 数 调 用 能 被 扩 展 的 次 数 , 例 如 , 若 联 编 深 度为 4, 且若 A 调 用 B,B 调 用 C, 三 个 调 用 都 将 内 联 扩 展 。 但 如 果 最 近 的 内 联 扩 展 为2, 只 有 A 和 B 被 扩 展 ,C 保 留 为 一 个 函 数 调 用 。

为 使 用 这 个 编 译 指 示 , 你 必 须 设 置 /Ob 编 译 器 选 项 为 1 或 2 。 使 用 这 个 编 译 指 示的 深 度 设 置 在 该 编 译 指 示 指 令 后 的 第 一 个 函 数 处 生 效 。 如 果 你 没 有 在 圆 括 号 中指 定 一 个 值 ,inline_depth 将 设 置 联 编 深 度 为 缺 省 值 8 。

联 编 深 度 在 扩 展 时 只 减 不 增 。 若 联 编 深 度 为 6, 且 在 扩 展 时 , 预 处 理 器 遇 到 一 个联 编 深 度 值 为 8 的 inline_depth 编 译 指 示 , 该 深 度 仍 保 持 为 6 。

联 编 深 度 0 禁 止 联 编 扩 展 ; 联 编 深 度 255 对 联 编 扩 展 无 限 制 , 若 使 用 一 个 未 指 定其 值 的 编 译 指 示 , 则 将 使 用 其 缺 省 值 。

inline_recursion

# pragma inline_recursion([{on|off}])

该 指 令 控 制 直 接 或 相 互 递 归 函 数 调 用 的 联 编 扩 展 。该 指 令 用 于 控 制 标 记 为 inline 和 _ _ inline 的 函 数 , 或 编 译 器 在 Ob2 选 项 下 自 动 扩 展 的 函 数 。 这 个 编 译 指 示 的 用法 需 要 一 个 设 置 为 1 或 2 的 /Ob 编 译 器 选 项 。 inline_recursion 的 缺 省 状 态 是off 。 这 个 编 译 指 示 只 是 在 其 出 现 之 后 的 第 一 个 函 数 处 起 作 用 , 并 且 不 会 影 响 该函 数 的 定 义 。

inline_recursion 编 译 指 示 控 制 递 归 函 数 如 何 被 扩 展 。 如 果 inline_recursion 关 闭 , 且 若 一 个 联 编 函 数 调 用 其 自 身 ( 直 接 或 间 接 ), 该 函 数 只 被 扩 展 一 次 。 若inline_recursion 为 打 开 状 态 , 则 该 函 数 将 被 扩 展 多 次 直 到 其 达 到inline_depth 的 值 , 或 达 到 其 容 量 值 的 限 制 。

intrinsic

# pragma intrinsic( function1 [, function2 ,...])

该 指 令 指 定 对 于 在 编 译 指 示 参 量 表 中 说 明 的 函 数 的 调 用 是 内 在 的 。 编 译 器 生 成象 联 编 代 码 的 内 在 函 数 , 而 并 不 像 函 数 调 用 那 样 。 具 有 内 在 格 式 的 库 函 数 如 下表 。 当 遇 到 一 个 intrinsic 编 译 指 示 时 , 它 在 一 个 包 含 指 定 的 内 在 函 数 的 第 一 个函 数 定 义 处 发 生 作 用 , 其 作 用 延 续 到 源 文 件 的 结 尾 , 或 直 到 一 个 说 明 相 同 的 内 在函 数 的 function 编 译 指 示 出 现 为 止 。

intrinsic 编 译 指 示 只 能 用 在 一 个 函 数 定 义 之 外 ( 全 局 级 ) 。以 下 函 数 具 有 内 在 格 式 :

_disable

_outp

fabs

 strcmp

_enable

_outpw

labs

 strcpy

_inp

_rotl

memcmp

 strlen

_inpw

_rotr

memcpy

_lrotl

_strset

memset

_lrotr

abs

strcat

使 用 内 在 函 数 的 程 序 更 快 , 因 为 它 们 没 有 函 数 调 用 的 额 外 开 销 , 但 由 于 产 生 的 额外 代 码 , 它 们 会 更 大 一 些 。

注 意 : _alloca 和 setjmp 函 数 总 是 联 编 生 成 的 , 这 种 行 为 不 会 受 intrinsic 编 译指 示 的 影 响 。

以 下 所 列 的 浮 点 函 数 没 有 真 正 的 内 在 格 式 。 但 它 们 有 这 样 的 版 本 : 将 参 量 直 接 送入 浮 点 芯 片 , 而 不 是 将 它 们 压 入 程 序 栈 中 :

acos

 cosh

pow

tanh

asin

 fmod

sinh

当 你 指 定 /Oi 和 /Og 编 译 器 选 项 ( 或 任 何 包 括 /Og 、 /Ox 、 /O1 和 /O2 的 选 项 ) 时 , 以下 浮 点 函 数 有 真 正 的 内 在 格 式 :

atan

 exp

log10

sqrt

atan2

 log

sin

tan

cos

你 可 以 使 用 /Op 或 /Za 编 译 器 选 项 重 迭 真 正 的 内 在 浮 点 选 项 的 生 成 。这 种 情 况 下 , 该 函 数 被 生 成 为 库 例 程 , 该 例 程 直 接 把 参 量 送 入 浮 点 芯 片 , 而 不 是 把 它 们 压 入 程序 栈 。

message

# pragma message( messagestring )

该 指 令 不 终 止 编 译 , 直 接 把 一 个 字 符 串 文 字 送 到 标 准 输 出 。 message 编 译 指 示 的典 型 用 法 是 在 编 译 时 显 示 信 息 消 号 。 以 下 代 码 段 使 用 message 编 译 指 示 在 编 译时 显 示 一 个 消 息 :

# if _M_IX86==500

# pragma message("Pentium processor build") # endif

messagestring 参 数 可 以 是 可 扩 展 为 一 个 字 符 串 文 字 的 宏 , 并 且 你 可 以 以 任 何 组合 方 式 用 字 符 串 文 字 将 这 些 宏 合 并 起 来 。 例 如 , 下 列 语 句 显 示 了 被 编 译 的 文 件 名以 及 该 文 件 最 后 改 动 的 日 期 和 时 间 :

# pragma message("Compiling "__ FILE __ )

# pragma message("Last modified on " __ TIMESTAMP _ _ )

once

# pragma once

该 指 令 指 定 该 编 译 指 示 驻 留 的 文 件 将 只 在 一 次 建 立 中 被 编 译 器 包 括 ( 打 开 ) 一次 。 该 编 译 指 示 的 一 种 普 通 用 法 如 下 :

//header.h

# pragma once

// 接 着 是 你 的 C 或 C++ 代 码

optimize

# pragma optimize( "[ optimization-list]",{on|off} )

仅 用 于 专 业 和 企 业 版 本 的 特 征 : 代 码 优 化 只 被 Visual C++ 专 业 版 和 企 业 版 支 持 。更 多 的 信 息 参 见 Microsoft Visual C++ 联 机 编 辑 。

该 指 令 指 定 在 函 数 基 中 执 行 的 优 化 。 optimize 编 译 指 示 必 须 出 现 在 一 个 函 数 之外 , 并 且 在 编 译 指 示 出 现 后 定 义 的 第 一 个 函 数 处 产 生 作 用 。 o n 和 off 参 量 可 以打 开 或 关 闭 在 Optimization-list 中 指 定 的 选 项 。

optimization-list 可 以 是 0 或 在 表 2.2 中 给 出 参 数 。

表 2.2 " 优 化 " 编 译 指 示 的 参 数

参量

优化类型

a g p

s 或

w

 t

假定无别名 允许全局优化

提高浮点相容性

指定机器码的短或快序列 假定无交叉函数调用的别名

y

生成程序堆栈中的框架指针

这 些 是 采 用 /O 编 译 器 选 项 的 相 同 字 母 , 例 如 :

# pragma optimize("atp", on)

用 空 字 符 串 ("") 使 用 optimize 编 译 指 示 是 该 指 令 的 一 种 特 殊 形 式 , 它 可 关 闭 所有 的 优 化 或 恢 复 它 们 的 原 有 ( 缺 省 的 ) 设 置 。

# pragma optimize("",off)

.

.

.

# pragma optimize("", on)

pack

# pragma pack([ n ])

该 指 令 指 定 结 构 和 联 合 成 员 的 紧 凑 对 齐 。 而 一 个 完 整 的 转 换 单 元 的 结 构 和 联 合

的 紧 凑 对 齐 由 /Zp 选 项 设 置 。 紧 凑 对 齐 用 pace 编 译 指 示 在 数 据 说 明 层 设 置 。 该编 译 指 示 在 其 出 现 后 的 第 一 个 结 构 或 联 合 说 明 处 生 效 。 该 编 译 指 示 对 定 义 无 效 。当 你 使 用 #pragma pack( n ) 时 , 这 里 n 为 1 、 2 、 4 、 8 或 16 。 第 一 个 结 构 成 员 之后 的 每 个 结 构 成 员 都 被 存 储 在 更 小 的 成 员 类 型 或 n 字 节 界 限 内 。 如 果 你 使 用 无参 量 的 #pragma pack, 结 构 成 员 被 紧 凑 为 以 /Zp 指 定 的 值 。 该 缺 省 /Zp 紧 凑 值 为

/Zp8 。

编 译 器 也 支 持 以 下 增 强 型 语 法 :

#pragma pack([[{push|pop},][ 标 识 符 ,]][ n ])

若 不 同 的 组 件 使 用 pack 编 译 指 示 指 定 不 同 的 紧 凑 对 齐 , 这 个 语 法 允 许 你 把 程 序组 件 组 合 为 一 个 单 独 的 转 换 单 元 。

带 push 参 量 的 pack 编 译 指 示 的 每 次 出 现 将 当 前 的 紧 凑 对 齐 存 储 到 一 个 内 部 编译 器 堆 栈 中 。 编 译 指 示 的 参 量 表 从 左 到 右 读 取 。 如 果 你 使 用 push, 则 当 前 紧 凑值 被 存 储 起 来 ; 如 果 你 给 出 一 个 n 的值 , 该 值 将 成 为 新 的 紧 凑 值 。 若 你 指 定 一 个标 识 符 , 即 你 选 定 一 个 名 称 , 则 该 标 识 符 将 和 这 个 新 的 的 紧 凑 值 联 系 起 来 。

带 一 个 pop 参 量 的 pack 编 译 指 示 的 每 次 出 现 都 会 检 索 内 部 编 译 器 堆 栈 顶 的 值 , 并 且 使 该 值 为 新 的 紧 凑 对 齐 值 。 如 果 你 使 用 pop 参 量 且 内 部 编 译 器 堆 栈 是 空 的 , 则 紧 凑 值 为 命 令 行 给 定 的 值 , 并 且 将 产 生 一 个 警 告 信 息 。 若 你 使 用 pop 且 指 定 一个 n 的值 , 该 值 将 成 为 新 的 紧 凑 值 。

若 你 使 用 pop 且 指 定 一 个 标 识 符 , ±所 有 存 储 在 堆 栈 中 的 值 将 从 栈 中 删 除 , 直 到 找到 一 个 匹 配 的 标 识 符 , 这 个 与 标 识 符 相 关 的 紧 凑 值 也 从 栈 中 移 出 , 并 且 这 个 仅 在标 识 符 入 栈 之 前 存 在 的 紧 凑 值 成 为 新 的 紧 凑 值 。 如 果 未 找 到 匹 配 的 标 识 符 , 将 使用 命 令 行 设 置 的 紧 凑 值 , 并 且 将 产 生 一 个 一 级 警 告 。 缺 省 紧 凑 对 齐 为 8 。

pack 编 译 指 示 的 新 的 增 强 功 能 让 你 编 写 头 文 件 , 确 保 在 遇 到 该 头 文 件 的 前 后 的紧 凑 值 是 一 样 的 。

/* File name: include1.h

*/

# pragma pack(push,enter_include1)

/* 你 的 包 括 文 件 代 码 ... */

# pragma pack(pop, enter_include1)

/* include1.h 结束 */

在 上 面 的 例 子 中 , 当 前 紧 凑 值 与 标 识 符 enter_include1 联 系 起 来 , 并 被 压 入 头 文件 的 项 中 。 头 文 件 末 尾 的 pack 编 译 指 示 删 除 所 有 可 能 出 现 在 头 文 件 中 的 干 预 紧凑 值 , 并 且 删 除 与 enter_include1 相 关 的 紧 凑 值 。 因 此 确 保 该 头 文 件 的 前 后 的紧 凑 值 是 相 同 的 。

这 种 新 功 能 也 允 许 你 使 用 代 码 , 例 如 头 文 件 , 它 可 以 使 用 pack 编 译 指 示 设 置 不 同于 在 你 的 代 码 中 设 置 的 紧 凑 值 的 紧 凑 对 齐 :

# pragma pack(push,before_include1) # include "include1.h"

# pragma pack( pop,before_include1)

在 上 面 的 例 子 中 , 对 于 出 现 在 include.h 中 的 紧 凑 值 的 任 何 变 化 , 你 的 代 码 是 受到 保 护 的 。

setlocale

# pragma setlocale(" locale_string ")

该 指 令 在 翻 译 宽 字 符 常 量 和 字 符 串 文 字 时 定 义 其 场 所 ( 国 家 和 语 言 ) 。 由 于 用 于转 换 多 字 节 字 符 为 宽 位 字 符 的 算 法 可 能 由 于 场 所 或 编 译 而 不 同 , 该 执 行 文 件 在 不同 的 场 所 运 行 也 可 能 不 同 。 这 个 编 译 指 示 提 供 了 在 编 译 时 给 出 目 标 场 所 的 方 法 。这 保 证 了 宽 字 符 串 以 正 确 的 格 式 进 行 存 储 。缺 省 的 locale _ _ string( 场 所 字 符 串 ) 是 ±“ C ”。“ C ” 场 所 将 每 个 该 串 中 的 字 符 映 射 为 一 个 wchar_t(unsigned short) 型 的 值 。

warning

# pragma warning( warning-specifier : warning-number-list

[, warning-specifier : warning-number-lis t...]) # pragma warning(push[, n ])

# pragma warning(pop)

该 指 令 允 许 选 择 性 地 改 变 编 译 器 的 警 告 消 息 。

warning-specifier 可 以 是 如 下 值 之 一 :

警告指示符 含义

once 只显示一次指定的消息

default 将缺省的编译器行为应用于指定的消息

1,2,3,4 把给定的警告级应用于指定的警告消息

disable 不发出指定警告消息

error 作为错误报告指定的警告

warning-number-list ( 警 告 编 号 表 ) 可 以 包 含 任 何 警 告 编 号 。 在 相 同 的 编 译 指 示 指令 中 可 指 定 多 个 选 项 如 下 :

# pragma warning( disable : 4507 34; once : 4385; error : 164 ) 其 功 能 想 当 于 :

#pragma warning( disable : 4507 34 ) // 禁 止 警 告 消 息 4507 和 34. #pragma warning( once : 4385 )// 仅 发 出 警 告 4385 一 次

#pragma warning( error : 164 )// 作 为 一 个 错 误 报 告 警 告 164

对 于 那 些 与 代 码 生 成 有 关 , 且 大 于 4699 的 警 告 编 号 来 说 , 这 个 warning 编 译 指 示仅 当 放 在 函 数 定 义 外 时 有 效 。 如 果 警 告 编 号 大 于 4699 或 用 在 函 数 体 内 , 则 忽 略该 编 译 指 示 。 下 面 的 例 子 指 出 了 禁 止 warning 编 译 指 示 的 正 确 位 置 , 且 随 后 恢 复一 个 代 码 生 成 警 告 消 息 的 产 生 。

int a;

# pragma warning( disable : 4705 ) void func()

{

a;

}

# pragma warning( default : 4705 ) warning 编 译 指 示 也 支 持 以 下 语 法 :

# pragma warning( push[, n ]) # pragma warning( pop)

这 里 n 代 表 警 告 级 (1 到 4) 。

编 译 指 示 warning(push) 存 储 所 有 警 告 的 当 前 警 告 状 态 。 编 译 指 示warning(push, n ) 存 储 所 有 警 告 的 当 前 警 告 状 态 并 设 置 全 局 警 告 级 为 n 。

编 译 指 示 warning(pop) 将 上 次 压 入 栈 的 警 告 状 态 弹 出 ,push 和 pop 之 间 警 告 状态 的 任 何 变 化 都 将 被 取 消 。 考 虑 这 个 例 子 :

# pragma warning(push)

# pragma warning(disable : 4705) # pragma warning(disable : 4706) # pragma warning(disable : 4707)

// 某 些 代 码

# pragma warning(pop)

在 这 段 代 码 的 未 尾 ,pop 恢 复 所 有 警 告 状 态 ( 包 括 4705 、 4706 和 4707) 为 它 在 代码 起 始 处 的 警 告 状 态 。

当 你 编 写 头 文 件 时 , 可 以 用 push 和 pop 以 确 保 对 于 用 户 造 成 的 警 告 状 态 的 变 化 , 不 会 影 响 头 部 的 正 确 编 译 。 通 常 在 头 部 的 起 始 处 使 用 push, 在 末 尾 处 使 用 pop 。例 如 , ±有 一 个 在 警 告 级 4 未 彻 底 编 译 的 头 部 。 以 下 代 码 将 警 告 级 改 为 3, 然 后 在头 部 的 未 尾 恢 复 原 来 的 警 告 级 :

# pragma warning(push,3)

// 说 明 / 定 义

# pragma warning(pop)