极客笔记C++ 表达式
C++ 表达式由运算符、常量和变量组成，按照语言规则排列。它还可以包含返回值的函数调用。一个表达式可以包含一个或多个操作数，零个或多个运算符来计算一个值。每个表达式都会产生一个值，通过赋值运算符将其赋给变量。
C++ 表达式的示例：
(a+b) - c
(x/y) -z
4a2 - 5b +c
(a+b) * (x+y)
表达式可以有以下类型：
- 常量表达式
- 整数表达式
- 浮点数表达式
- 指针表达式
- 关系表达式
- 逻辑表达式
- 按位表达式
- 特殊赋值表达式
如果表达式是上述表达式的组合，则这样的表达式被称为复合表达式。
常量表达式
一个常量表达式是只由常量值组成的表达式。它是一个在编译时确定值但在运行时评估的表达式。它可以由整数、字符、浮点和枚举常量组成。
常量在以下情况下使用：
- 它在下标声明符中用于描述数组边界。
- 它在switch语句中的case关键字后使用。
- 它作为枚举中的数值使用。
- 它指定位域的宽度。
- 它在预处理器中使用#if。
在上述场景中，常量表达式可以有整数、字符和枚举常量。我们可以使用静态和外部关键字与常量一起定义函数范围。
下表显示包含常量值的表达式：
| Expression containing constant | Constant value |
|---|---|
| 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; // variable declaration.
x=(3/2) + 2; // constant expression
cout<<"Value of x is : "<<x; // displaying the value of x.
return 0;
}
在上面的代码中，我们首先声明了一个整数类型的变量’x’。在声明之后，我们将简单常量表达式赋值给’x’变量。
输出
Value of x is : 3
积分表达式
整数表达式是在执行所有显式和隐式转换后输出整数值的表达式。
以下是积分表达式的示例：
(x * y) -5
x + int(9.0)
where x and y are the integers.
让我们看一个简单的积分表达式的例子：
#include <iostream>
using namespace std;
int main()
{
int x; // variable declaration.
int y; // variable declaration
int z; // variable declaration
cout<<"Enter the values of x and y";
cin>>x>>y;
z=x+y;
cout<<"\n"<<"Value of z is :"<<z; // displaying the value of 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; // variable declaration
int y=9; // variable initialization
x=y+int(10.0); // integral expression
cout<<"Value of x : "<<x; // displaying the value of 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; // variable initialization
float y=5.6; // variable initialization
float z; // variable declaration
z=x+y;
std::cout <<"value of z is :" << z<<std::endl; // displaying the value of z.
return 0;
}
输出
value of z is :14.5
让我们来看一个浮点表达式的另一个例子
#include <iostream>
using namespace std;
int main()
{
float x=6.7; // variable initialization
float y; // variable declaration
y=x+float(10); // float expression
std::cout <<"value of y is :" << y<<std::endl; // displaying the value of 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}; // array initialization
int *ptr; // pointer declaration
ptr=a; // assigning base address of array to the pointer ptr
ptr=ptr+1; // incrementing the value of pointer
std::cout <<"value of second element of an array : " << *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; // variable declaration
int b=78; // variable declaration
bool y= a>b; // relational expression
cout<<"Value of y is :"<<y; // displaying the value of y.
return 0;
}
在上面的代码中，我们声明了两个变量，即’a’和’b’。在声明后，我们在变量之间应用了关系运算符，以检查’a’是大于’b’还是小于’b’。
输出：
Value of y is :0
让我们看另一个例子。
#include <iostream>
using namespace std;
int main()
{
int a=4; // variable declaration
int b=5; // variable declaration
int x=3; // variable declaration
int y=6; // variable declaration
cout<<((a+b)>=(x+y)); // relational expression
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
x>>3 // 这个语句表示我们将三位向右移动。
在上面的例子中，’x’的值为3，其二进制值为0011。我们将 ‘x’ 的值向右移动三位。我们通过图示来理解。
让我们看一个简单的例子
#include <iostream>
using namespace std;
int main()
{
int x=5; // variable declaration
std::cout << (x>>1) << std::endl;
return 0;
}
在上述代码中，我们声明了一个变量’x’。声明后，我们应用了位操作符，即右移操作符将比特位向右移动一位。
输出
2
让我们来看另一个例子
#include <iostream>
using namespace std;
int main()
{
int x=7; // variable declaration
std::cout << (x<<3) << std::endl;
return 0;
}
在上面的代码中，我们声明了一个变量 ‘x’。在声明之后，我们将左移操作符应用于变量 ‘x’，将三位位置向左移动。
输出
56
特殊赋值表达式
特殊赋值表达式是根据赋给变量的值进一步分为不同类别的表达式。
- 链式赋值
链式赋值表达式是一种表达式，可以通过使用单个语句将相同的值赋给多个变量。
例如：
a=b=20
or
(a=b) = 20
让我们通过一个例子来理解
#include <iostream>
using namespace std;
int main()
int a; // variable declaration
int b; // variable declaration
a=b=80; // chained assignment
std::cout <<"Values of 'a' and 'b' are : " <<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; // variable declaration
int b; // variable declaration
a=10+(b=90); // embedded assignment expression
std::cout <<"Values of 'a' is " <<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; // variable declaration
a+=10; // compound assignment
std::cout << "Value of a is :" <<a<< std::endl; // displaying the value of a.
return 0;
}
在上面的代码中，我们声明了一个变量 ‘a’ 并将值10分配给这个变量。然后，我们应用了复合赋值运算符（+=）到 ‘a’ 变量上，即 a+=10，该语句等同于 (a=a+10)。这个语句将 ‘a’ 的值增加了10。
输出
Value of a is :20