此处将为大家介绍关于C，C++，Java和C＃中的递增和递减运算符行为[重复]的详细内容，并且为您解答有关c++递增运算符重载的相关问题，此外，我们还将为您介绍关于c++_for循环_表达式和语句的定

此处将为大家介绍关于C，C ++，Java和C＃中的递增和递减运算符行为[重复]的详细内容，并且为您解答有关c++递增运算符重载的相关问题，此外，我们还将为您介绍关于c++_for循环_表达式和语句的定义_阶乘例子_递增和递减运算符_副作用点和顺序点_、C++递增/递减运算符重载、C中的递减运算符、C和JAVA中递增递减运算符的差异的有用信息。

• C，C ++，Java和C＃中的递增和递减运算符行为[重复]（c++递增运算符重载）
• c++_for循环_表达式和语句的定义_阶乘例子_递增和递减运算符_副作用点和顺序点_
• C++递增/递减运算符重载
• C中的递减运算符
• C和JAVA中递增递减运算符的差异

C，C ++，Java和C＃中的递增和递减运算符行为[重复]（c++递增运算符重载）

免责声明： 这不是真实示例。 这只是这些语言如何工作的理论问题。

C / C ++，C＃和Java在后和前增量运算符之间到底有什么区别？

这就是我使用VC ++ 10，Java 1.6和C＃4所获得的

int a = 2;int b = a++ + a++;int c = ++a + a++ + a++;      +-----+------+------+----+      |  C  | C++  | Java | C# |+-----+-----+------+------+----+| a   |  7  |  7   |   7  |  7 |+-----+-----+------+------+----+| b   |  4  |  4   |   5  | 5  |+-----+-----+------+------+----+| c   | 15  |  15  |  16  | 16 |+-----+-----+------+------+----+

答案1

Java和C＃从左到右评估表达式，其副作用 立即 可见。

在C ++中，未指定子表达式的求值顺序，并且两次修改同一对象而没有插入顺序点的行为是未定义的行为。

c++_for循环_表达式和语句的定义_阶乘例子_递增和递减运算符_副作用点和顺序点_

/* 对于for循环 */
/*for(initializition; test-expression; update-expression)中
01)initializition只执行一次初始化
02)test-expression决定循环体是否被执行，通常可以是任意表达式
03)update-expression在每轮循环结束时执行
04)对c++来说for是一个关键字，因此编译器不会讲for视为一个函数
05)为区分函数和for、if、while等关键字，习惯上在关键字和括号之间加一个空格,
     而省略函数和括号之间的空格*/

/* 表达式和语句的定义 */
// x=20 这是一个表达式，注意没有分号
// x<y 也是一个表达式 为关系表达式
// age = 20; 这是一条语句，注意有分号
// int toad; 这是一条语句，不是表达式，因为它没有值

/* for的应用：以下为阶乘的一个代码，改变Arsize的值即可改变实现阶乘的数目 */
//#include <iostream>
//
//const int Arsize = 16; //定义静态变量 不可修改
//int main()
//{
//     int zero; //定义一个变量用于最后的cin
//     long long factorias[Arsize]; //定义一个空数组数据类型为long long
//     factorias[1] = factorias[0] = 1LL; // 0和1的阶乘都是1，那么这里就直接讲0和1的阶乘设置为1,LL表示将1设置为long long类型
//     for (int i = 2; i < Arsize; i++)
//        factorias[i] = i * factorias[i - 1];
//     for (int i = 0; i < Arsize; i++) //i是在for循环中定义的变量,只能在for循环中使用,离开循环便不可用
//       std::cout << i << "! = " << factorias[i] << std::endl;
//     std::cin >> zero;
//     return 0;
//}

/* 递增运算符++和递减运算符-- */
/* 前缀和后缀(++zero和zero++) */
/*01)粗略的讲a++表示使用a的当前值计算表达式,然后将a的值加1，即使用后修改
     如 int x=5;
     int y=x++; //此时y=5,x=6 即先使用后修改
02)++b的意思是先将b的值加1，然后使用新的值来计算表达式，即修改后使用
     如 int z=5;
     int y=z++; //此时y=6,z=6 即先修改后使用
03)副作用：在计算表达式时对某些东西(如存储在变量中的值)进行了修改
04)顺序点：在程序执行过程中的一个点，在这里，进入下一步之前将确保对所有的副作用都进行了评估
在c++中，语句的分号就是一个顺序点，这意味着进入下一步之前对所有的副作用都进行了评估
另外，任何完整表达式末尾都是一个顺序点
05)完整表达式；不是另外一个更大表达式的子表达式
完整的表达式的例子有：表达式语句中的表达式部分以及用作while循环中的检测条件的表达式
06)顺序点有助于阐明后最递增何时进行，如下例子
while(guests++ < 10) //guests同10比较后再将其值加1
    cout<<guests<<endl;
这里guests是一个完整的表达式，因此改表达式的末尾就是一个顺序点，所以c++在确保副作用(将guests加1)在程序进入
cout之前完成。然而使用后缀格式，可确保将guests同10比较后再将其值加1
*/

//#include <iostream>
//
//int main()
//{
//     using namespace std;
// 　int guests = 0;
//     int zero;
// while (guests++ < 10) //guests同10比较后再将其值加1，所以下边先打印的是1
// {
//     cout << guests << endl; //打印1 2 3 4 5 6 7 8 9 10
// }
//     cin >> zero;
//     return 0;
//}

/*
for (n=100; n>0; --n)
    ...;
for (n=100; n>0; n--)
    ...;
这两句的最终结果是相同的
但是执行速度方面，前缀的速度会更快一些
前缀将值加1，然后返回结果
但后缀首先复制一个副本，将其值加1，然后将复制的副本返回
因此前缀版本的效率会比后缀的高
*/

/* 递增/递减运算符和指针 */

//前缀递增、前缀递减和接触引用(*)优先级都是一样的，所以采取自右向左的结合方式
//后缀递增和后缀递减的优先级相同，但是比前缀运算符的优先级高 *****

 1 #include <iuostream>
 2 int main()
 3 {
 4     using namespace std;
 5 
 6     int zero;
 7 
 8     double arr[5] = {1.0,2.0,3.0,4.0,5.0}; //定义一个包含5个double型数据的数组arr
 9     double* pt = arr; //定义一个指向double型的指针，并将arr的地址赋给arr pt指向arr[0]
10     ++pt;
11     cout<<"Address of ++pt is: "<<pt<<" Value: "<<*pt<<endl; //j将pt的地址加1，此时pt指向arr[1]
12     //打印 Address of ++pt is: 0133FCE4 Value: 2
13     *++pt;
14     cout<< "Address of *++pt is: "<<pt<< " Value: "<< *pt<<endl; //表示将此时pt指向arr[2],再对pt接触引用(取值)，所以*++pt=3.0
15     //打印 Address of *++pt is: 00BDFB4C Value: 3
16     ++*pt; //表示对pt接触引用后再加1，此时++*pt=4.0 ，此时pt仍然指向arr[2]
17     cout << "Address of ++*pt is: " << pt << " Value: " << *pt << endl;
18     //打印 Address of ++*pt is: 00BDFB4C Value: 4
19     (*pt)++; //表示取出pt的值后再将其值加1，但是此时pt仍然指向arr[2]
20 cout << "Address of (*)++pt is: " << pt << " Value: " << *pt << endl;
21 //打印 Address of (*)++pt is: 00BDFB4C Value: 5
22 *pt++; //后缀运算符的优先级更高，所以此时会先执行后缀递增将pt指向arr[3],然后
23 cout << "Address of *pt++ is: " << pt << " Value: " << *pt << endl; 
24 //打印 Address of *pt++ is: 00BDFB54 Value: 4
25 cin >> zero;
26 return 0;
27 }

View Code

2019.03.01 haijing in hz

C++递增/递减运算符重载

#include <iostream>

using namespace std;

class Time {
   private:
      int hours;             // 0 to 23
      int minutes;           // 0 to 59

   public:
      // required constructors
      Time() {
         hours = 0;
         minutes = 0;
      }
      Time(int h, int m) {
         hours = h;
         minutes = m;
      }

      // method to display time
      void displayTime() {
         cout << H:  << hours <<  M: << minutes <<endl;
      }

      // overloaded prefix ++ operator
      Time operator++ () {
         ++minutes;          // increment this object
         if(minutes >= 60) {
            ++hours;
            minutes -= 60;
         }
         return Time(hours, minutes);
      }

      // overloaded postfix ++ operator
      Time operator++( int ) {

         // save the orignal value
         Time T(hours, minutes);

         // increment this object
         ++minutes;                    

         if(minutes >= 60) {
            ++hours;
            minutes -= 60;
         }

         // return old original value
         return T; 
      }
};

int main() {
   Time T1(11, 59), T2(10,40);

   ++T1;                    // increment T1
   T1.displayTime();        // display T1
   ++T1;                    // increment T1 again
   T1.displayTime();        // display T1

   T2++;                    // increment T2
   T2.displayTime();        // display T2
   T2++;                    // increment T2 again
   T2.displayTime();        // display T2
   return 0;
}

C中的递减运算符

#include <iostream>

using namespace std;

void main ()
{
    char dummy;
    _int16 numb;
    cout << "Enter a number: ";
    cin >> numb;

    double facto(_int16);

    cout << "factorial = " <<facto(numb);
    cin >> dummy;
}

double facto( _int16 n )
{
    if ( n>1 )
        return ( n*facto(n-1) );
    else
        return 1;
}

return ( n*facto(n-1) );

return ( n*facto(n--) );

int n = 10,x;
x = --n;                // both are 9

int n = 10,x;
x = n--;                // x = 10,i = 9

C和JAVA中递增递减运算符的差异

int a[]={1,2,3,4,5,6,7,8};
int i=0,n;
n=a[++i] + i++ + a[i++] + a[i] ;

#include <stdio.h>
            int main()
            {
                int a[]={1,8};
                int i=0,n;
                n=a[++i] + i++ + a[i++] + a[i] ;
                printf("%d",n);
                getch();
                return 0;
            }

public class HelloWorld{

     public static void main(String []args){

        int a[]={1,8};
        int i=0,n;
        i=0;
        n=a[++i] + i++ + a[i++] + a[i] ;
        System.out.println(n);
     }
}

i = ++i + 1;
a[i++] = i;

我们今天的关于C，C ++，Java和C＃中的递增和递减运算符行为[重复]和c++递增运算符重载的分享就到这里，谢谢您的阅读，如果想了解更多关于c++_for循环_表达式和语句的定义_阶乘例子_递增和递减运算符_副作用点和顺序点_、C++递增/递减运算符重载、C中的递减运算符、C和JAVA中递增递减运算符的差异的相关信息，可以在本站进行搜索。