标签: postfix-operator

#include<stdio.h>
int main()
{
 int a=0, b=1, c=3;
 *((a) ?&b :&a) = a ? b : c; 
 printf("%d %d %d\n", a, b, c);
 return 0;
}

输出：3 1 3

赋值运算符的结合性是从右到左。所以这里我们得到了 3 1 3 但是......

#include<stdio.h>
int main()
{
 int a=0, b=1, c=3;
 *((a++) ?&b :&a) = a ? b : c;
 printf("%d %d %d\n", a, b, c);
 return 0;
}

输出：1 1 3

My doubt is why 1 1 3 is returned instead of 1 3 3 ?

我正在编写一个日期类,并且在修复后增量方面遇到了麻烦(前缀增量似乎很好).

以下是示例代码:

public class date
{
    int year,
        month,
        day;

    public date(int d, int m, int y)
    {
        day = d;
        month = m;
        year = y;
    }

    static public date operator ++(date d)
    { 
        return d.Next(d);
    }
}

方法"下一个(日期d)"采用日期并返回明天日期(我为了简洁而将其留下).我要年轻的C#来理解为什么前缀很好但后缀增量什么也没做.但请记住,在C++中,我们必须有两个方法而不是一个 - 用于前缀和后缀增量.

编译时也没有错误或警告.

我正在尝试重载' - '后缀运算符.我有这个代码:

class Counter
{
 private:
    int count;
 public:
    Counter()
    { count = 0; }
    Counter(int c)
    { count = c; }

    void setCount(int c)
    { count = c; }
    int getCount()
    { return count; }

    int operator--()
    {
       int temp = count;
       count = count - 1;
       return temp;
    }
};

然后在main我有这个函数调用:

 Counter a; 
 a.setCount(5); 
 cout << a-- << endl;

这给了我这个错误: error: no ‘operator--(int)’ declared for postfix ‘--’, trying prefix operator instead

但是当我这样调用这个operator--函数时,它运行得很好:

 cout …

我听到一位教授说“避免在上下文允许选择前缀的后缀运算符”。我进行搜索，但在stackoverflow中找不到相关的帖子来解释这一点。

当我们有能力选择操作员++时，为什么更喜欢使用prefixoperator ++ postfix？

我对C中的postfix和前缀运算符优先级感到困惑,任何帮助和提示都会有所帮助.

我会在这里粘贴我的测试代码:

#include <stdio.h>

int a = 0;

int main(int argc, char *argv[])
{
   if (++a & 0x01) // prefix version
   // if (a++ & 0x01) // postfix version
   {
      printf("++ first\n");
   }
   else
   {
      printf("& first\n");
   }
   return 0;
}

我现在可以理解,在postfix版本中,虽然postfix ++有一个更大的优先级,但是a++会返回0到这里&,0x01并且会a在此表达式后增加值.

但我无法理解的是为什么在前缀版本中,为什么++a首先进行评估？运算符优先级表指示prefix ++并&具有相同的优先级,此外,它们的关联性为right-to-left.这种方法&不应该先评估吗？

编辑: 我正在使用的图表:C运算符优先表

我为Brian Kernighan的" The C Programming Language " 练习1-19编写了一个简单的解决方案,它可以反转一个字符串.该reverse(char[])功能是如下,一切都与它的罚款;

void reverse(char src[])
{   
    int len = 0;
    while( src[len] != '\0')
        len++;

    for(int i = 0; i < len/2; i++)
    {
        char temp = src[i];
        src[i] = src[len - 1 - i];
        src[len - 1 - i] = temp;
    }
}

但是,如果我在while循环中使用postfix increment(++)运算符,则函数会失败;

void reverse(char src[])
{   
    int len = 0;
    while( src[len++] != '\0')      // this fails
        ;

    for(int i = 0; i …

后缀运算符采用int参数.关于为什么会有一个问题,似乎答案是:" 因为Bjarne Stroustrup这么说 "

我对这个答案感到不舒服.如果Bjarne Stroustrup需要一些东西来解决编译器的行为方式不同,为什么他不能只关闭运算符是否返回引用？它让我质疑:

1. 为什么我不能这样做: foo++ 13;
2. 为什么int参数默认为1
3. 为什么这被认为是一元运算符,需要一个论证

鉴于

int w = 1;
int x = 6;
int y = 5;
int z = 0;
 
z = !z || !x && !y;
printf("%d\n", z);

z = x-- == y + 1;
printf("%d\n", z);

如果 x-- 是 5 并且 y+1 是 6，有人可以解释下面的行将如何评估为 1 吗？

z = x-- == y + 1;

我有一个代码flush[*it % 4].push_back(*(it++) /= 4);,它意味着在递增it迭代器之前push_back新值(旧值/ 4),它是否正确或如何以最快的方式从迭代器获取值,除以4,存储它,在push_back中使用新值然后增加迭代器？

我知道使用变量后的postfix运算符增量值.但在这种情况下,它是一个有效的声明吗？因为看起来我在返回语句后修改变量.

#include <iostream>

using namespace std;

int val = 0;

int foo()
{
        return val++;
}

int main()
{
        cout<<foo();
        cout<<endl<<val;
}

任何详细说明都会有所帮助.

最近我发现使用st这样的风险:

int i = 10;
int sum = 0;
while ( i-- ){
      sum = sum + i;

它实际上得到sum = 9 + 8 + 7 + .. + 1.所以它总共缺少10个.但我更喜欢这种编码方式,它快速而专业.有什么建议可以防止风险并且仍然有简洁的代码吗？

我面临着一个关于postfix和前缀运算符的经典考试问题,前缀是我无法理解的.考虑以下:

#define MAX( a, b ) ( a > b ) ? (a) : (b) 

int main()
{
    int x = 2, y = 2;

    if( MAX( ++x, y ) == x )
    {
        printf( " %d is greater than %d ", x, y );
    }

    return 0;
}

考试问题要求提供该课程的输出.对我来说,它将是"3大于2"但实际输出是"4大于2"

我理解post和前缀是如何工作的(或者至少我是这么认为的)但是我不知道变量如何递增两次.对此有何解释？