第二章 - 数据类型与运算
2.1 数据类型
使用编程语言进行编程时,需要用到各种变量来存储各种信息。变量保留的是它所存储的值的内存位置。这意味着,当您创建一个变量时,就会在内存中保留一些空间。
需要存储各种数据类型(比如字符型、宽字符型、整型、浮点型、双浮点型、布尔型等)的信息,操作系统会根据变量的数据类型,来分配内存和决定在保留内存中存储什么。
在C++中可以使用的数据类型有:
2.1.1 基本的内置类型
C++ 为程序员提供了种类丰富的内置数据类型和用户自定义的数据类型。下表列出了七种基本的 C++ 数据类型:
类型 | 关键字 |
---|---|
布尔型 | bool |
字符型 | char |
整型 | int |
浮点型 | float |
双浮点型 | double |
无类型 | void |
宽字符型 | wchar_t |
一些基本类型可以使用一个或多个类型修饰符进行修饰:
修饰符 | 含义 |
---|---|
signed | 有符号 |
unsigned | 无符号 |
short | 短 |
long | 长 |
注意: 不同系统会有所差异,一字节为 8 位。
注意: 默认情况下,int、short、long都是带符号的,即 signed。
注意: long int 8 个字节,int 都是 4 个字节,早期的 C 编译器定义了 long int 占用 4 个字节,int 占用 2 个字节,新版的 C/C++ 标准兼容了早期的这一设定。
- 无符号与有符号
signed: 则数值以补码形式存放,存储单元中的最高位(bit)用来表示数值符号。存放signed类型的存储单元中,左边第一位表示符号位(如果该位为0,表示该整数是一个正数;如果该位为1,表示该整数是一个负数)。一个32位的整型变量,除去左边第一位符号位,剩下表示值的只有31个比特位。
unsigned: 则数值没有符号,全部二进制都用来表示数值本身。
补码
- 正数的补码是该数的二进制形式。
- 负数的补码需要通过以下几步获得:
(1)先取得该数的绝对值的二进制形式
(2)再将第1步的值按位取反(除符号位)
(3)最后将第2步的值加1
例如:
下表显示了各种变量类型在内存中存储值时需要占用的内存,以及该类型的变量所能存储的最大值和最小值。
比特位:CPU能读懂的最小单位:比特位,bit,b;每个比特位只能存放二进制数,即0,1;
字节:内存最小寻址单位,字节,Byte,B,1Byte = 8bit;
补充
计算机单位换算关系
单位 | 换算关系 | 英文 | 中文 |
---|---|---|---|
1b | Bit | 位 | |
1B | 8b | Byte | 字节 |
1KB | 1024B | kilobyte | 千字节 |
1MB | 1024KB | Megabyte | 兆字节 |
计算机存储单位/容量单位(bit、B、KB、MB、GB、TB、PB、EB、ZB、YB、BB、NB、DB、CB):
bit 就是位,简写b,也叫比特位,是计算机表示数据最小的单位
byte 就是字节,简写B
1字符=2字节
1B(字节)=1byte=8bit=8b
1KB(千字节)=1024B =2^10 byte
1MB(兆字节)=1024KB
1GB(吉字节 又称千兆)=1024MB
1TB(太字节)=1024GB
1PB(拍字节)=1024TB
1EB(艾字节)=1024PB
1ZB(泽字节)=1024EB
1YB=1024ZB
1BB=1024YB
1NB(诺字节)=1024BB
1DB(地字节)=1024NB
1CB(侧字节)=1024DB
类型 | 位 | 范围 |
---|---|---|
char | 1 个字节 | -128 到 127 或者 0 到 255 |
unsigned char | 1 个字节 | 0 到 255 |
signed char | 1 个字节 | -128 到 127 |
int | 4 个字节 | -2147483648 到 2147483647 |
unsigned int | 4 个字节 | 0 到 4294967295 |
signed int | 4 个字节 | -2147483648 到 2147483647 |
short int | 2 个字节 | -32768 到 32767 |
unsigned short int | 2 个字节 | 0 到 65,535 |
signed short int | 2 个字节 | -32768 到 32767 |
long int | 8 个字节 | -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 |
signed long int | 8 个字节 | -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 |
unsigned long int | 8 个字节 | 0 到 18,446,744,073,709,551,615 |
float | 4 个字节 | 精度型占4个字节(32位)内存空间,+/- 3.4e +/- 38 (~7 个数字) |
double | 8 个字节 | 双精度型占8 个字节(64位)内存空间,+/- 1.7e +/- 308 (~15 个数字) |
long double | 16 个字节 | 长双精度型 16 个字节(128位)内存空间,可提供18-19位有效数字。 |
wchar_t | 2 或 4 个字节 | 1 个宽字符 |
示例程序
#include <iostream>
using namespace std;
int main()
{
cout << "Size of char : " << sizeof(char) << endl;
cout << "Size of int : " << sizeof(int) << endl;
cout << "Size of short int : " << sizeof(short int) << endl;
cout << "Size of long int : " << sizeof(long int) << endl;
cout << "Size of float : " << sizeof(float) << endl;
cout << "Size of double : " << sizeof(double) << endl;
cout << "Size of wchar_t : " << sizeof(wchar_t) << endl;
return 0;
}
本实例使用了 endl
,这将在每一行后插入一个换行符,<<
运算符用于向屏幕传多个值。我们也使用 sizeof()
函数来获取各种数据类型的大小。
当上面的代码被编译和执行时,它会产生以下的结果,结果会根据所使用的计算机而有所不同。
2.1.2 typedef 声明
可以使用 typedef
为一个已有的类型取一个新的名字。下面是使用 typedef 定义一个新类型的语法:
typedef type newname;
例如,下面的语句会告诉编译器,feet 是 int 的另一个名称:
typedef int feet;
现在,下面的声明是完全合法的,它创建了一个整型变量 distance:
feet distance;
2.1.3 枚举类型
枚举类型(enumeration)是C++中的一种派生数据类型,它是由用户定义的若干枚举常量的集合。
如果一个变量只有几种可能的值,可以定义为枚举(enumeration)类型。所谓"枚举"是指将变量的值一一列举出来,变量的值只能在列举出来的值的范围内。
创建枚举,需要使用关键字 enum
。枚举类型的一般形式为:
enum 枚举名{
标识符[=整型常数],
标识符[=整型常数],
...
标识符[=整型常数]
} 枚举变量;
如果枚举没有初始化, 即省掉"=整型常数"时, 则从第一个标识符开始。
例如,下面的代码定义了一个颜色枚举,变量 c 的类型为 color。最后,c 被赋值为 “blue”。
enum color { red, green, blue } c;
c = blue;
默认情况下,第一个名称的值为 0,第二个名称的值为 1,第三个名称的值为 2,以此类推。但是,您也可以给名称赋予一个特殊的值,只需要添加一个初始值即可。例如,在下面的枚举中,green 的值为 5。
enum color { red, green=5, blue };
在这里,blue 的值为 6,因为默认情况下,每个名称都会比它前面一个名称大 1,但 red 的值依然为 0。
2.1.4 修饰符类型
C++ 允许在 char、int 和 double 数据类型前放置修饰符。修饰符是用于改变变量类型的行为的关键字,它更能满足各种情境的需求。
下面列出了数据类型修饰符:
- signed:表示变量可以存储负数。对于整型变量来说,signed 可以省略,因为整型变量默认为有符号类型。
- unsigned:表示变量不能存储负数。对于整型变量来说,unsigned 可以将变量范围扩大一倍。
- short:表示变量的范围比 int 更小。short int 可以缩写为 short。
- long:表示变量的范围比 int 更大。long int 可以缩写为 long。
- long long:表示变量的范围比 long 更大。C++11 中新增的数据类型修饰符。
- float:表示单精度浮点数。
- double:表示双精度浮点数。
- bool:表示布尔类型,只有 true 和 false 两个值。
- char:表示字符类型。
- wchar_t:表示宽字符类型,可以存储 Unicode 字符。
修饰符 signed、unsigned、long 和 short 可应用于整型,signed 和 unsigned 可应用于字符型,long 可应用于双精度型。
这些修饰符也可以组合使用,修饰符 signed 和 unsigned 也可以作为 long 或 short 修饰符的前缀。例如:unsigned long int。
C++ 允许使用速记符号来声明无符号短整数或无符号长整数。您可以不写 int,只写单词 unsigned、short 或 long,int 是隐含的。例如,下面的两个语句都声明了无符号整型变量。
signed int num1 = -10; // 定义有符号整型变量 num1,初始值为 -10
unsigned int num2 = 20; // 定义无符号整型变量 num2,初始值为 20
short int num1 = 10; // 定义短整型变量 num1,初始值为 10
long int num2 = 100000; // 定义长整型变量 num2,初始值为 100000
long long int num1 = 10000000000; // 定义长长整型变量 num1,初始值为 10000000000
float num1 = 3.14f; // 定义单精度浮点数变量 num1,初始值为 3.14
double num2 = 2.71828; // 定义双精度浮点数变量 num2,初始值为 2.71828
bool flag = true; // 定义布尔类型变量 flag,初始值为 true
char ch1 = 'a'; // 定义字符类型变量 ch1,初始值为 'a'
wchar_t ch2 = L'你'; // 定义宽字符类型变量 ch2,初始值为 '你'
为了理解 C++ 解释有符号整数和无符号整数修饰符之间的差别,我们来运行一下下面这个短程序:
#include <iostream>
using namespace std;
/*
* 这个程序演示了有符号整数和无符号整数之间的差别
*/
int main()
{
short int i; // 有符号短整数
short unsigned int j; // 无符号短整数
j = 50000;
i = j;
cout << i << " " << j;
return 0;
}
当上面的程序运行时,会输出下列结果:
-15536 50000
上述结果中,无符号短整数 50,000 的位模式被解释为有符号短整数 -15,536。
C++ 中的类型限定符
类型限定符提供了变量的额外信息,用于在定义变量或函数时改变它们的默认行为的关键字。
限定符 | 含义 |
---|---|
const | const 定义常量,表示该变量的值不能被修改。 |
volatile | 修饰符 volatile 告诉该变量的值可能会被程序以外的因素改变,如硬件或其他线程。 |
restrict | 由 restrict 修饰的指针是唯一一种访问它所指向的对象的方式。只有 C99 增加了新的类型限定符 restrict。 |
mutable | 表示类中的成员变量可以在 const 成员函数中被修改。 |
static | 用于定义静态变量,表示该变量的作用域仅限于当前文件或当前函数内,不会被其他文件或函数访问。 |
register | 用于定义寄存器变量,表示该变量被频繁使用,可以存储在CPU的寄存器中,以提高程序的运行效率。 |
- const 实例
const int NUM = 10; // 定义常量 NUM,其值不可修改
const int* ptr = &NUM; // 定义指向常量的指针,指针所指的值不可修改
int const* ptr2 = &NUM; // 和上面一行等价
- volatile 实例
volatile int num = 20; // 定义变量 num,其值可能会在未知的时间被改变
- mutable 实例
class Example {
public:
int get_value() const {
return value_; // const 关键字表示该成员函数不会修改对象中的数据成员
}
void set_value(int value) const {
value_ = value; // mutable 关键字允许在 const 成员函数中修改成员变量
}
private:
mutable int value_;
};
- static 实例
void example_function() {
static int count = 0; // static 关键字使变量 count 存储在程序生命周期内都存在
count++;
}
- register 实例
void example_function(register int num) {
// register 关键字建议编译器将变量 num 存储在寄存器中
// 以提高程序执行速度
// 但是实际上是否会存储在寄存器中由编译器决定
}
2.1.5 存储类
存储类定义 C++ 程序中变量/函数的范围(可见性)和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C++ 程序中可用的存储类:
- auto
- register
- static
- extern
- mutable
- thread_local (C++11)
从 C++ 17 开始,auto 关键字不再是 C++ 存储类说明符,且 register 关键字被弃用。
- auto 存储类
自 C++ 11 以来,auto 关键字用于两种情况:声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。
C++98标准中auto关键字用于自动变量的声明,但由于使用极少且多余,在 C++17 中已删除这一用法。
根据初始化表达式自动推断被声明的变量的类型,如:
auto f=3.14; //double
auto s("hello"); //const char*
auto z = new auto(9); // int*
auto x1 = 5, x2 = 5.0, x3='r';//错误,必须是初始化为同一类型
- register 存储类
register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小(通常是一个词),且不能对它应用一元的 ‘&’ 运算符(因为它没有内存位置)。
{
register int miles;
}
寄存器只用于需要快速访问的变量,比如计数器。还应注意的是,定义 ‘register’ 并不意味着变量将被存储在寄存器中,它意味着变量可能存储在寄存器中,这取决于硬件和实现的限制。
- static 存储类
static 存储类指示编译器在程序的生命周期内保持局部变量的存在,而不需要在每次它进入和离开作用域时进行创建和销毁。因此,使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。
static 修饰符也可以应用于全局变量。当 static 修饰全局变量时,会使变量的作用域限制在声明它的文件内。
在 C++ 中,当 static 用在类数据成员上时,会导致仅有一个该成员的副本被类的所有对象共享。
#include <iostream>
// 函数声明
void func(void);
static int count = 10; /* 全局变量 */
int main()
{
while(count--)
{
func();
}
return 0;
}
// 函数定义
void func( void )
{
static int i = 5; // 局部静态变量
i++;
std::cout << "变量 i 为 " << i ;
std::cout << " , 变量 count 为 " << count << std::endl;
}
当上面的代码被编译和执行时,它会产生下列结果:
变量 i 为 6 , 变量 count 为 9
变量 i 为 7 , 变量 count 为 8
变量 i 为 8 , 变量 count 为 7
变量 i 为 9 , 变量 count 为 6
变量 i 为 10 , 变量 count 为 5
变量 i 为 11 , 变量 count 为 4
变量 i 为 12 , 变量 count 为 3
变量 i 为 13 , 变量 count 为 2
变量 i 为 14 , 变量 count 为 1
变量 i 为 15 , 变量 count 为 0
- extern 存储类
extern 存储类用于提供一个全局变量的引用,全局变量对所有的程序文件都是可见的。当您使用 ‘extern’ 时,对于无法初始化的变量,会把变量名指向一个之前定义过的存储位置。
当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时,可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解,extern 是用来在另一个文件中声明一个全局变量或函数。
extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候,如下所示:
第一个文件:main.cpp
#include <iostream>
int count ;
extern void write_extern();
int main()
{
count = 5;
write_extern();
}
第二个文件:support.cpp
#include <iostream>
extern int count;
void write_extern(void)
{
std::cout << "Count is " << count << std::endl;
}
在这里,第二个文件中的 extern 关键字用于声明已经在第一个文件 main.cpp 中定义的 count。现在 ,编译这两个文件,如下所示:
$ g++ main.cpp support.cpp -o write
这会产生 write 可执行程序,尝试执行 write,它会产生下列结果:
$ ./write
Count is 5
- mutable 存储类
mutable 说明符仅适用于类的对象,这将在本教程的最后进行讲解。它允许对象的成员替代常量。也就是说,mutable 成员可以通过 const 成员函数修改。
- thread_local 存储类
使用 thread_local 说明符声明的变量仅可在它在其上创建的线程上访问。 变量在创建线程时创建,并在销毁线程时销毁。 每个线程都有其自己的变量副本。
thread_local 说明符可以与 static 或 extern 合并。
可以将 thread_local 仅应用于数据声明和定义,thread_local 不能用于函数声明或定义。
以下演示了可以被声明为 thread_local 的变量:
thread_local int x; // 命名空间下的全局变量
class X
{
static thread_local std::string s; // 类的static成员变量
};
static thread_local std::string X::s; // X::s 是需要定义的
void foo()
{
thread_local std::vector<int> v; // 本地变量
}
2.1.6 类型转换
类型转换是将一个数据类型的值转换为另一种数据类型的值。
C++ 中有四种类型转换:静态转换、动态转换、常量转换和重新解释转换。
- 静态转换(Static Cast)
静态转换是将一种数据类型的值强制转换为另一种数据类型的值。
静态转换通常用于比较类型相似的对象之间的转换,例如将 int 类型转换为 float 类型。
静态转换不进行任何运行时类型检查,因此可能会导致运行时错误。
#include <iostream>
using namespace std;
int main(){
int i = 10;
float f = static_cast<float>(i); // 静态将int类型转换为float类型
cout<<f<<endl;
}
- 动态转换(Dynamic Cast)
动态转换通常用于将一个基类指针或引用转换为派生类指针或引用。动态转换在运行时进行类型检查,如果不能进行转换则返回空指针或引发异常。
class Base {};
class Derived : public Base {};
Base* ptr_base = new Derived;
Derived* ptr_derived = dynamic_cast<Derived*>(ptr_base); // 将基类指针转换为派生类指针
- 常量转换(Const Cast)
常量转换用于将 const 类型的对象转换为非 const 类型的对象。
常量转换只能用于转换掉 const 属性,不能改变对象的类型。
const int i = 10;
int& r = const_cast<int&>(i); // 常量转换,将const int转换为int
- 重新解释转换(Reinterpret Cast)
重新解释转换将一个数据类型的值重新解释为另一个数据类型的值,通常用于在不同的数据类型之间进行转换。
重新解释转换不进行任何类型检查,因此可能会导致未定义的行为。
int i = 10;
float f = reinterpret_cast<float&>(i); // 重新解释将int类型转换为float类型
2.2 常量
常量是固定值,在程序执行期间不会改变。这些固定的值,又叫做字面常量、直接常量。常量可以是任何的基本数据类型,可分为整型数字、浮点数字、字符、字符串和布尔值。
常量就像是常规的变量,只不过常量的值在定义后不能进行修改。常量包括两大类:数值型常量(即常数)和字符型常量。
2.2.1 数值常量
- 整数常量
整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数:0x 或 0X 表示十六进制,0 表示八进制,不带前缀则默认表示十进制。
整数常量也可以带一个后缀,后缀是 U 和 L 的组合,U 表示无符号整数(unsigned),L 表示长整数(long)。后缀可以是大写,也可以是小写,U 和 L 的顺序任意。
下面列举几个整数常量的实例:
212 // 合法的
215u // 合法的
0xFeeL // 合法的
078 // 非法的:8 不是八进制的数字
032UU // 非法的:不能重复后缀
以下是各种类型的整数常量的实例:
85 // 十进制
0213 // 八进制
0x4b // 十六进制
30 // 整数
30u // 无符号整数
30l // 长整数
30ul // 无符号长整数
- 浮点常量
浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。
当使用小数形式表示时,必须包含整数部分、小数部分,或同时包含两者。当使用指数形式表示时, 必须包含小数点、指数,或同时包含两者。带符号的指数是用 e 或 E 引入的。
下面列举几个浮点常量的实例:
3.14159 // 合法的
314159E-5L // 合法的
510E // 非法的:不完整的指数
210f // 非法的:没有小数或指数
.e55 // 非法的:缺少整数或分数
- 布尔常量
布尔常量共有两个,它们都是标准的 C++ 关键字:
- true 值代表真。
- false 值代表假。
我们不应把 true 的值看成 1,把 false 的值看成 0。
- 字符常量
字符常量是括在单引号中。如果常量以 L(仅当大写时)开头,则表示它是一个宽字符常量(例如 L’x’),此时它必须存储在 wchar_t 类型的变量中。否则,它就是一个窄字符常量(例如 ‘x’),此时它可以存储在 char 类型的简单变量中。
字符常量可以是一个普通的字符(例如 ‘x’)、一个转义序列(例如 ‘\t’),或一个通用的字符(例如 ‘\u02C0’)。
在 C++ 中,有一些特定的字符,当它们前面有反斜杠时,它们就具有特殊的含义,被用来表示如换行符(\n)或制表符(\t)等。下表列出了一些这样的转义序列码:
转义序列 | 含义 |
---|---|
\ | \ 字符 |
’ | ’ 字符 |
" | " 字符 |
? | ? 字符 |
\a | 警报铃声 |
\b | 退格键 |
\f | 换页符 |
\n | 换行符 |
\r | 回车 |
\t | 水平制表符 |
\v | 垂直制表符 |
\ooo | 一到三位的八进制数 |
\xhh . . . | 一个或多个数字的十六进制数 |
下面的实例显示了一些转义序列字符:
#include <iostream>
using namespace std;
int main()
{
cout << "Hello\tWorld\n\n";
return 0;
}
当上面的代码被编译和执行时,它会产生下列结果:
Hello World
- 字符串常量
字符串字面值或常量是括在双引号 ""
中的。一个字符串包含类似于字符常量的字符:普通的字符、转义序列和通用的字符。
您可以使用 \ 做分隔符,把一个很长的字符串常量进行分行。
下面的实例显示了一些字符串常量:
#include <iostream>
#include <string>
using namespace std;int main()
{
string greeting = "hello, runoob";
cout << greeting;
cout << "**\n**"; // 换行符
string greeting2 = "hello, **\** runoob";
cout << greeting2;
return 0;
}
hello, runoob
hello, runoob
- 定义常量
在 C++ 中,有两种简单的定义常量的方式:
使用 #define 预处理器。
使用 const 关键字。
#define
预处理器
下面是使用 #define 预处理器定义常量的形式:
#define identifier value
具体请看下面的实例:
#include <iostream>
using namespace std;
#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'
int main()
{
int area;
area = LENGTH * WIDTH;
cout << area;
cout << NEWLINE;
return 0;
}
当上面的代码被编译和执行时,它会产生下列结果:
50
- const 关键字
您可以使用 const 前缀声明指定类型的常量,如下所示:
const type variable = value;
具体请看下面的实例:
#include <iostream>
using namespace std;
int main()
{
const int LENGTH = 10;
const int WIDTH = 5;
const char NEWLINE = '\n';
int area;
area = LENGTH * WIDTH;
cout << area;
cout << NEWLINE;
return 0;
}
当上面的代码被编译和执行时,它会产生下列结果:
50
请注意,把常量定义为大写字母形式,是一个很好的编程实践。
2.3 变量
2.3.1 什么是变量
在程序执行期间其值可以改变的量称为变量。一个变量应该有一个名字,并在内存中占据一定的存储单元,在改存储单元中存放变量的值。
变量其实只不过是程序可操作的存储区的名称。C++ 中每个变量都有指定的类型,类型决定了变量存储的大小和布局,该范围内的值都可以存储在内存中,运算符可应用于变量上。
2.3.2 变量名命名规则
变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写字母和小写字母是不同的,因为 C++ 是大小写敏感的。
C++ 也允许定义各种其他类型的变量,比如枚举、指针、数组、引用、数据结构、类等等
- 驼峰式
char MyName = "张三";
- 下划线
char my_name = "张三";
2.3.3 C++ 中的变量定义
在C++语言中,要求对所有用到的变量做强制定义,也就是必须“先定义,后使用”,
变量定义就是告诉编译器在何处创建变量的存储,以及如何创建变量的存储。变量定义指定一个数据类型,并包含了该类型的一个或多个变量的列表,如下所示:
type variable_list;
在这里,type 必须是一个有效的 C++ 数据类型,可以是 char、wchar_t、int、float、double、bool 或任何用户自定义的对象,variable_list 可以由一个或多个标识符名称组成,多个标识符之间用逗号分隔。下面列出几个有效的声明:
int i, j, k;
char c, ch;
float f, salary;
double d;
行 int i, j, k; 声明并定义了变量 i、j 和 k,这指示编译器创建类型为 int 的名为 i、j、k 的变量。
变量可以在声明的时候被初始化(指定一个初始值)。初始化器由一个等号,后跟一个常量表达式组成,如下所示:
type variable_name = value;
下面列举几个实例:
extern int d = 3, f = 5; // d 和 f 的声明
int d = 3, f = 5; // 定义并初始化 d 和 f
byte z = 22; // 定义并初始化 z
char x = 'x'; // 变量 x 的值为 'x'
不带初始化的定义:带有静态存储持续时间的变量会被隐式初始化为 NULL(所有字节的值都是 0),其他所有变量的初始值是未定义的。
2.3.4 C++ 中的变量声明
变量声明向编译器保证变量以给定的类型和名称存在,这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义,在程序连接时编译器需要实际的变量声明。
当您使用多个文件且只在其中一个文件中定义变量时(定义变量的文件在程序连接时是可用的),变量声明就显得非常有用。您可以使用 extern 关键字在任何地方声明一个变量。虽然您可以在 C++ 程序中多次声明一个变量,但变量只能在某个文件、函数或代码块中被定义一次。
尝试下面的实例,其中,变量在头部就已经被声明,但它们是在主函数内被定义和初始化的:
#include <iostream>
using namespace std;
// 变量声明
extern int a, b;
extern int c;
extern float f;
int main ()
{
// 变量定义
int a, b;
int c;
float f;
// 实际初始化
a = 10;
b = 20;
c = a + b;
cout << c << endl ;
f = 70.0/3.0;
cout << f << endl ;
return 0;
}
当上面的代码被编译和执行时,它会产生下列结果:
30
23.3333
同样的,在函数声明时,提供一个函数名,而函数的实际定义则可以在任何地方进行。例如:
// 函数声明
int func();
int main()
{
// 函数调用
int i = func();
}
// 函数定义
int func()
{
return 0;
}
2.3.5 C++ 中的左值(Lvalues)和右值(Rvalues)
C++ 中有两种类型的表达式:
- **左值(lvalue):**指向内存位置的表达式被称为左值(lvalue)表达式。左值可以出现在赋值号的左边或右边。
- **右值(rvalue):**术语右值(rvalue)指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式,也就是说,右值可以出现在赋值号的右边,但不能出现在赋值号的左边。
变量是左值,因此可以出现在赋值号的左边。数值型的字面值是右值,因此不能被赋值,不能出现在赋值号的左边。下面是一个有效的语句:
int g = 20;
但是下面这个就不是一个有效的语句,会生成编译时错误:
10 = 20;
2.4 C++ 变量作用域
一般来说有三个地方可以定义变量:
- 在函数或一个代码块内部声明的变量,称为局部变量。
- 在函数参数的定义中声明的变量,称为形式参数。
- 在所有函数外部声明的变量,称为全局变量。
作用域是程序的一个区域,变量的作用域可以分为以下几种:
- 局部作用域:在函数内部声明的变量具有局部作用域,它们只能在函数内部访问。局部变量在函数每次被调用时被创建,在函数执行完后被销毁。
- 全局作用域:在所有函数和代码块之外声明的变量具有全局作用域,它们可以被程序中的任何函数访问。全局变量在程序开始时被创建,在程序结束时被销毁。
- 块作用域:在代码块内部声明的变量具有块作用域,它们只能在代码块内部访问。块作用域变量在代码块每次被执行时被创建,在代码块执行完后被销毁。
- 类作用域:在类内部声明的变量具有类作用域,它们可以被类的所有成员函数访问。类作用域变量的生命周期与类的生命周期相同。
**注意:**如果在内部作用域中声明的变量与外部作用域中的变量同名,则内部作用域中的变量将覆盖外部作用域中的变量。
2.4.1 局部变量
在函数或一个代码块内部声明的变量,称为局部变量。它们只能被函数内部或者代码块内部的语句使用。下面的实例使用了局部变量:
#include <iostream>
using namespace std;
int main ()
{
// 局部变量声明
int a, b;
int c;
// 实际初始化
a = 10;
b = 20;
c = a + b;
cout << c;
return 0;
}
2.4.2 全局变量
在所有函数外部定义的变量(通常是在程序的头部),称为全局变量。全局变量的值在程序的整个生命周期内都是有效的。
全局变量可以被任何函数访问。也就是说,全局变量一旦声明,在整个程序中都是可用的。下面的实例使用了全局变量和局部变量:
#include <iostream>
using namespace std;
// 全局变量声明
int g;
int main ()
{
// 局部变量声明
int a, b;
// 实际初始化
a = 10;
b = 20;
g = a + b;
cout << g;
return 0;
}
在程序中,局部变量和全局变量的名称可以相同,但是在函数内,局部变量的值会覆盖全局变量的值。下面是一个实例:
#include <iostream>
using namespace std;
// 全局变量声明
int g = 20;
int main ()
{
// 局部变量声明
int g = 10;
cout << g;
return 0;
}
当上面的代码被编译和执行时,它会产生下列结果:
10
2.4.3 初始化局部变量和全局变量
当局部变量被定义时,系统不会对其初始化,您必须自行对其初始化。定义全局变量时,系统会自动初始化为下列值:
数据类型 | 初始化默认值 |
---|---|
int | 0 |
char | ‘\0’ |
float | 0 |
double | 0 |
pointer | NULL |
正确地初始化变量是一个良好的编程习惯,否则有时候程序可能会产生意想不到的结果。
块作用域指的是在代码块内部声明的变量:
#include <iostream>
int main() {
int a = 10;
{
int a = 20; // 块作用域变量
std::cout << "块变量: " << a << std::endl;
}
std::cout << "外部变量: " << a << std::endl;
return 0;
}
以上实例中,内部的代码块中声明了一个名为 a 的变量,它与外部作用域中的变量 a 同名。内部作用域中的变量 a 将覆盖外部作用域中的变量 a,在内部作用域中访问 a 时输出的是20,而在外部作用域中访问 a 时输出的是 10。
当上面的代码被编译和执行时,它会产生下列结果:
块变量: 20
外部变量: 10
- 类作用域
类作用域指的是在类内部声明的变量:
#include <iostream>
class MyClass {
public:
static int class_var; // 类作用域变量
};
int MyClass::class_var = 30;
int main() {
std::cout << "类变量: " << MyClass::class_var << std::endl;
return 0;
}
以上实例中,MyClass 类中声明了一个名为 class_var 的类作用域变量。可以使用类名和作用域解析运算符 :: 来访问这个变量。在 main() 函数中访问 class_var 时输出的是 30。
类变量: 30
2.5 运算符
运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C++ 内置了丰富的运算符,并提供了以下类型的运算符:
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
- 杂项运算符
本章将逐一介绍算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和其他运算符。
2.5.1 算术运算符
- 基础算术运算符
下表显示了 C++ 支持的算术运算符。
假设变量 A 的值为 10,变量 B 的值为 20,则:
运算符 | 描述 | 实例 |
---|---|---|
+ | 把两个操作数相加 | A + B 将得到 30 |
- | 从第一个操作数中减去第二个操作数 | A - B 将得到 -10 |
* | 把两个操作数相乘 | A * B 将得到 200 |
/ | 分子除以分母;如果两个类型都为整型则只去整数部分,舍弃小数部分。 | B / A 将得到 2 |
% | 取模运算符,整除后的余数 | B % A 将得到 0 |
#include <iostream>
using namespace std;
int main()
{
int a = 21;
int b = 10;
int c;
c = a + b;
cout << "Line 1 - c 的值是 " << c << endl ;
c = a - b;
cout << "Line 2 - c 的值是 " << c << endl ;
c = a * b;
cout << "Line 3 - c 的值是 " << c << endl ;
c = a / b;
cout << "Line 4 - c 的值是 " << c << endl ;
c = a % b;
cout << "Line 5 - c 的值是 " << c << endl ;
int d = 10; // 测试自增、自减
c = d++;
cout << "Line 6 - c 的值是 " << c << endl ;
d = 10; // 重新赋值
c = d--;
cout << "Line 7 - c 的值是 " << c << endl ;
return 0;
}
当上面的代码被编译和执行时,它会产生以下结果:
Line 1 - c 的值是 31
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 10
Line 7 - c 的值是 10
- 自增(++)和自减(—)运算符
在C++中,常在表达式中使用自增(++)和自减(- -)运算符,他们的作用是是变量的值增加1或减1。
正确的使用自增和自减可以是程序简洁、清晰、高效。
运算符 | 描述 | 实例 |
---|---|---|
++ | 自增运算符,整数值增加 1 | A++ 将得到 11 |
– | 自减运算符,整数值减少 1 | A-- 将得到 9 |
++i
在使用i之前,先使i的值加1,如果i的原值为3,则执行j=++i后,j的值为4。
–i
在使用i之前,先使i的值减1,如果i的原值为3,则执行j=- -i后,j的值为2。
i++
在使用i之后,使i的值加1,如果i的原值为3,则执行j=i++后,j的值为3,i为4。
i- -
在使用i之后,使i的值减1,如果i的原值为3,则执行j=i- -后,j的值为3,i为2。
2.5.2 关系运算符
下表显示了 C++ 支持的关系运算符。
假设变量 A 的值为 10,变量 B 的值为 20,则:
运算符 | 描述 | 实例 |
---|---|---|
== | 检查两个操作数的值是否相等,如果相等则条件为真。 | (A == B) 不为真。 |
!= | 检查两个操作数的值是否相等,如果不相等则条件为真。 | (A != B) 为真。 |
> | 检查左操作数的值是否大于右操作数的值,如果是则条件为真。 | (A > B) 不为真。 |
< | 检查左操作数的值是否小于右操作数的值,如果是则条件为真。 | (A < B) 为真。 |
>= | 检查左操作数的值是否大于或等于右操作数的值,如果是则条件为真。 | (A >= B) 不为真。 |
<= | 检查左操作数的值是否小于或等于右操作数的值,如果是则条件为真。 | (A <= B) 为真。 |
#include <iostream>
using namespace std;
int main()
{
int a = 21;
int b = 10;
int c ;
if( a == b )
{
cout << "Line 1 - a 等于 b" << endl ;
}
else
{
cout << "Line 1 - a 不等于 b" << endl ;
}
if ( a < b )
{
cout << "Line 2 - a 小于 b" << endl ;
}
else
{
cout << "Line 2 - a 不小于 b" << endl ;
}
if ( a > b )
{
cout << "Line 3 - a 大于 b" << endl ;
}
else
{
cout << "Line 3 - a 不大于 b" << endl ;
}
/* 改变 a 和 b 的值 */
a = 5;
b = 20;
if ( a <= b )
{
cout << "Line 4 - a 小于或等于 b" << endl ;
}
if ( b >= a )
{
cout << "Line 5 - b 大于或等于 a" << endl ;
}
return 0;
}
当上面的代码被编译和执行时,它会产生以下结果:
Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 a
2.5.3 逻辑运算符
下表显示了 C++ 支持的关系逻辑运算符。
假设变量 A 的值为 1,变量 B 的值为 0,则:
运算符 | 描述 | 实例 |
---|---|---|
&& | 称为逻辑与运算符。如果两个操作数都 true,则条件为 true。 | (A && B) 为 false。 |
|| | 称为逻辑或运算符。如果两个操作数中有任意一个 true,则条件为 true。 | (A || B) 为 true。 |
! | 称为逻辑非运算符。用来逆转操作数的逻辑状态,如果条件为 true 则逻辑非运算符将使其为 false。 | !(A && B) 为 true。 |
#include <iostream>
using namespace std;
int main()
{
int a = 5;
int b = 20;
int c ;
if ( a && b )
{
cout << "Line 1 - 条件为真"<< endl ;
}
if ( a || b )
{
cout << "Line 2 - 条件为真"<< endl ;
}
/* 改变 a 和 b 的值 */
a = 0;
b = 10;
if ( a && b )
{
cout << "Line 3 - 条件为真"<< endl ;
}
else
{
cout << "Line 4 - 条件不为真"<< endl ;
}
if ( !(a && b) )
{
cout << "Line 5 - 条件为真"<< endl ;
}
return 0;
}
当上面的代码被编译和执行时,它会产生以下结果:
Line 1 - 条件为真
Line 2 - 条件为真
Line 4 - 条件不为真
Line 5 - 条件为真
2.5.4 位运算符
位运算符作用于位,并逐位执行操作。&、 | 和 ^ 的真值表如下所示:
p | q | p & q | p | q | p ^ q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
假设如果 A = 60,且 B = 13,现在以二进制格式表示,它们如下所示:
A = 0011 1100
B = 0000 1101
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
下表显示了 C++ 支持的位运算符。假设变量 A 的值为 60,变量 B 的值为 13,则:
运算符 | 描述 | 实例 |
---|---|---|
& | 按位与操作,按二进制位进行"与"运算。运算规则:0&0=0;0&1=0;1&0=0;1&1=1; | (A & B) 将得到 12,即为 0000 1100 |
| | 按位或运算符,按二进制位进行"或"运算。运算规则:0|0=0; 0|1=1;1|0=1;1|1=1; | (A | B) 将得到 61,即为 0011 1101 |
^ | 异或运算符,按二进制位进行"异或"运算。运算规则:0^0=0;0^1=1;1^0=1;1^1=0; | (A ^ B) 将得到 49,即为 0011 0001 |
~ | 取反运算符,按二进制位进行"取反"运算。运算规则:~1=-2;~0=-1; | (~A ) 将得到 -61,即为 1100 0011,一个有符号二进制数的补码形式。 |
<< | 二进制左移运算符。将一个运算对象的各二进制位全部左移若干位(左边的二进制位丢弃,右边补0)。 | A << 2 将得到 240,即为 1111 0000 |
>> | 二进制右移运算符。将一个数的各二进制位全部右移若干位,正数左补0,负数左补1,右边丢弃。 | A >> 2 将得到 15,即为 0000 1111 |
请看下面的实例,了解 C++ 中可用的位运算符。
#include <iostream>
using namespace std;
int main()
{
unsigned int a = 60; // 60 = 0011 1100
unsigned int b = 13; // 13 = 0000 1101
int c = 0;
c = a & b; // 12 = 0000 1100
cout << "Line 1 - c 的值是 " << c << endl ;
c = a | b; // 61 = 0011 1101
cout << "Line 2 - c 的值是 " << c << endl ;
c = a ^ b; // 49 = 0011 0001
cout << "Line 3 - c 的值是 " << c << endl ;
c = ~a; // -61 = 1100 0011
cout << "Line 4 - c 的值是 " << c << endl ;
c = a << 2; // 240 = 1111 0000
cout << "Line 5 - c 的值是 " << c << endl ;
c = a >> 2; // 15 = 0000 1111
cout << "Line 6 - c 的值是 " << c << endl ;
return 0;
}
当上面的代码被编译和执行时,它会产生以下结果:
Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15
2.5.5 赋值运算符
下表列出了 C++ 支持的赋值运算符:
运算符 | 描述 | 实例 |
---|---|---|
= | 简单的赋值运算符,把右边操作数的值赋给左边操作数 | C = A + B 将把 A + B 的值赋给 C |
+= | 加且赋值运算符,把右边操作数加上左边操作数的结果赋值给左边操作数 | C += A 相当于 C = C + A |
-= | 减且赋值运算符,把左边操作数减去右边操作数的结果赋值给左边操作数 | C -= A 相当于 C = C - A |
*= | 乘且赋值运算符,把右边操作数乘以左边操作数的结果赋值给左边操作数 | C *= A 相当于 C = C * A |
/= | 除且赋值运算符,把左边操作数除以右边操作数的结果赋值给左边操作数 | C /= A 相当于 C = C / A |
%= | 求模且赋值运算符,求两个操作数的模赋值给左边操作数 | C %= A 相当于 C = C % A |
<<= | 左移且赋值运算符 | C <<= 2 等同于 C = C << 2 |
>>= | 右移且赋值运算符 | C >>= 2 等同于 C = C >> 2 |
&= | 按位与且赋值运算符 | C &= 2 等同于 C = C & 2 |
^= | 按位异或且赋值运算符 | C ^= 2 等同于 C = C ^ 2 |
|= | 按位或且赋值运算符 | C |= 2 等同于 C = C | 2 |
#include <iostream>
using namespace std;
int main()
{
int a = 21;
int c ;
c = a;
cout << "Line 1 - = 运算符实例,c 的值 = : " <<c<< endl ;
c += a;
cout << "Line 2 - += 运算符实例,c 的值 = : " <<c<< endl ;
c -= a;
cout << "Line 3 - -= 运算符实例,c 的值 = : " <<c<< endl ;
c *= a;
cout << "Line 4 - *= 运算符实例,c 的值 = : " <<c<< endl ;
c /= a;
cout << "Line 5 - /= 运算符实例,c 的值 = : " <<c<< endl ;
c = 200;
c %= a;
cout << "Line 6 - %= 运算符实例,c 的值 = : " <<c<< endl ;
c <<= 2;
cout << "Line 7 - <<= 运算符实例,c 的值 = : " <<c<< endl ;
c >>= 2;
cout << "Line 8 - >>= 运算符实例,c 的值 = : " <<c<< endl ;
c &= 2;
cout << "Line 9 - &= 运算符实例,c 的值 = : " <<c<< endl ;
c ^= 2;
cout << "Line 10 - ^= 运算符实例,c 的值 = : " <<c<< endl ;
c |= 2;
cout << "Line 11 - |= 运算符实例,c 的值 = : " <<c<< endl ;
return 0;
}
当上面的代码被编译和执行时,它会产生以下结果:
Line 1 - = 运算符实例,c 的值 = 21
Line 2 - += 运算符实例,c 的值 = 42
Line 3 - -= 运算符实例,c 的值 = 21
Line 4 - *= 运算符实例,c 的值 = 441
Line 5 - /= 运算符实例,c 的值 = 21
Line 6 - %= 运算符实例,c 的值 = 11
Line 7 - <<= 运算符实例,c 的值 = 44
Line 8 - >>= 运算符实例,c 的值 = 11
Line 9 - &= 运算符实例,c 的值 = 2
Line 10 - ^= 运算符实例,c 的值 = 0
Line 11 - |= 运算符实例,c 的值 = 2
2.5.6 杂项运算符
下表列出了 C++ 支持的其他一些重要的运算符。
运算符 | 描述 |
---|---|
sizeof | sizeof运算符返回变量的大小。例如,sizeof(a) 将返回 4,其中 a 是整数。 |
Condition ? X : Y | 条件运算符。如果 Condition 为真 ? 则值为 X : 否则值为 Y。 |
, | 逗号运算符会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。 |
.(点)和 ->(箭头) | 成员运算符用于引用类、结构和共用体的成员。 |
Cast | 强制转换运算符把一种数据类型转换为另一种数据类型。例如,int(2.2000) 将返回 2。 |
& | 指针运算符& 返回变量的地址。例如 &a; 将给出变量的实际地址。 |
* | 指针运算符* 指向一个变量。例如,*var; 将指向变量 var。 |
1. sizeof运算符
sizeof
是一个关键字,它是一个编译时运算符,用于判断变量或数据类型的字节大小。
sizeof
运算符可用于获取类、结构、共用体和其他用户自定义数据类型的大小。
使用 sizeof
的语法如下:
sizeof (data type)
其中,data
、 type
是要计算大小的数据类型,包括类、结构、共用体和其他用户自定义数据类型。
请尝试下面的实例,理解 C++ 中 sizeof
的用法。
#include <iostream>
using namespace std;
int main()
{
cout << "Size of char : " << sizeof(char) << endl;
cout << "Size of int : " << sizeof(int) << endl;
cout << "Size of short int : " << sizeof(short int) << endl;
cout << "Size of long int : " << sizeof(long int) << endl;
cout << "Size of float : " << sizeof(float) << endl;
cout << "Size of double : " << sizeof(double) << endl;
cout << "Size of wchar_t : " << sizeof(wchar_t) << endl;
return 0;
}
当上面的代码被编译和执行时,它会产生下列结果,结果会根据使用的机器而不同:
Size of char : 1
Size of int : 4
Size of short int : 2
Size of long int : 4
Size of float : 4
Size of double : 8
Size of wchar_t : 4
2.条件运算符
Exp1 ? Exp2 : Exp3;
其中,Exp1、Exp2 和 Exp3 是表达式。请注意冒号的使用和位置。? : 表达式的值取决于 Exp1 的计算结果。如果 Exp1 为真,则计算 Exp2 的值,且 Exp2 的计算结果则为整个 ? : 表达式的值。如果 Exp1 为假,则计算 Exp3 的值,且 Exp3 的计算结果则为整个 ? : 表达式的值。
? 被称为三元运算符,因为它需要三个操作数,可以用来代替如下所示的 if-else 语句:
if(condition){
var = X;
}else{
var = Y;
}
例如,请看下面这段代码:
if(y < 10){
var = 30;
}else{
var = 40;
}
上面的代码可以写成以下语句:
var = (y < 10) ? 30 : 40;
在这里,如果 y 小于 10,则 var 被赋值为 30,如果 y 不小于 10,则 var 被赋值为 40。请看下面的实例:
#include <iostream>
using namespace std;
int main ()
{
// 局部变量声明
int x, y = 10;
x = (y < 10) ? 30 : 40;
cout << "value of x: " << x << endl;
return 0;
}
当上面的代码被编译和执行时,它会产生下列结果:
value of x: 40
3.逗号运算符
使用逗号运算符是为了把几个表达式放在一起。整个逗号表达式的值为系列中最后一个表达式的值。
从本质上讲,逗号的作用是将一系列运算按顺序执行。
表达式1, 表达式2
求解过程是:先求解表达式 1,再求解表达式 2。整个逗号表达式的值是表达式 2 的值。
最右边的那个表达式的值将作为整个逗号表达式的值,其他表达式的值会被丢弃。
例如:
var = (count=19, incr=10, count+1);
在这里,首先把 count 赋值为 19,把 incr 赋值为 10,然后把 count 加 1,最后,把最右边表达式 count+1 的计算结果 20 赋给 var。上面表达式中的括号是必需的,因为逗号运算符的优先级低于赋值操作符。
尝试运行下面的实例,理解逗号运算符的用法。
#include <iostream>
using namespace std;
int main()
{
int i, j;
j = 10;
i = (j++, j+100, 999+j);
cout << i;
return 0;
}
当上面的代码被编译和执行时,它会产生下列结果:
1010
上面的程序中,j 最初的值为 10,然后自增到 11,这时 j 的值就为 11,然后再计算第二个表达式 j+100,最后 j(j 为 11) 再加上 999,最后 i 为 最后一个表达式的值 999+j,及 999+ 11=1010。
4.成员运算符
.(点)运算符和 ->(箭头)运算符用于引用类、结构和共用体的成员。
点运算符应用于实际的对象。箭头运算符与一个指向对象的指针一起使用。例如,假设有下面的结构:
struct Employee {
char first_name[16];
int age;
} emp;
(.)点运算符
下面的代码把值 “zara” 赋给对象 emp 的 first_name 成员:
strcpy(emp.first_name, "zara");
(->)箭头运算符
如果 p_emp 是一个指针,指向类型为 Employee 的对象,则要把值 “zara” 赋给对象 emp 的 first_name 成员,需要编写如下代码:
strcpy(p_emp->first_name, "zara");
-> 称为箭头运算符,它是由一个减号加上一个大于号组成。
简而言之,访问结构的成员时使用点运算符,而通过指针访问结构的成员时,则使用箭头运算符。
5.强制装换运算符
强制转换运算符是一种特殊的运算符,它把一种数据类型转换为另一种数据类型。强制转换运算符是一元运算符,它的优先级与其他一元运算符相同。
大多数的 C++ 编译器都支持大部分通用的强制转换运算符:
(type) expression
其中,type 是转换后的数据类型。下面列出了 C++ 支持的其他几种强制转换运算符:
-
const_cast (expr): const_cast 运算符用于修改类型的 const / volatile 属性。除了 const 或 volatile 属性之外,目标类型必须与源类型相同。这种类型的转换主要是用来操作所传对象的 const 属性,可以加上 const 属性,也可以去掉 const 属性。
-
dynamic_cast (expr): dynamic_cast 在运行时执行转换,验证转换的有效性。如果转换未执行,则转换失败,表达式 expr 被判定为 null。dynamic_cast 执行动态转换时,type 必须是类的指针、类的引用或者 void*,如果 type 是类指针类型,那么 expr 也必须是一个指针,如果 type 是一个引用,那么 expr 也必须是一个引用。
-
reinterpret_cast (expr): reinterpret_cast 运算符把某种指针改为其他类型的指针。它可以把一个指针转换为一个整数,也可以把一个整数转换为一个指针。
-
static_cast (expr): static_cast 运算符执行非动态转换,没有运行时类检查来保证转换的安全性。例如,它可以用来把一个基类指针转换为派生类指针。
上述所有的强制转换运算符在使用类和对象时会用到。现在,请看下面的实例,理解 C++ 中如何使用一个简单的强制转换运算符。复制并黏贴下面的 C++ 程序到 test.cpp 文件中,编译并运行程序。
#include <iostream>
using namespace std;
int main()
{
double a = 21.09399;
float b = 10.20;
int c ;
c = (int) a;
cout << "Line 1 - Value of (int)a is :" << c << endl ;
c = (int) b;
cout << "Line 2 - Value of (int)b is :" << c << endl ;
return 0;
}
当上面的代码被编译和执行时,它会产生下列结果:
Line 1 - Value of (int)a is :21
Line 2 - Value of (int)b is :10
6.指针运算符& 、*
C++ 提供了两种指针运算符,一种是取地址运算符 &,一种是间接寻址运算符 *。
指针是一个包含了另一个变量地址的变量,您可以把一个包含了另一个变量地址的变量说成是"指向"另一个变量。变量可以是任意的数据类型,包括对象、结构或者指针。
- 取地址运算符 &
& 是一元运算符,返回操作数的内存地址。例如,如果 var 是一个整型变量,则 &var 是它的地址。该运算符与其他一元运算符具有相同的优先级,在运算时它是从右向左顺序进行的。
您可以把 & 运算符读作"取地址运算符",这意味着,&var 读作"var 的地址"。
- 间接寻址运算符 *
第二个运算符是间接寻址运算符 ,它是 & 运算符的补充。 是一元运算符,返回操作数所指定地址的变量的值。
请看下面的实例,理解这两种运算符的用法。
#include <iostream>
using namespace std;
int main ()
{
int var;
int *ptr;
int val;
var = 3000;
// 获取 var 的地址
ptr = &var;
// 获取 ptr 的值
val = *ptr;
cout << "Value of var :" << var << endl;
cout << "Value of ptr :" << ptr << endl;
cout << "Value of val :" << val << endl;
return 0;
}
当上面的代码被编译和执行时,它会产生下列结果:
Value of var :3000
Value of ptr :0xbff64494
Value of val :3000
2.5.6 C++ 中的运算符优先级
运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级,例如,乘除运算符具有比加减运算符更高的优先级。
例如 x = 7 + 3 * 2,在这里,x 被赋值为 13,而不是 20,因为运算符 * 具有比 + 更高的优先级,所以首先计算乘法 3*2,然后再加上 7。
下表将按运算符优先级从高到低列出各个运算符,具有较高优先级的运算符出现在表格的上面,具有较低优先级的运算符出现在表格的下面。在表达式中,较高优先级的运算符会优先被计算。
类别 | 运算符 | 结合性 |
---|---|---|
后缀 | () [] -> . ++ - - | 从左到右 |
一元 | + - ! ~ ++ - - (type)* & sizeof | 从右到左 |
乘除 | * / % | 从左到右 |
加减 | + - | 从左到右 |
移位 | << >> | 从左到右 |
关系 | < <= > >= | 从左到右 |
相等 | == != | 从左到右 |
位与 AND | & | 从左到右 |
位异或 XOR | ^ | 从左到右 |
位或 OR | | | 从左到右 |
逻辑与 AND | && | 从左到右 |
逻辑或 OR | || | 从左到右 |
条件 | ?: | 从右到左 |
赋值 | = += -= *= /= %=>>= <<= &= ^= | = |
逗号 | , | 从左到右 |
请看下面的实例,了解 C++ 中运算符的优先级。
对比有括号和没有括号时的区别,这将产生不同的结果。因为 ()、 /、 * 和 + 有不同的优先级,高优先级的操作符将优先计算。
#include <iostream>
using namespace std;
int main()
{
int a = 20;
int b = 10;
int c = 15;
int d = 5;
int e;
e = (a + b) * c / d; // ( 30 * 15 ) / 5
cout << "(a + b) * c / d 的值是 " << e << endl ;
e = ((a + b) * c) / d; // (30 * 15 ) / 5
cout << "((a + b) * c) / d 的值是 " << e << endl ;
e = (a + b) * (c / d); // (30) * (15/5)
cout << "(a + b) * (c / d) 的值是 " << e << endl ;
e = a + (b * c) / d; // 20 + (150/5)
cout << "a + (b * c) / d 的值是 " << e << endl ;
return 0;
}
当上面的代码被编译和执行时,它会产生以下结果:
(a + b) * c / d 的值是 90
((a + b) * c) / d 的值是 90
(a + b) * (c / d) 的值是 90
a + (b * c) / d 的值是 50
2.6 输入输出
2.6.1 输入输出流
在C语言中,输入和输出的功能是通过调用scanf函数和printf函数来实现的,在C++中是通过调用输入输出流库中的流对象cin和cout实现的。也就是说,输入输出不是有C++本身定义的,而是在编译系统提供的I/O库中定义的。
C++的输出和输入是用 “ 流 ” (stream)的方式实现的。“流” 指的是来自设备或传给设备的一个数据流。数据流是由一系列字节组成的,这些字节是按进入“流”的顺序排列的。cout是输出流对象的名字,cin是输入流对象的名字,
“<<”是流插入运算符(也可成流插入操作符),其作用是将需要输出的内容插入到输出流中,磨人的输入设备是显示器。“>>”是流提取运算符,其作用是从默认的输入设备(一般为键盘)的输入流中提取若干个字节送到计算机内存区中指定的变量。
有关流对象cin,cout和流运算符的定义等信息是存放在C++的输入输出流库中的,因此如果在程序中使用cin,cout和流运算符,就必须使用预处理指令文件stream包含到本文件中:
#include <iostream>
从这一点可以看出来,cin和cout不是C++本身提供的语句,因为使用C++本身提供的语句(如赋值语句、if语句、for语句等)时,是不需要用#include指令包含有关头文件的。
尽管cin和cout不是C++本身提供的语句,但是在不致混淆的情况下,为了叙述方便,常常把由cin和流提取运算符“>>”实现输入的语句成为输入语句或cin语句,把cout和流插入运算符“<<”实现输出的语句成为输出语句或cout语句。根据C++的语法,凡是能实现某种操作而且最后以分好结束的都是语句。
2.6.2 输入流与输出流的基本操作
1、cout语句
cout 语句的一般格式为
cout<<表达式1<<表达式2<< ··· <<表达式n;
在定义流对象时,系统会在内存中开辟一段缓冲区,用来暂存输入输出流的数据。在执行cout语句时,并不是插入一个数据就马上输出一个数据,而是先把插入的数据顺序放在输出缓冲区中,知道输出缓冲区满或遇到cout语句中的endl(或‘\n’,ends,flush)为止,此时将缓冲区中已有的数据一起输出,并清空缓冲区。系统提供的标准输出流中的数据想系统默认的设备(一般为显示器)输出。
cout<<"This is a C++ program"<<endl;
cout<<"This is "
<<"a C++"
<<"program"
<<endl;
cout<<"This is ";
cout<<"a C++";
cout<<"program";
cout<<endl;
注意:不能用一个插入运算法“<<”插入多个输出项。
cout<<a,b,c; //错误
cout<<a+b+c; // 正确
2、cin语句
cin 语句的一般格式为
cin>>变量1>>变量2>> ··· >>变量n;
cin>>a>>b>>c>>d;
cin>>a
>>b
>>c
>>d;
cin>>a;
cin>>b;
cin>>c;
cin>>d;
在用cin输入时,系统也会根据变量的类型从输入流中提取相应长度的字节。
#include <iostream>
using namesapce std;
int main(){
char c1,c2;
int a;
float b;
cin>>c1>>c2>>a>>b;
}
1234 56.78
上输入数据后,系统会去第一个字符‘1’给字符变量c1,去第二个字符‘2’给字符变量c2,再去34给正向变量a,最后去56.78给浮点型变量b。
注意:34后面应该有空格以便和56.78分开。
也可以一个数据一个空格,系统会把空格作为数据间的分隔符,不予提取而提取后面一个字符。
1 2 3 4 56.78
由此可知:不能用cin语句吧空格字符和回车换行符作为字符输入给字符变量,他们将被跳过。如果想将空格字符或者回车换行符(或任何其他键盘上的字符)输入给字符变量可以使用getchar函数。
另外在组织输入流数据时,要仔细分析cin语句中变量的类型,按照响应的格式输入,否则容易出错。
3、在标准输入流与输出流中使用控制符
在输入输出时有一些特殊的要求,如在输出浮点数时规定字段宽度,只保留两位小数,数据向左或向右对齐等,C++中提供了在标准输入输出流中使用的控制符(操作符)。
控制符 | 作用 |
---|---|
dec | 设置数值的基础为10 |
hex | 设置数值的基础为16 |
oct | 设置数值的基础为8 |
setfill© | 设置填充字符c,c可以是字符常量或字符变量 |
setprecision(n) | 设置浮点数的精度为n位,在以一般十进制小数形式输出时,n代表有效数字。在以fixed(固定小数位)形式和scientific(指数)形式输出时,n为小数位数 |
setw(n) | 谁知字段宽度为n位 |
setiosflags(ios::fixed) | 设置浮点数以固定的小数位数显示 |
setiosflags(ios::scientific) | 设置浮点数以科学计数法(指数)显示 |
setiosflags(ios::left) | 输出数据左对齐 |
setiosflags(ios::right) | 输出数据右对齐 |
setiosflags(ios::skipws) | 忽略前导的空格 |
setiosflags(ios::uppercase) | 数据以十六进制形式输出时字母以大写表示 |
setiosflags(ios::lowercase) | 数据以十六进制输出时字母以小写表示 |
setiosflags(ios::showpos) | 输出整数时给出“+”号 |
如果使用了控制符,在程序单位的开头除了要加 iostream
头文件外,还要加 iomanip
头文件。
举例 - 输出双精度数
#include <iostream>
#include <iomanip>
using namespace std;
int main() {
double a = 123.456789012345;
// 按默认格式输出(以十进制小数形式输出,全部有效数字为6位)
cout << a << endl;
// 指定输出9位有效数字
cout<<setprecision(9)<<a<<endl;
// 恢复默认格式,精度为6
cout<<setprecision(6); // 恢复默认格式(精度为6)
// 以固定小数位输出,默认输出6位小数
cout<<setiosflags(ios::fixed)<<a<<endl;
// 指定输出8位小数
cout<<setiosflags(ios::fixed)<<setprecision(8)<<a<<endl;
// 指定按质数形式输出,默认给出6位小数(第7位小数四舍五入)
cout<<setiosflags(ios::scientific)<<a<<endl;
// 以质数形式输出,指定4位小数
cout<<setiosflags(ios::scientific)<<setprecision(4)<<a<<endl;
return 0;
}
输出的结果为:
123.457
123.456789
123.456789
123.45678901
0x1.edd3c07fb4c69p+6
0x1.edd3c07fb4c69p+6
举例 - 整数输出
#include <iostream>
#include <iomanip>
using namespace std;
int main() {
int b = 123456;
// 按十进制整数形式输出
cout<<b<<endl;
// 按十六进制整数形式输出,其中字母“e”代表十六进制中的14
cout<<hex<<b<<endl;
// 按十六进制形式输出,字母e改为大写
cout<<setiosflags(ios::uppercase)<<b<<endl;
// 指定字段宽度为10,在123456前面流4个空格,紧接着再输出一次b,但是由于setw只对其后第一个数据其作用,淫才在输出第二个b时setw(10)不起作用,按默认方式输出,前面不留空格
cout<<setw(10)<<b<<','<<b<<endl;
//在输出时用‘*’代替空格。
cout<<setfill('*')<<setw(10)<<b<<endl;
// 在正数前面加一个‘+’好
cout<<setiosflags(ios::showpos)<<b<<endl;
return 0;
}
输出的结果为:
123456
1e240
1E240
1E240,1E240
*****1E240
1E240
小数点对齐
#include <iostream>
#include <iomanip>
using namespace std;
int main(){
double a=123.456,b=3.14159,c=-3214.67;
cout<<setiosflags(ios::fixed)<<setiosflags(ios::right)<<setprecision(2);
cout<<setw(10)<<a<<endl;
cout<<setw(10)<<b<<endl;
cout<<setw(10)<<c<<endl;
return 0;
}
123.46
3.14
-3214.67
2.6.3 用 getchar
和 putchar
函数进行字符的输出和输出
除了可以使用 cin
和 cout
语句输出和输出字符外,c++还保留了C语言中用于输入和输出单个字符的函数,使用很方便。其中最长用的有 getchar
函数和 putchar
函数。
1. putchar函数(字符输出函数)
putchar函数的作用是向终端输出一个字符,
#include <iostream>
using namespace std;
int main(){
char a,b,c;
a = 'B';
b = 'O';
c = 'Y';
putchar(a);putchar(b);putchar(c);putchar('\n');
putchar(66);putchar(79);putchar(89);putchar(10);
return 0;
}
输出结果为:
BOY
BOY
可以看到,用putchar可以输出转义字符,但是我们输出数字打印出来还是字母,这是因为遵循了ASCII码,这里是将所有的字符与字母全部转换成数字形式,当打印数字的时候对应的输出的就是ASCII对应的符号。
2. getchar函数(字符输入函数)
getchar是从终端(或系统隐含指定的输入设备)输入一个字符。getchar函数没有参数。
#include <iostream>
using namespace std;
int main(){
char c;
c = getchar();
putchar(c+32); // +32 可以将大写字母转换为小写字母
putchar('\n');
return 0;
}
注意 : getchar()只能接收一个字符。getchar函数得到的字符可以赋值给一个字符变量或整型变量,也可以不赋值给任何变量,作为表达式的一部分。
putchar(getchar()+32);putchar('\n')
我们还可以通过getchar()来获取一个字符的ASCII码。
#include <iostream>
using namespace std;
int main(){
char c;
cout<<(c = getchar()+32);
}
2.6.4 用scanf和printf函数进行输入和输出
在C语言中是用 printf()
函数进行输出,用 scanf()
函数进行输入的。C++保留了C语言的这一用法。
scanf函数的一般格式:
scanf(格式控制,输出表列)
printf 函数的一般格式:
printf(格式控制,输出表列)
实例
#include <iostream>
using namespace std;
int main(){
int a;
float b;
char c;
scanf("%d %c %f",&a,&c,&b);// 注意在变量名钱要加地址运算符&
printf("a = %d,b = %f,c = %c \n",a,b,c);
return 0;
}
printf函数中用到的格式字符
格式字符 | 说明 |
---|---|
%d | 输出带符号的十进制整数,正数的符号省略 |
%u | 以无符号的十进制整数形式输出 |
%o | 以无符号的八进制整数形式输出,不输出前导符0 |
%x | 以无符号十六进制整数形式(小写)输出,不输出前导符0x |
%X | 以无符号十六进制整数形式(大写)输出,不输出前导符0X |
%f | 以小数形式输出单、双精度数,隐含输出6位小数 |
%e | 以指数形式(小写e表示指数部分)输出实数 |
%E | 以指数形式(大写E表示指数部分)输出实数 |
%g | 自动选取f或e中输出宽度较小的一种使用,且不输出无意义的0 |
%c | 输出一个字符 |
%s | 输出字符串 |