C++ 变量和类型：int、double、char、string、bool

C++ 中的变量

C++ 变量为我们提供了命名存储功能。它允许程序员根据需要操作数据。每个变量在 C++ 中都有一个类型。变量类型有助于确定变量的内存映射的大小和布局、可以存储在该内存中的值的范围以及可以对其应用的操作集。

在本 C++ 教程中，您将学习：

• C++ 中的变量
• C++ 中变量的基本类型
• 在 C++ 中声明变量的规则
• C++ 变量数据类型
• 变量名称或标识符
• C++ 中的常量限定符
• C++ 中的变量范围
• 变量类型转换
• 注册变量
• 转义序列

C++中变量的基本类型

以下是 C++ 变量的基本类型：

诠释：

整数是没有任何小数或指数部分的数字文字（与数字相关联）。例子。 120、-90等

双：

它是一个双精度浮点值。示例：11.22、2.345

字符：

字符文字是通过将单个字符括在单引号内来创建的。例如：‘a’、‘m’、‘F’、‘P’、‘}’等

浮动：

浮点文字是具有小数形式或指数形式的数字文字。例如：1.3、2.6

字符串文字：

字符串文字是用双引号括起来的字符序列。例如：“你好吗？”

布尔：

它保存布尔值 true 或 false。

C++变量声明规则

以下是命名变量的一些常用规则：

• C++ 变量名只能包含字母、数字和下划线。
• C++ 变量名不能以数字开头。
• 变量名称不应以大写字符开头。
• C++ 中使用的变量名不能是关键字。例如，int 是用于表示整数的关键字。
• C++ 变量名可以以下划线开头。但是，这并不是一种好的做法。

C++ 变量数据类型

C++定义了一整套原始类型

空白 type 没有与之关联的值，只能在少数情况下使用。它最常作为不返回值的函数的返回类型。

算术类型 包括字符、整数、布尔值和浮点数。算术类型如果进一步分为2类

1. 浮点类型 .浮点数（或浮点型）表示十进制数。 IEEE 标准规定了有效数字的最小数量。大多数编译器通常提供比指定最小值更高的精度。通常，浮点数以 32 位表示，双精度数以 64 位表示，长双精度数以 96 位或 128 位表示。
2. 整型 （包括字符、整数和布尔类型）。 布尔值 type 只有两种类型的值：True 或 False。有几个char 类型，其中大部分是为了支持国际化而存在的。最基本的字符类型是char。 char 与单个机器字节的大小相同，即单个字节。

整数类型 可以签名也可以不签名。

签名类型 ：它们代表负数或正数（包括零）。在有符号类型中，范围必须在 +ve 和 -ve 值之间平均分配。因此，一个 8 位有符号字符将保存从 –127 到 127 的值。

无符号类型 :在无符号类型中，所有值都>=0。8 位无符号字符可以包含 0 到 255（包括 0 到 255）。

变量名称或标识符

标识符可以由一些字母、数字和下划线字符或它们的某种组合组成。名称长度没有限制。

标识符必须

• 以字母或下划线 ('_') 开头。
• 并且区分大小写；大小写字母不同：

// 定义了四个不同的int变量

int guru99, gurU99, GuRu99, GURU99;

C++ 语言保留了一些名称供其使用。

在不同的编程语言中命名变量有许多公认的约定。遵循这些约定可以提高程序的可读性。

• 标识符应该至少能说明其含义。
• 变量名称通常是小写的——guru99，而不是 Guru99 或 GURU99。
• 我们定义的类通常以大写字母开头。
• 包含多个单词的标识符应在视觉上区分每个单词。例如，guru99_website 不是 guru99website。

C++ 变量声明和定义

变量的声明使程序在定义它的范围内知道名称。示例：

int a=5;
int b;
char c='A'; 

int a,b;
a=b=1000;

List initialization
int a(5);
int b{5};

C++ 中的常量限定符

假设有一个变量 buffsize 表示要从用户那里获取的输入数量。在这里，我们不想在整个程序中更改 buffsize 的值。我们想定义一个我们知道它的值不应该改变的变量。

在这种情况下，请使用关键字 const

const int bufSize = 512;    // input buffer size

这将 bufSize 定义为常量。任何分配或更改 bufSize 的尝试都会出错。

在这里，我们不能在创建 const 对象后更改它的值，它必须强制声明和初始化。否则编译器会抛出错误。

const int i = get_size();  // ok: initialized at run time
const int j = 42;          // ok: initialized at compile time
const int k;               // error: k is uninitialized const
int i = 42;
const int ci = i;    	   // ok: the value in i is copied into ci 

C++ 中的变量范围

范围是程序的一个跨度，其中变量具有意义。大多数情况下，相同的名称可用于指代不同范围内的不同实体。变量从声明它们的那一刻起直到它们的声明出现的范围结束都是可见的。

#include <iostream>	
int main()	
{	
    int sum = 0;	
    // sum values from 1 through 10 inclusive	
    for (int val = 1; val <= 10; ++val)	
        sum += val;  // equivalent to sum = sum + val	
    cout << "Sum of 1 to 10 inclusive is "<< sum <<endl;	
    return 0;	
}	 

该程序定义了 3 个名称，即 main、sum 和 val。它使用命名空间名称 std，以及该命名空间中的另外两个名称——cout 和 endl。

• 函数名“main”在大括号外定义。函数名 main ——与在函数外部定义的大多数其他名称一样——具有全局范围。这意味着一旦声明，名称就在 全局范围 在整个程序中都可以访问。
• 变量 sum 是在 main 函数体块的范围内定义的。它可以从它的声明点和主函数体的其余部分访问。然而，不在它之外。这意味着变量 sum 具有 块范围 .
• 变量val定义在“for语句”的范围内。它可以很容易地在该语句中使用，但不能在 main 函数的其他地方使用。它具有本地范围 .

嵌套范围

范围可以包含其他范围。包含（或嵌套）范围称为内部范围。包含范围是外部范围。

#include <iostream>	
using namespace std;	
// Program for illustration purposes only: It is bad style for a function	
// to use a global variable and also define a local variable with the same name	
int reused = 42;  // reused has global scope	
int main()	
{	
    int unique = 0; // unique has block scope	
    // output #1: uses global reused; prints 42 0	
    cout << reused << " " << unique << endl;	
    int reused = 0; // new, local object named reused hides global reused	
    // output #2: uses local reused; prints 0 0	
    cout << reused << " " << unique << endl;	
    // output #3: explicitly requests the global reused; prints 42 0	
    cout << ::reused << " " << unique << endl;	
    return 0;	
}	 

输出 #1 出现在重用的本地定义之前。因此，这个输出

语句是使用在全局范围内定义的重用名称的语句。该语句输出

42 0

输出 #2 发生在局部定义重用之后。它现在在范围内。因此，第二个输出语句只使用名为reused 的本地对象而不是全局对象并输出

0 0

输出#3 使用范围运算符覆盖默认范围规则。全局范围没有名称。因此，当作用域 operator(::) 的左侧为空时。它将其解释为获取全局范围右侧名称的请求。因此，表达式使用全局重用和输出

42 0

变量类型转换

一种类型的变量可以转换为另一种类型。它被称为“类型转换”。让我们看看转换不同C++变量类型的规则：

将 non-bool 赋值给 bool 变量如果值为 0 则为 false，否则为 true。

bool b = 42;            // b is true

将 bool 分配给其他算术类型之一，如果 bool 为真，则为 1；如果 bool 为假，则为 0。

bool b = true;
int i = b;              // i has value 1

将浮点值分配给 int 类型的变量会产生被截断的值。存储的值是小数点前的部分。

int i = 3.14;               // i has value 3

将 int 值分配给 float 类型的变量会导致小数部分变为零。如果整数的位数多于浮动变量所能容纳的位数，则精度通常会丢失。

Int i=3;
double pi = i;          // pi has value 3.0

如果我们尝试将超出范围的值分配给无符号类型的变量，则结果是值的余数 %(modulo)

例如，8 位 unsigned char 类型可以保存从 0 到 255 的值，包括 0 到 255。分配超出此范围的值将导致编译器将该值的余数以 256 为模。因此，根据上述逻辑，将 –1 分配给 8 位无符号字符会赋予该对象 255 的值。

unsigned char c = -1;   // assuming 8-bit chars, c has value 255

如果我们尝试将超出范围的值分配给有符号类型的对象，则结果是不可预测的。它是未定义的。该程序可能看起来在外面工作，或者它可能会崩溃，或者它可能会产生垃圾值。

signed char c2 = 256;   // assuming 8-bit chars, the value of c2 is undefined

当我们使用一种类型的值而需要其他类型的值时，编译器会应用这些相同类型的转换。

int i = 42;
if (i) // condition will evaluate as true
i = 0; 

如果此值=0，则条件为假；所有其他（非零）值产生真。同样的概念，当我们在算术表达式中使用 bool 时，它的值总是被转换为 0 或 1。因此，在算术表达式中使用 bool 通常几乎肯定是不正确的。

注意：不要混用有符号和无符号类型

当有符号值为负时，混合有符号和无符号的表达式会产生令人惊讶和错误的结果。如上所述，有符号值会自动转换为无符号值。

例如，在像

这样的算术表达式中

x* y

如果 x 是 -1 并且 y 是 1，并且如果 x 和 y 都是 int，那么正如预期的那样，该值是 -1。

如果 x 是 int 并且 y 是无符号的，那么这个表达式的值取决于一个整数在编译机上有多少位。在我们的机器上，这个表达式产生 4294967295。

注册变量

与内存变量相比，寄存器变量的访问速度更快。因此，可以使用 register 将 C++ 程序中经常使用的变量放入寄存器中 关键词。 register 关键字告诉编译器将给定变量存储在寄存器中。是否将其放入寄存器是编译器的选择。通常，编译器本身会进行各种优化，包括将一些变量放入寄存器中。 C++ 程序中寄存器变量的数量没有限制。但是编译器可能不会将变量存储在寄存器中。这是因为寄存器内存非常有限，并且最常被操作系统使用。

定义：

register int i;

评论

注释是编译器忽略的代码部分。它允许程序员在源代码/程序的相关区域做笔记。注释以块形式或单行形式出现。程序注释是解释性陈述。它可以包含在 C++ 代码中，以帮助任何人阅读其源代码。所有编程语言都允许某种形式的注释。 C++ 支持单行注释和多行注释。

• 单行注释 是以 // 开头并一直持续到行尾的那些。如果注释行中的最后一个字符是 \，则注释将在下一行继续。
• 多行注释 是以 /* 开头并以 */ 结尾的那些。

/* This is a comment */
/* C++ comments can  also 
* span multiple lines 
*/

转义序列

一些字符，例如退格和控制字符，没有可见的图像。此类字符称为不可打印字符。其他字符（单引号和双引号、问号和反斜杠）在许多编程语言中具有特殊含义。

我们的程序不能直接使用这些字符中的任何一个。相反，我们可以使用转义序列来表示这样的字符。转义序列以反斜杠开头。

C++ 编程语言定义了几个转义序列：

它有什么作用？ 人物

换行

\n

垂直制表符

\v

反斜杠

\\

回车

\r

水平制表符

\t

退格

\b

问号

\?

换页

\f

警报（铃）

\a

双引号

\”

单引号

\'

我们像使用单个字符一样使用转义序列：

cout << '\n';        // prints a newline
cout << "\tguru99!\n";   // prints a tab followed by "guru99!" and a newline 

我们还可以编写通用转义序列 \x 后跟一个或多个十六进制数字。或者我们使用 \ 后跟一个、两个或三个八进制数字。广义转义序列表示字符的数值。一些例子（假设 Latin-1 字符集）：

\7 (bell)    \12 (newline)      \40 (blank)
\0 (null)    \115 ('M')         \x4d ('M') 

我们可以使用预定义的转义序列，就像我们使用任何其他字符一样。

cout << "Hi \x4dO\115!\n";  // prints Hi MOM! followed by a newline
cout << '\115' << '\n';     // prints M followed by a newline 

总结

• C++ 变量为我们提供了命名存储功能。
• C++ 变量类型：int、double、char、float、string、bool 等
• 包含（或嵌套）范围称为内部范围，包含范围称为外部范围。
• 一种类型的变量可以转换为另一种类型。它被称为“类型转换”。
• 与内存变量相比，寄存器变量的访问速度更快。
• 注释是编译器忽略的代码部分。
• 某些字符（例如退格和控制字符）没有可见图像。