C++表达式
C++表达式由根据语言规则排列的运算符，常量和变量组成。它还可以包含返回值的函数调用。一个表达式可以包含一个或多个操作数，零个或多个运算符来计算值。每个表达式都会产生一些值，该值将在赋值运算符的帮助下分配给变量。
C++表达式示例:
(a+b)-c
(x/y)-z
4a2-5b +c
(a+b) * (x+y)
表达式可以是以下类型:
常量表达式
整数表达式
浮点数表达式
指针表达式
关系表达式
逻辑表达式
按位表达式
特殊赋值表达式
如果该表达式是上述表达式的组合，则这些表达式称为复合表达式
常量表达式
常量表达式是仅包含常量值的表达式。它是一个表达式，其值在编译时确定，但在运行时求值。它可以由整数，字符，浮点数和枚举常量组成。
在以下情况下使用常量:
在下标声明符中用于描述数组绑定。
在switch语句中的case关键字之后使用。
它用作枚举中的数值
它指定位字段的宽度。
在预处理器 #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; // variable declaration.
x=(3/2) + 2; // constant expression
cout<<"Value of x is : "<<x; // displaying the value of x.
return 0;
}
在上面的代码中，我们首先声明了整数类型的'x'变量。声明后，我们将简单的常量表达式分配给'x'变量。
输出
整数表达式
整数表达式是在执行所有显式和隐式转换后生成整数值作为输出的表达式。
以下是整数表达式的示例:
(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"变量中。
输出
浮点表达式
浮点表达式是在执行所有显式和隐式转换后生成浮点值作为输出的表达式。
以下内容是float表达式的示例:
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;
}
输出
让我们看看另一个float表达式示例。
#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'中。
输出
指针表达式
指针表达式是一个生成地址值作为输出的表达式。
以下是指针表达式的示例:
让我们通过一个例子来理解。
#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
关系表达式
关系表达式是产生布尔类型的值的表达式，该值可以为true或false。也称为布尔表达式。当在关系运算符的两边使用算术表达式时，首先对算术表达式求值，然后比较它们的结果。
以下是关系表达式的示例:
让我们通过示例了解
#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'。
输出
让我们看看另一个示例。
#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'。然后，我们在这些变量之间应用关系运算符(> =)。
输出
逻辑表达式
逻辑表达式是组合两个或更多关系表达式并产生布尔类型值的表达式。逻辑运算符为" &&"和" ||"结合了两个或多个关系表达式。
以下是逻辑表达式的一些示例:
让我们看一个简单的逻辑表达式示例。
#include <iostream>
using namespace std;
int main()
{
int a=2;
int b=7;
int c=4;
cout<<((a>b)||(a>c));
return 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'。声明后，我们应用了按位运算符，即右移运算符，将一位位置右移。
输出
让我们看另一个示例。
#include <iostream>
using namespace std;
int main()
{
int x=7; // variable declaration
std::cout << (x<<3) << std::endl;
return 0;
}
在上面的代码中，我们声明了一个变量'x'。声明后，我们将左移位运算符应用于变量" x"，以将三位位置向左移位。
输出
特殊分配表达式
特殊分配表达式是可以根据分配给变量的值进一步分类的表达式。
链式分配
链式赋值表达式是通过使用单个语句将相同的值赋给多个变量的表达式。
例如:
让我们通过一个例子来理解。
#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))。
输出
化合物分配
复合赋值表达式是由赋值运算符和二进制运算符组合而成的表达式。
例如，
在上面的语句中，" 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、
输出
