C++教程-C++的表达式

C++表达式由运算符、常量和变量组成，按照语言的规则排列。它还可以包含返回值的函数调用。表达式可以由一个或多个操作数、零个或多个运算符组成，以计算一个值。每个表达式都会产生某个值，该值通过赋值运算符赋给变量。

C++表达式的示例：

(a+b) - c
(x/y) -z
4a2 - 5b +c
(a+b) * (x+y)

表达式可以是以下类型：

• 常量表达式
• 整数表达式
• 浮点表达式
• 指针表达式
• 关系表达式
• 逻辑表达式
• 位表达式
• 特殊赋值表达式

如果表达式是上述表达式的组合，则这些表达式被称为复合表达式。

常量表达式

常量表达式是仅由常量值组成的表达式。它是在编译时确定但在运行时评估的表达式。它可以由整数、字符、浮点和枚举常量组成。 广告

常量在以下情况下使用：

• 在下标声明符中用于描述数组界限。
• 在switch语句中的case关键字后使用。
• 在enum中作为数值使用。
• 指定位字段宽度。
• 在预处理器#if中使用。

在上述情况下，常量表达式可以包含整数、字符和枚举常量。我们可以使用static和extern关键字与常量一起定义函数范围。

下表显示包含常量值的表达式：

包含常量的表达式	常量值
x = (2/3) * 4	(2/3) * 4
extern int y = 67	67
int z = 43	43
static int a = 56	56

让我们看一个包含常量表达式的简单程序：

#include <iostream>
using namespace std;
int main()
{
int x; // 变量声明。
x=(3/2) + 2; // 常量表达式
cout<<"x的值为："<<x; // 显示x的值。
return 0;
}

在上面的代码中，我们首先声明了整数类型的'x'变量。声明之后，我们将简单的常量表达式赋给'x'变量。

输出

x的值为：3

整数表达式

整数表达式是在执行所有显式和隐式转换后产生整数值作为输出的表达式。

以下是整数表达式的示例：

(x * y) -5
x + int(9.0)
where x and y are the integers. 

让我们看一个整数表达式的简单示例：

#include <iostream>
using namespace std;
int main()
{
int x; // 变量声明。
int y; // 变量声明
int z; // 变量声明
cout<<"输入x和y的值";
cin>>x>>y;
z=x+y;
cout<<"\n"<<"z的值为："<<z; // 显示z的值。
return 0;
}

在上面的代码中，我们声明了三个变量，即x、y和z。声明之后，我们接受用户输入x和y的值。然后，我们将x和y的值相加，并将结果存储在z变量中。

输出

Enter the values of x and y                                                                                                     
8                                                                                                                               
9                                                                                                                               
Value of z is :17 

让我们看另一个整数表达式的示例。

#include <iostream>
using namespace std;
int main()
{

int x; // 变量声明
int y=9; // 变量初始化
x=y+int(10.0); // 整数表达式
cout<<"x的值为："<<x; // 显示x的值。
return 0;
}

在上面的代码中，我们声明了两个变量，即x和y。我们将表达式（y+int(10.0)）的值存储在'x'变量中。

输出

Value of x : 19

浮点表达式

浮点表达式是在执行所有显式和隐式转换后产生浮点值作为输出的表达式。

以下是浮点表达式的示例：

x+y
(x/10) + y
34.5
x+float(10)

让我们通过一个例子来理解。

#include <iostream>
using namespace std;
int main()
{

float x=8.9; // 变量初始化
float y=5.6; // 变量初始化
float z; // 变量声明
z=x+y;
std::cout <<"z的值为：" << z<<std::endl; // 显示z的值。kotlinCopy code
return 0;  

}

输出

value of z is :14.5

让我们看另一个浮点表达式的示例。

#include <iostream>
using namespace std;
int main()
{
float x=6.7; // 变量初始化
float y; // 变量声明
y=x+float(10); // 浮点表达式
std::cout <<"y的值为：" << y<<std::endl; // 显示y的值
return 0;
}

在上面的代码中，我们声明了两个变量，即x和y。在声明之后，我们将表达式（x+float(10)）的值存储在变量'y'中。

输出

value of y is :16.7

指针表达式

指针表达式是一种产生地址值作为输出的表达式。

以下是指针表达式的示例：

&x
ptr
ptr++
ptr-

让我们通过一个例子来理解。

#include <iostream>
using namespace std;
int main()
{

int a[]={1,2,3,4,5}; // 数组初始化
int *ptr; // 指针声明
ptr=a; // 将数组的基地址赋给指针ptr
ptr=ptr+1; // 增加指针的值
std::cout <<"数组的第二个元素的值：" << *ptr<<std::endl;
return 0;
}

在上面的代码中，我们声明了数组和一个指针ptr。我们将数组的基地址赋给变量'ptr'。赋值地址后，我们增加指针'ptr'的值。当指针增加时，'ptr'将指向数组的第二个元素。

输出

value of second element of an array : 2

关系表达式

关系表达式是产生bool类型值的表达式，该值可以是true或false。它也称为布尔表达式。当关系运算符的两侧使用算术表达式时，先计算算术表达式，然后比较它们的结果。

以下是关系表达式的示例：

a>b
a-b >= x-y
a+b>80

让我们通过一个例子来理解。

#include <iostream>
using namespace std;
int main()
{
int a=45; // 变量声明
int b=78; // 变量声明
bool y= a>b; // 关系表达式
cout<<"y的值为："<<y; // 显示y的值。
return 0;
}

在上面的代码中，我们声明了两个变量，即'a'和'b'。在声明之后，我们应用关系运算符来检查'a'是否大于'b'。

输出

Value of y is :0

让我们看另一个例子。

#include <iostream>
using namespace std;
int main()
{
int a=4; // 变量声明
int b=5; // 变量声明
int x=3; // 变量声明
int y=6; // 变量声明
cout<<((a+b)>=(x+y)); // 关系表达式
return 0;
}

在上面的代码中，我们声明了四个变量，即'a'、'b'、'x'和'y'。然后，我们在这些变量之间应用关系运算符（>=）。

输出

1

逻辑表达式

逻辑表达式是将两个或多个关系表达式组合起来并产生bool类型值的表达式。逻辑运算符是'&&'和'||'，用于组合两个或多个关系表达式。

以下是一些逻辑表达式的示例：

a>b && x>y
a>10 || b==5

让我们看一个逻辑表达式的简单示例。

#include <iostream>
using namespace std;
int main()
{
int a=2;
int b=7;
int c=4;
cout<<((a>b)||(a>c));
return 0;
}

输出

0

位表达式

位表达式是用于在位级别上操作数据的表达式。它们基本上用于移位位。

在上面的例子中，变量'x'的值是3，其二进制值为0011。我们将'x'的值向右移动三位。让我们通过图示表示来理解。

让我们看一个简单的例子。

#include <iostream>
using namespace std;
int main()
{
int x=5; // 变量声明
std::cout << (x>>1) << std::endl;
return 0;
}

在上面的代码中，我们声明了一个变量'x'。在声明之后，我们应用了位运算符，即右移运算符，将其向右移动一位。

输出

2

让我们看另一个例子。

#include <iostream>
using namespace std;
int main()
{
int x=7; // 变量声明
std::cout << (x<<3) << std::endl;
return 0;
}

在上面的代码中，我们声明了一个变量'x'。在声明之后，我们应用了左移运算符将变量'x'向左移动三位。

输出

56

特殊赋值表达式

特殊赋值表达式是根据分配给变量的值进行进一步分类的表达式。

• 链接赋值

链接赋值表达式是一种在单个语句中将相同的值分配给多个变量的表达式。

例如：

a=b=20
或
(a=b) = 20

让我们通过一个例子来理解。

#include <iostream>
using namespace std;
int main()

int a; // 变量声明
int b; // 变量声明
a=b=80; // 链接赋值
std::cout <<"a和b的值为：" <<a<<","<<b<< std::endl;
return 0;
}

在上面的代码中，我们声明了两个变量，即'a'和'b'。然后，我们使用链接赋值表达式将相同的值分配给这两个变量。

输出

Values of 'a' and 'b' are : 80,80

注意：使用链接赋值表达式时，不能在声明变量时将值分配给变量。例如，int a=b=c=90 是无效的语句。

• 嵌套赋值表达式

嵌套赋值表达式是一种将赋值表达式嵌套在另一个赋值表达式中的赋值表达式。

让我们通过一个例子来理解。

#include <iostream>
using namespace std;
int main()
{
int a; // 变量声明
int b; // 变量声明
a=10+(b=90); // 嵌套赋值表达式
std::cout <<"a的值为：" <<a<< std::endl;
return 0;
}

在上面的代码中，我们声明了两个变量，即'a'和'b'。然后，我们应用了嵌套赋值表达式 (a=10+(b=90))。

输出

Values of 'a' is 100

• 复合赋值

复合赋值表达式是赋值运算符和二元运算符的组合。

例如，

a+=10;

在上面的语句中，'a'是一个变量，'+='是一个复合语句。

让我们通过一个例子来理解。

#include <iostream>
using namespace std;
int main()
{
int a=10; // 变量声明
a+=10; // 复合赋值
std::cout << "a的值为：" <<a<< std::endl; // 显示a的值。
return 0;
}

在上面的代码中，我们声明了一个变量'a'并将其赋值为10。然后，我们应用了复合赋值运算符（+=）到变量'a'，即a+=10，这等同于(a=a+10)。此语句将'a'的值增加10。

输出

Value of a is :20