第 1 章 词 法 规 定

本 章 介 绍 C++ 程 序 的 基 本 元 素 , 你 使 用 这 些 被 称 为 “ 词 法 元 素 ” 或 “ 符 号 ” 的 元素 去 构 造 语 句 、 定 义 、 说 明 等 , 并 使 用 它 们 构 造 完 整 的 程 序 。 本 章 讨 论 以 下 词 法元 素 ：

• 语 言 符 号

• 注 释

• 标 识 符

• 关 键 字

• 标 点 符 号

• 运 算 符

• 文 字

本 章 还 包 括 表 1.1, 该 表 中 给 出 了 C++ 运 算 符 的 优 先 级 和 结 合 律 ( 优 先 级 从 最 高 到最 低 排 列 ) 。 有 关 运 算 符 的 完 整 讨 论 参 见 第 4 章 “ 表 达 式 ”。

文 件 翻 译 概 述

C++ 程 序 和 C 程 序 一 样 , 由 一 个 或 多 个 文 件 组 成 , 每 个 文 件 按 如 下 概 念 顺 序 被 翻 译( 实 际 的 顺 序 遵 循 “ as if ” 规 则 : 只 要 遵 照 这 些 步 骤 则 翻 译 必 然 发 生 ):

1. 词 法 符 号 化 : 此 翻 译 阶 段 执 行 字 符 映 射 及 三 字 母 处 理 、 行 分 割 及 符 号 化 。

2. 预 处 理 : 此 翻 译 阶 段 调 入 由 #include 命 令 引 用 的 辅 助 源

   文 件 , 处 理 “ 字 符 串化 ” 和 “ 字 符 化 ” 命 令 , 执 行 符 号 传 递 和 宏 扩 展 ( 若 需 要 更 多 信 息 则 可 见 本 册 后面 “ 预 处 理 器 参 考 ” 中 的 “ 预 处 理 器 命 令 ” ), 预 处 理 的 结 果 是 一 组 有 序 的 符 号 , 合 在 一 起 定 义 了 一 个 “ 转 换 单 元 ”。

预 处 理 器 命 令 总 是 以 数 字 符 号 (#) 开 头 ( 即 , 一 行 的 第 一 个 非 空 白 字 符 必 须 是 一 个数 字 符 号 ) 。 一 行 只 能 出 现 一 条 预 处 理 器 命 令 。 例 如 :

#include <iostream.h> // 在 转 换 单 元 包 含 iostream.h 文 本 。#define NDEBUG // 定 义 NDEBUG(NDEBUG 包 含 空 文 本 字 符 串 ) 。

1. 产 生 代 码 : 此 翻 译 阶 段 是 用 预 处 理 阶 段 生 成 的 符 号 来

   生 成 目 标 代 码 。在 此 阶 段 , 执 行 源 代 码 的 语 法 及 语 义 检 查 。

若 需 要 更 多 的 信 息 可 参 阅 本 手 册 后 面 “ 预 处 理 器 参 考 ” 中 的 “ 翻 译 阶 段 ”。

C++ 预 处 理 器 是 ANSI C 预 处 理 器 的 严 格 的 超 集 , 但 是 C++ 预 处 理 器 在 某 些 实 例 上有 所 不 同 。

以 下 所 列 的 是 ANSI C 与 C++ 预 处 理 器 的 几 处 不 同 点 :

• 支 持 单 行 注 释 , 详见 “ 注 释 ”

• 一 种 预 定 义 宏 _{__} cplusplus 仅 为 C++ 所 定 义 。 详 见 本 卷 后 面 “ 预 处 理器 参 考 ” 中 的 “ 预 定 义 宏 ”。

• C 预 处 理 器 不 能 识 别 C++ 的 .* . ->* 和 :: 运 算 符 。 有 关 运 算 符 详 见 本章 后 面 的 “ 运 算 符 ” 以 及 第 4 章 “ 表 达 式 ”。

语 言 符 号

• 个 语 言 符 号 是 C++ 程 序 中 对 编 译 器 有 意 义 的 最 小 单 元 。 C++ 语 法 分 析 程 序 识 别以 下 这 些 种 类 的 语 言 符 号 : 标 识 符 、 关 键 字 、 文 字 、 运 算 符 、 标 点 符 号 及 其 它 分隔 符 。 这 一 串 符 号 构 成 一 个 转 换 单 元 。

语 言 符 号 通 常 由 " 空 白 " 分 开 , 空 白 可 以 是 一 个 或 多 个 :

• 空 格

• 水 平 或 垂 直 制 表 符

• 换 行 符

• 换 页 符

• 注 释

语 法

符 号 :

关 键 字

标 识 符

常量

运 算 符

标 点 符 号预 处 理 符 号 :

头 名 称

标 识 符

pp 数

字 符 常 量

字 符 串 文 字

运 算 符

标 点 符 号

每 个 非 空 白 字 符 不 能 是 以 上 中 的 一 种 。

语 法 分 析 程 序 通 过 对 输 入 字 符 从 左 到 右 扫 描 , 尽 可 能 地 从 输 入 流 中 创 建 最 长 的 语言 符 号 集 来 分 割 语 言 符 号 。 考 虑 以 下 代 码 段 :

a=i+++j;

写 此 代 码 的 程 序 员 可 能 有 以 下 两 种 语 句 目 的 :

a=i+(++j)

a=(i++)+j

由 于 语 法 分 析 程 序 从 输 入 流 尽 可 能 创 建 最 长 的 符 号 集 , 所 以 它 选 择 第 二 种 解 释 , 得 到 符 号 i++ 、 + 和 j 。

注 释

注 释 是 编 译 器 忽 略 的 文 本 , 但 对 程 序 设 计 者 而 言 却 非 常 有 用 。 注 释 通 常 对 代 码 进行 标 注 以 便 以 后 参 考 。 编 译 器 把 它 们 作 为 空 白 对 待 。 在 调 试 时 你 可 以 使 用 注 释使 得 特 定 行 代 码 不 运 行 ; 但 是 ,#if#endif 预 处 理 命 令 在 这 方 面 更 好 , 因 为 你 可 以括 起 包 含 注 释 在 内 的 代 码 , 但 是 你 不 能 嵌 套 注 释 。

• 个 C++ 注 释 按 以 下 的 一 种 方 式 书 写 :

  • /*( 斜 杠 , 星 号 ) 字 符 , 后 面 跟 随 任 意 字 符 序 列 ( 包 括 新 行 ), 再 跟 上 */ 字 符 。 这 种 语 法 与 ANSI C 的 一 样 。

  • //( 两 个 斜 杠 ) 字 符 , 后 面 跟 随 任 意 字 符 序 列 。 一 个 不 是 紧 随 后 面 反斜 杠 的 新 行 将 结 束 此 种 形 式 的 注 释 。 因 此 , 它 通 常 被 称 为 “ 单 行 注释 ” 。

注 释 字 符 (/*,*/ 和 //) 在 字 符 常 量 : 字 符 串 文 字 或 注 释 内 部 没 有 任 何 特 殊 意 义 。因 此 , 使 用 第 一 种 语 法 的 注 释 不 能 被 嵌 套 使 用 , 考 虑 以 下 例 子 :

/* Intent: Comment out this block of code.

Problem:Nested comments on each line of code are illegal.

FileName=String("hello.dat"); /*Initialize file string*/

cout << "File:" << FileName << "\n";/*Print status message*/

*/

执 行 代 码 不 能 编 译 , 因 为 编 译 器 扫 描 输 入 流 , 从 第 一 个 /* 到 第 一 个 */, 则 认 为 它 是一 个 注 释 。 在 这 种 情 况 下 , 第 一 个 */ 出 现 在 注 释 Initialize file string 的 末尾 。 那 么 对 最 后 一 个 */, 则 再 没 有 一 个 /* 与 其 配 对 了 。

注 意 : 注 释 的 单 行 形 式 (//) 后 面 跟 随 一 个 续 行 符 (/) 会 产 生 出 人 意 料 的 结 果 。 考虑 以 下 代 码 :

#include<stdio.h>

void main()

{

printf("This is a number %d",//\

5);

}

在 预 处 理 之 后 , 前 面 的 代 码 有 错 并 显 示 如 下 : #indude<stdio.h>

void main()

{

printf("This is a number %d",

}

标 识 符

• 个 标 识 符 是 一 个 用 于 对 以 下 内 容 之 一 进 行 编 码 的 字 符

  序 列 :

  • 对 象 或 变 量 名 称

  • 类 、 结 构 或 联 合 名 称

  • 枚 举 的 类 型 名 称

  • 类 、 结 构 、 联 合 或 枚 举 的 成 员

  • 函 数 或 类 成 员 函 数

  • 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

Microsoft 特 殊 处 →

仅 Microsoft C++ 标 识 符 的 前 247 个 字 符 是 有 意 义 的 。 由 于 用 户 定 义 类 型 的 名称 由 编 译 器 “ 修 饰 ” 以 保 存 类 型 信 息 的 事 实 而 使 得 这 一 限 制 变 得 复 杂 。 结 果 名称 , 包 括 类 型 信 息 , 不 能 超 过 247 个 字 符 长 度 。 ( 详 见 联 机 “ Microsoft Visual C++6.0 程 序 员 指 南 ” 中 的 “ 修 饰 名 称 ” ) 。 能 够 影 响 修 饰 的 标 识 符 长 度 的 因 素有 :

• 不 论 标 识 符 表 示 一 个 用 户 定 义 类 型 的 对 象 还 是 表 示 用 户 定 义 类 型 的派 生 类 型 的 对 象 。

• 不 论 标 识 符 表 示 一 个 函 数 还 是 表 示 函 数 派 生 的 类 型 。

• 一 个 函 数 的 参 量 的 个 数 。

Microsoft 特 殊 处 结 束

• 个 标 识 符 的 首 字 符 必 须 是 字 母 , 不 论 大 写 或 小 写 , 或 一 个 下 划 线 (_) 。 由 于 C++ 标 识 符 对 大 小 写 敏 感 , 所 以 fileName 和 FileName 是 不 同 的 。

标 识 符 不 能 与 关 键 字 使 用 一 样 的 拼 写 和 大 小 写 方 式 。 标 识 符 中 含 有 关 键 字 是 合法 的 , 例 如 ,pint 是 一 个 合 法 的 标 识 符 , 尽 管 它 包 含 了 关 键 字 int 。

在 一 个 标 识 符 的 开 头 使 用 连 续 的 两 个 下 划 线 ( -- ) 或 一 个 下 划 线 打 头 后 跟 一 个 大 写字 母 , 则 在 所 有 范 围 中 为 C++ 的 实 现 而 保 留 , 你 应 当 避 免 使 用 一 个 打 头 的 下 划 线带 一 个 小 写 字 母 作 为 有 文 件 范 围 的 名 称 , 因 为 它 可 能 与 现 在 或 将 来 保 存 的 标 识 符相 冲 突 。

关 键 字

关 键 字 是 有 特 殊 含 义 的 预 定 义 的 保 留 标 识 符 。 它 们 不 能 被 用 作 你 程 序 中 的 标 识符 。 以 下 是 C++ 保 留 的 关 键 字 :

语 法

关 键 字 : 如 下 之 一

* 为 与 其 它 C++ 实 现 相 兼 容 而 保 留 的 , 但 没 有 实 现 。 使 用 --asm 。

Microsoft 特 殊 处 →

在 Microsoft C++ 中 , 由 两 个 下 划 线 开 头 的 标 识 符 是 为 编 译 器 的 实 现 而 保 留 的 。因 此 ,Microsoft 规 定 是 在 Microsoft 特 定 关 键 字 前 加 上 双 下 划 线 , 这 些 字 不 可用 作 标 识 符 名 。

1. . 这 些 当 与 -- declspec 一 起 使 用 时 是 特 殊 的 标 识 符 , 在 其 它 上 下 文 中 的 应 用则没 有 限 制 。

Microsoft 扩 充 部 分 在 缺 省 状 态 下 是 允 许 的 , 为 确 保 你 的 程 序 完 全 可 移 植 , 你 可以 通 过 指 定 ANSI 可 兼 容 性 /Za 命 令 行 选 项 , 使 得 编 译 期 间 Microsoft 扩 充 部 分不 可 用 。 当 你 这 样 做 时 ,Microsoft 特 定 关 键 字 是 不 可 用 的 。

当 Microsoft 扩 充 部 分 使 能 时 , 你 可 以 在 你 的 程 序 里 使 用 前 面 罗 列 的 关 键 字 。

对 ANSI 应 用 , 这 些 关 键 字 被 冠 以 双 下 划 线 。 为 向 后 兼 容 , 所 有 关 键 字 除 _{__}except 、

_{_ _} finally 、 _{_ _}leave 和 _{__} try 外 , 其 单 下 划 线 版 本 均 被 支 持 , 此 外 , _{__} cdecl 不 带 前面 下 划 线 的 也 可 用 。

Microsoft 特 殊 处 结 束

标 点 符 号

C++ 中 的 标 点 符 号 对 编 译 器 而 言 具 有 语 法 及 语 义 意 义 , 但 其 自 身 并 不 指 定 产 生 数值 的 某 种 操 作 。 某 些 标 点 符 号 , 不 论 是 单 独 使 用 或 以 组 合 方 式 使 用 , 均 可 作 为 C++ 的 运 算 符 或 对 预 处 理 器 有 重 要 意 义 。

语 法

标 点 符 号 : 如 下 之 一

! % ^ & * ( ) - + = { } | ~

[ ] \ ; ' : " < > ? , . / #

标 点 符 号 [] 、 () 和 { } 在 翻 译 第 4 阶 段 后 必 须 成 对 出 现 。

运 算 符

运 算 符 指 定 执 行 以 下 一 种 求 值 运 算 :

• 一 个 操 作 数 ( 单 目 运 算 符 )

• 两 个 操 作 数 ( 双 目 运 算 符 )

• 三 个 操 作 数 ( 三 目 运 算 符 )

C++ 语 言 包 含 了 C 中 的 所 有 运 算 符 , 还 添 加 了 几 个 新 的 运 算 符 , 表 1.1 列 出 了Microsoft C++ 中 可 用 的 运 算 符 。

运 算 符 按 照 严 格 的 优 先 级 来 确 定 包 含 这 些 运 算 符 的 表 达 式 的 运 算 顺 序 。 运 算 符要 么 与 其 左 边 的 表 达 式 结 合 , 要 么 与 其 右 边 的 表 达 式 结 合 , 这 被 称 为 “ 结 合 律 ”。

同 组 中 的 运 算 符 具 有 相 同 的 优 先 级 , 在 表 达 式 中 从 左 向 右 运 算 , 除 非 用 括 号 () 明确 指 定 其 顺 序 , 表 1.1 给 出 了 C++ 运 算 符 的 优 先 级 及 结 合 律 ( 优 先 级 从 高 到 低 ) 。

表 1.1 C++ 运 算 符 优 先 级 与 结 合 性

非 变 元 的 程 序 元 素 被 称 为 “ 文 字 ” 或 “ 常 量 ”。 在 这 里 术 语 “ 文 字 ” 和 “ 常 量 ” 可 互 换 使 用 。

文 字 有 四 个 主 要 类 别 : 整 型 、 字 符 型 、 浮 点 型 和 字 符 串 文 字 。

语 法

文 字 :

整 型 常 量

字 符 常 量

浮 点 常 量

字 符 串 文 字

整 型 常 量

整 型 常 量 是 没 有 小 数 部 分 或 指 数 的 常 量 数 据 元 素 , 总 是 以 数 字 开 头 。 你 可 以 按 十进 制 、 八 进 制 或 十 六 进 制 形 式 指 定 整 型 常 量 。 可 指 定 为 有 符 号 的 或 无 符 号 类 型

以 及 长 型 或 短 型 。

语 法

整 型 常 量 :

十 进 制 常 量 整 数 后 缀 _opt

八 进 制 常 量 整 数 后 缀 _opt

十 六 进 制 常 量 整 数 后 缀 _opt

‘ c 字 符 序 列 ' 十 进 制 常 量 :

非 0 数 字

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

0

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

0x 十 六 进 制 数 字

0X 十 六 进 制 数 字

十 六 进 制 常 量 十 六 进 制 数 字非 0 数字 : 如 下 之 一

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

64 位 整 数 后 缀

i64

用 八 进 制 或 十 六 进 制 计 数 法 指 定 整 型 常 量 时 , 使 用 一 个 前 缀 指 明 基 数 。 要 指 定 一给 定 整 型 类 型 的 整 型 常 量 , 则 使 用 一 个 后 缀 指 定 类 型 。

指 定 一 个 十 进 制 常 量 , 须 以 一 个 非 0 数 字 开 头 。 例 如 :

int i=157; // 十 进 制 常 量

int j=0198; // 不 是 一 个 十 进 制 数 , 是 一 个 错 误 的 八 进 制 常 量int k=0365; // 打 头 的 0 指 定 的 是 八 进 制 常 量 , 而 不 是 十 进 制 数

指 定 一 个 八 进 制 常 量 , 则 以 0 开 头 , 后 面 跟 随 从 0-7 范 围 内 的 数 字 序 列 。 在 指 定一 个 八 进 制 常 量 时 , 数 字 8 和 9 是 错 误 的 。 例 如 :

int i=0377; // 八 进 制 常 量

int j=0397; // 错 误 :9 不 是 一 个 八 进 制 数 符

指 定 一 个 十 六 进 制 常 量 , 则 以 0x 或 0X(X 的 大 小 写 无 关 ) 开 始 , 后 面 跟 随 0-9 和a( 或 A)-f( 或 F) 范 围 内 的 数 符 序 列 。 十 六 进 制 数 符 a( 或 A) 到 f( 或 F) 代 表 的 数值 范 围 是 10-15 。 例 如 :

int i=0x3fff; // 十 六 进 制 常 量int j=0X3FFF; // 与 i 相 等

指 定 为 无 符 号 类 型 , 则 使 用 u 或 U 作 后 缀 指 定 为 长 型 , 则 用 l 或 L 作 后 缀 。 例 如 : unsigned uVal=328u; // 无 符 号 数

long lVal=0x7FFFFFL; // 长 型 数 值 作 为 十 六 进 制 常 量unsigned long ulVal=0776745ul; // 无 符 号 长 型 数 值

字 符 常 量

字 符 常 量 是 “ 源 字 符 集 ” 中 的 一 个 或 几 个 成 员 , 源 字 符 集 是 一 个 程 序 中 使 用 的 字符 集 , 字 符 常 量 由 单 引 号 (') 括 起 。 它 们 被 用 于 表 示 “ 执 行 字 符 集 ” 即 程 序 执 行所 用 机 器 的 字 符 集 中 的 字 符 。

Microsoft 特 殊 处 →

对 Microsoft C++ 而 言 , 源 字 符 集 与 执 行 字 符 集 都 是 ASCII 码 。

Microsoft 特 殊 处 结 束

有 三 种 字 符 常 量 :

• 普 通 字 符 常 量

• 多 字 符 常 量

• 宽 字 符 常 量

注 : 使 用 宽 字 符 常 量 替 代 多 字 符 常 量 可 确 保 可 移 植 性 字 符 常 量 被 指 定 为 单 引 号 括

起 的 一 个 或 多 个 字 符 , 例 如 :

char ch= ′ x ′ ; // 指 定 普 通 字 符 常 量

int mbch= ′ ab ′ ;// 指 定 依 赖 于 系 统 的 多 字 符 常 量wchar_t wcch=L ′ ab ′ ; // 指 定 宽 字 符 常 量

注 意 mbch 的 类 型 是 int, 如 果 它 被 说 明 为 char 类型 , 则 第 二 个 字 节 将 被 保 留 起来 。 一 个 多 字 符 常 量 有 四 个 有 意 义 的 字 符 , 若 指 定 的 字 符 数 超 过 四 则 将 产 生 错 误信 息 。

语 法

字 符 常 量 :

c ‘ 字 符 序 列 '

L ‘ c 字 符 序 列 ' c 字 符 序 列 :

c 字 符

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

源 字 符 集 中 除 单 引 号 ( ′ ) 、 反 向 斜 杠 (\) 或 换 行 符 外 的 任 何 字 符

转 义 序 列转 义 序 列 :

简 单 转 义 序 列

八 进 制 转 义 序 列

十 六 进 制 转 义 序 列简 单 转 义 序 列 : 如 下 之 一

\ ′ \" \? \\

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

\ 八 进 制 数 字

\ 八 进 制 数 字 八 进 制 数 字

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

\x 十 六 进 制 数 字

十 六 进 制 转 义 序 列 十 六 进 制 数 字

Microsoft C++ 支 持 普 通 字 符 、 多 字 符 和 宽 字 符 常 量 , 使 用 宽 字 符 常 量 去 指 定 扩充 执 行 字 符 集 ( 例 如 要 支 持 国 际 应 用 ) 的 成 员 。 普 通 字 符 常 量 为 类 型 char, 多 字符 常 量 类 型 为 int, 宽 字 符 常 量 类 型 为 wchar_t 。 (wchar_t 类 型 定 义 在 标 准 头 文件 STDDEF.H, STDLIB.H 和 STRING.H 中 , 但 是 宽 字 符 函 数 的 原 型 仅 在 STDLIB.H 中 ) 。

在 指 定 普 通 的 和 宽 字 符 常 量 时 唯 一 的 不 同 之 处 是 宽 字 符 常 量 字 母 以 L 打 头 。 例如 :

char schar= ′ x ′ ;// 普 通 字 符 常 量

wchar_t wchar=L ′ \x81\x19 ′ ; // 宽 字 符 常 量

表 1.2 给 出 的 是 依 赖 于 系 统 的 或 不 允 许 在 字 符 常 量 中 使 用 的 保 留 的 或 非 显 示 的字 符 , 这 些 字 符 须 由 转 义 序 列 表 示 。

表 1.2 C++ 保 留 的 或 非 显 示 的 字 符

如 果 反 向 斜 杠 后 面 的 字 符 不 是 指 定 的 一 个 合 法 转 义 序 列 , 则 结 果 在 实 现 时 确 定 。Microsoft C++ 中 , 跟 在 反 向 斜 杠 后 的 字 符 作 为 文 字 被 接 收 , 尽 管 转 义 不 存 在 , 而且 出 现 层 1 的 警 告 ( “ 无 法 识 别 的 字 符 转 义 序 列 ” ) 。

以 \ ooo 形 式 指 定 的 八 进 制 转 义 序 列 包 括 一 个 反 向 斜 杠 和 一 个 、 两 个 或 三 个 八 进制 字 符 ; 以 \x hhh 形 式 指 定 的 十 六 进 制 转 义 序 列 包 括 字 符 \x 和 其 后 跟 随 的 十 六 进制 数 字 序 列 ; 与 八 进 制 转 义 序 列 不 同 的 是 在 十 六 进 制 转 义 序 列 中 对 十 六 进 制 数 字

的 数 目 没 有 限 制 。

八 进 制 转 义 序 列 由 第 一 个 非 八 进 制 数 字 的 字 符 结 束 或 当 三 个 字 符 可 见 时 , 例 如 : wchar_t och=L ′ \076a ′ ; // 序 列 在 a 处 结 束

char ch= ′ \233 ′ ; // 序 列 在 3 个 字 符 后 结 束

相 似 地 , 十 六 进 制 转 义 序 列 在 第 一 个 非 十 六 进 制 数 字 处 结 束 。 由 于 十 六 进 制 数 字包 括 字 母 a ～ f( 和 A ～ F), 所 以 要 确 定 转 义 序 列 在 所 想 要 的 数 字 处 结 束 。

由 于 单 引 号 ( ′ ) 用 于 括 住 字 符 常 量 , 所 以 用 转 义 序 列 \
′ 来 表 示 被 包 含 的 单 引号 。 双 引 号 (") 可 以 不 用 转 义 序 列 表 示 。 反 向 斜 杠 (\) 被 放 在 行 尾 时 是 作 为 续 行符 的 , 如 果 你 想 要 一 个 反 向 斜 杠 出 现 在 一 个 字 符 常 量 中 , 你 必 须 在 一 行 里 打 上 两个 反 斜 杠 ( 关 于 行 继 续 的 更 多 信 息 可 参 阅 本 卷 后 面 “ 预 处 理 器 参 考 ” 中 的 “ 翻 译阶 段 ” ) 。

浮 点 常 量

浮 点 常 量 指 定 的 数 值 必 须 带 有 小 数 部 分 , 这 些 数 值 包 含 小 数 点 (.), 且 可 以 包 含 指数 。

语 法

浮 点 数 量 :

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

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

小 数 常 量 :

数 字 序 列 _opt. 数 字 序 列

数 字 序 列

指 数 部 分 :

e 符 号 _opt 数 字 序 列

E 符 号 _opt 数 字 序 列符 号 : 如 下 之 一

+ - 数 字 序 列 :

数字

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

f l F L

浮 点 常 量 有 一 个 “ 尾 数 ” 指 定 数 的 值 , 一 个 “ 指 数 ” 指 定 数 的 量 值 , 以 及 一 个 可选 后 缀 指 定 常 量 的 类 型 。 尾 数 指 定 为 一 个 字 符 序 列 后 带 小 数 点 , 带 上 表 示 数 的 小数 部 分 的 可 选 的 数 字 序 列 。 例 如 :

18.46

38.

如 果 出 现 指 数 , 则 是 用 作 10 为 底 的 幂 次 来 指 定 数 的 量 值 , 如 下 例 所 示 : 18.46e0 //18.46

18.46e1 //184.6

如 果 出 现 指 数 , 尾 部 的 小 数 点 可 以 不 要 , 整 个 数 像 18E0 一 样 。

浮 点 常 量 的 缺 省 类 型 是 double 。 相 应 地 使 用 后 缀 f 或 l( 或 F 或 L, 后 缀 不 是 大小 写 敏 感 的 ), 常 量 可 分 别 被 指 定 为 float 或 long double 。

尽 管 long double 和 double 有 着 同 样 的 表 示 , 但 它 们 是 不 同 的 类 型 。 例 如 , 你 可

以 重 载 函 数 :

void func(double); 和

void func(long double);

字 符 串 文 字

字 符 串 文 字 是 由 双 引 号 括 起 的 源 字 符 集 中 的 0 个 或 多 个 字 符 组 成 , 一 个 字 符 串 文字 表 示 一 个 字 符 序 列 , 合 在 一 起 构 成 一 个 以 空 格 结 尾 的 字 符 串 。

语 法

字 符 串 文 字 :

"s 字 符 序 列 _opt"

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

s 字 符

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

除 双 引 号 (") 、 反 斜 杠 (\) 或 换 行 符 之 外 的 源 字 符 集 中 的 任 何 成 员

转 义 序 列

C++ 字 符 串 有 这 些 类 型 :

• char[ n ] 数 组 ,n 为 字 符 串 ( 以 字 符 方 式 ) 的 长 度 加 1, 因 为 用 结 束 符'\0' 标 识 字 符 串 结 尾 。

• wchar_t 数组 , 为 宽 字 符 串 。

修 改 字 符 串 常 量 的 结 果 是 不 确 定 的 , 例 如 :

char *szStr="1234";

szStr[2]= ′ A ′ ; // 结 果 不 确 定

Microsoft 特 殊 处 →

在 某 些 情 况 下 , 相 同 的 字 符 串 文 字 可 以 被 “ 合 并 ” 以 节 省 执 行 文 件 的 空 间 , 在 字符 串 文 字 合 并 时 , 编 译 器 使 所 有 对 特 定 字 符 串 文 字 的 引 用 都 指 向 存 储 器 中 相 同 的位 置 , 而 不 是 让 每 个 引 用 指 向 各 自 的 字 符 串 文 字 实 例 。 /GF 编 译 选 项 使 能 字 符 串合 并 。

Microsoft 特 殊 处 结 束

当 指 定 字 符 串 文 字 时 , 相 邻 的 字 符 串 将 被 连 接 起 来 。 因 此 , 如 下 说 明 : char szStr[]="12" "34";

与 下 面 的 说 明 完 全 相 同 :

char szStr[]="1234";

这 种 相 邻 字 符 串 的 连 接 使 得 可 以 很 容 易 地 通 过 多 个 行 指 定 长 字 符 串 。cout <<"Four score and seven years"

"ago, our forefathers brought forth"

"upon this continent a new nation.";

在 前 一 个 例 子 中 , 整 个 字 符 串 "Four score and seven years ago ,our forefathers brought forth upon this continent a new nation." 一 起 被 分割 处 理 。 这 个 字 符 串 还 可 以 按 如 下 方 式 用 行 分 割 符 来 指 定 :

cout<<"Four score and seven years\ ago, our forefathers brought forth\

upon this continent a new nation.";

常 量 中 所 有 相 邻 的 字 符 串 被 连 接 后 ,NULL 字 符 '\0' 被 添 加 , 为 C 字 符 串 处 理 函 数提 供 字 符 串 结 束 标 记 。

当 第 一 个 字 符 串 包 含 转 义 字 符 时 , 字 符 串 的 连 接 可 能 产 生 出 人 意 料 的 结 果 , 考 虑以 下 两 个 说 明 :

char szStr1[]="\01" "23"; char szStr2[]="\0123";

尽 管 很 自 然 地 认 为 szStr1 和 szStr2 包 含 相 同 的 值 , 但 它 们 实 际 所 包 含 的 值 由 图

1.1 给 出 。

图 1.1 转 义 和 字 符 串 的 连 接

Microsoft 特 殊 处 →

• 个 字 符 串 文 字 的 最 大 长 度 约 为 2048 个 字 节 , 这 个 限 制 适 用 于 char[] 和wchar_t[] 类 型 的 字 符 串 。 如 果 一 个 字 符 串 文 字 包 含 被 双 引 号 括 起 的 部 分 , 则 预处 理 器 将 这 个 部 分 连 接 成 一 个 单 字 符 串 , 而 且 对 每 行 连 接 , 在 总 字 节 数 上 加 上 一个 额 外 的 字 节 。

例 如 假 定 一 个 字 符 串 包 含 40 行 , 每 行 50 个 字 符 (2000 个 字 符 ), 以 及 有 一 行 为 7 个 字 符 , 且 每 行 均 由 双 引 号 括 起 , 合 计 为 2007 个 字 节 , 再 加 上 一 个 字 节 的 结 束 空

字 符 , 总 共 2008 个 字 节 。 在 字 符 串 进 行 连 接 时 , 前 面 的 40 行 每 行 添 加 一 个 额 外的 字 符 到 总 数 中 , 这 样 得 到 总 共 2048 个 字 节 。 ( 额 外 的 字 符 并 非 真 的 写 到 字 符 串中 ) 。 但 是 , 注 意 , 如 果 用 续 行 符 (\) 代 替 双 引 号 , 则 预 处 理 器 不 会 为 每 行 添 加 一 个额 外 的 字 符 。

Microsoft 特 殊 处 结 束

通 过 计 数 字 符 个 数 再 为 终 止 符 '\0' 加 1 或 为 wchar_t 类 型 加 2, 则 可 确 定 字 符 串对 象 的 大 小 。

因 为 双 引 号 (") 用 于 括 住 字 符 串 , 所 以 对 被 括 起 的 双 引 号 本 身 则 使 用 转 义 序 列 (\" 来 表 示 。 单 引 号 (') 可 以 不 用 转 义 序 列 表 示 。 反 向 斜 杠 被 置 于 行 尾 时 是 一 个 续 行符 , 如 果 你 想 要 反 向 斜 杠 出 现 在 一 个 字 符 串 中 , 则 你 必 须 打 上 两 个 反 斜 杠 (\\)( 关于 续 行 问 题 参 见 本 书 后 面 “ 预 处 理 器 引 用 ” 中 的 “ 翻 译 阶 段 ” 部 分 ) 。

为 了 指 定 一 个 类 型 为 宽 字 符 (wchar_t[]) 的 字 符 串 , 则 用 带 字 符 L 的 开 双 引 号 开头 。 例 如 :

wchar_t wszStr[]=L"lalg";

所 有 在 “ 字 符 常 量 ” 中 列 出 的 普 通 转 义 代 码 在 字 符 串 常 量 中 都 是 合 法 的 , 例 如 : cout<<"First line\nSecond line";

cout<<"Error! Take corrective action\a";

由 于 转 义 代 码 在 第 一 个 非 十 六 进 制 数 字 的 字 符 处 终 止 , 所 以 用 嵌 有 十 六 进 制 转 义代 码 来 指 定 字 符 串 常 量 可 能 造 成 意 想 不 到 的 结 果 , 以 下 例 子 意 在 创 建 一 个 包 含ASCII 5 的 字 符 串 文 字 ， 后 面 跟 随 字 符 five:

\x05five"

实 际 的 结 果 是 十 六 进 制 的 5F, 即 ASCII 代 码 的 下 划 线 , 后 面 跟 随 字 符 ive 。 以 下

例 子 生 成 的 是 所 希 望 的 结 果 : "\005five"// 使 用 八 进 制 常 量"\x05" "five"// 使 用 字 符 串 分 割