C++表达式

📌 相关文章

📜 C++表达式

📅 最后修改于: 2020-10-16 06:22:37 🧑 作者: Mango

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

C++表达式的示例：

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

表达式可以具有以下类型：

常数表达式
积分表达式
浮点表达式
指针表达式
关系表达
逻辑表达式
按位表达式
特殊任务表达

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

常数表达式

常数表达式是仅包含常数值的表达式。它是一个表达式，其值在编译时确定但在运行时求值。它可以由整数，字符，浮点数和枚举常量组成。

在以下情况下使用常量：

在下标声明符中使用它来描述数组绑定。
在switch语句中的case关键字之后使用。
在枚举中用作数值
它指定位字段的宽度。
在预处理程序#if中使用

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

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

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 
using namespace std;
int main()
{
    int x;        // variable declaration.
    x=(3/2) + 2;  // constant expression
    cout<<"Value of x is : "<

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

输出量

Value of x is : 3

积分表达式

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

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

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

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

#include 
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 :"<

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

输出量

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

我们来看积分表达式的另一个例子。

#include 
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和y。我们将表达式(y + int(10.0))的值存储在’x’变量中。

输出量

Value of x : 19

浮点表达式

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

以下是float表达式的示例：

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

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

#include 
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<

输出量

value of z is :14.5

让我们看一下float表达式的另一个示例。

#include 
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<

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

输出量

value of y is :16.7

指针表达式

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

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

&x
ptr
ptr++
ptr-

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

#include 
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<

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

输出量

value of second element of an array : 2

关系表达

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

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

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

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

#include 
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 :"<

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

输出量

Value of y is :0

让我们来看另一个例子。

#include 
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”。然后，我们在这些变量之间应用关系运算符(> =)。

输出量

逻辑表达式

逻辑表达式是组合两个或多个关系表达式并产生布尔类型值的表达式。逻辑运算符为“ &&”和“ ||”结合了两个或多个关系表达式。

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

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

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

#include 
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 
using namespace std;
int main()
{
 int x=5;   // variable declaration
std::cout << (x>>1) << std::endl;
return 0;
}

在上面的代码中，我们声明了一个变量“ x”。声明后，我们使用按位运算运算符，即右移运算符将一位位置右移。

输出量

让我们看另一个例子。

#include 
using namespace std;
int main()
{
 int x=7;   // variable declaration
std::cout << (x<<3) << std::endl;
return 0;
}

在上面的代码中，我们已经声明了变量“ x”。声明后，我们将左移位运算符应用于变量“ x”，以将三位位置向左移位。

输出量

特殊作业表达

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

连锁分配

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

例如：

a=b=20 
 or 
(a=b) = 20

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

#include 
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”。然后，我们使用链式分配表达式为两个变量分配了相同的值。

输出量

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

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

嵌入式分配表达式

嵌入式赋值表达式是一种赋值表达式，其中，赋值表达式包含在另一个赋值表达式中。

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

#include 
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”和“ b”。然后，我们应用了嵌入式分配表达式(a = 10 +(b = 90))。

输出量

Values of 'a' is 100

复合作业

复合赋值表达式是由赋值运算符和二进制运算符组合而成的表达式。

例如，

a+=10;

在上面的语句中，“ a”是变量，而“ + =”是复合语句。

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

#include 
using namespace std;
int main()
{
  int a=10;   // variable declaration
  a+=10;    // compound assignment
  std::cout << "Value of a is :" <

在上面的代码中，我们声明了一个变量“ a”，并为该变量分配了10个值。然后，我们将复合赋值运算符(+ =)应用于’a’变量，即a + = 10等于(a = a + 10)。该语句将“ a”的值增加10。

输出量

Value of a is :20