标签: pre-increment

只是为了看看我对++c/c++运算符的工作原理了解多少，我尝试运行这些 C 程序：

int c = 5;
c = c - c++;
printf("%d\n", c);

打印 1，我猜逻辑是 ++ 在使用它的代码行之后应用，因此c变为= c - c0，并在“下一行”增加一。但对我来说似乎很奇怪，我想更详细地了解操作员优先级应该发生什么。

现在开始：

int c = 5;
c = c - ++c;
printf("%d\n", c);

这个打印0，我真的不明白为什么。如果从左到右解析右手值，我想它会读取c哪个是 5，然后++c哪个是 6，因为它应该立即应用。或者它是否++c在整个右手值计算之前计算，因此它实际上是在做 6 - 6，因为增量还涉及第一次调用c？

我从未在实际代码中看到用于预增量和后增量的用例.我经常看到它们的唯一地方是谜题.
我的观点是,它引入了更多的混淆而不是有用.

• 是否有任何真实的用例场景

• 这不能通过使用+ =来完成

  y = x++

  y = x
x += 1

我正在寻找c ++ for dummies并找到了这段代码

#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;

int nextStudentId = 1000; // first legal Student ID
class StudentId
{
public:
StudentId()
{
    value = nextStudentId++;
    cout << "Take next student id " << value << endl;
}

// int constructor allows user to assign id
StudentId(int id)
{
    value = id;
    cout << "Assign student id " << value << endl;
}
protected:
int value;
};

class Student
{
public:
Student(const char* pName)
{ …

假设您有一个递归方法,并在递归调用中后递增/递减值.当预增量/减量不会导致堆栈溢出异常时,为什么会这样？

防爆.

numberCount(currentNumber++); //Stack overflow exception

numberCount(++currentNumber); //No stack overflow exception

提前感谢您的任何澄清.

我们有这段代码:

int a = 1;
int b = ++a + ++a;

在C++(VS 2010)中,结果是:b = 6但在C#中结果是:b = 5

那里发生了什么？为什么结果不同？

我试图通过在线解决一些问题来学习动态编程.我遇到的一个问题需要处理以下输入

4 10 3 4 4 5 6 7 5 7

项目数量的第一个点,第二个总容量和四个中的其余点(成对)现在应该指向值和容量.

我遇到的问题是解析它的代码.

#include<iostream>
#include<map>
#include<iterator>
using namespace std;

template<typename T>
void print(typename T::const_iterator start,
           typename T::const_iterator end)
{
    typename T::const_iterator itr=start;
    while(itr!=end)
    {
        std::cout << itr->first << " " << itr->second << std::endl;
        itr++;
    }
}

int main()
{
    int _M_N; // total numbers
    int _M_V; // total values
    std::map<int,int> _M_Values; 

    istream_iterator<int> isi(cin); 
    _M_N = *isi;
    _M_V = *++isi;

    for(int i=0;i<_M_N;i++)
    {
        //int m=*++isi,n=*++isi;
        //_M_Values.insert(make_pair(m,n));
        _M_Values.insert(make_pair(*++isi,*++isi)); 
    }
    print<std::map<int,int> >(_M_Values.begin(),_M_Values.end()); …

array.prototype.reduce函数位于:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce

它有以下循环:

for (index = 0; length > index; ++index) {
    if (this.hasOwnProperty(index)) {
      if (isValueSet) {
         value = callback(value, this[index], index, this);
      } else {
        value = this[index];
        isValueSet = true;
      }
    }
}

我不认为索引在这里是先增加还是后增加,因为它是在每次循环迭代之后完成的,但是想要确定.

可以将其更改为index + = 1,以便传递jslint吗？请不要讨论jslint警告的优点.

这种变化会有什么不同吗？

我写了一个代码来打印所有有效的n对括号组合.但是,在我第一次尝试时,算法输出所有组合两次,即.代码是:

public static void solve(char[] string, int open, int closed, int index)
{
    if (open < 0 || closed < open) {
        return;
    }

    if (open == 0 && closed == 0) {
        System.out.println(string);
    }

    if (open > 0) {
        string[index] = '(';
        solve(string, --open, closed, ++index);
    }

    if (closed > open) {
        string[index] = ')';
        solve(string, open, --closed, ++index);
    }
}

我花了很多时间才能看出出了什么问题.我认为代码进入最后一个if分支比它应该更多.然后,在尝试不同的事情时,我意识到了变化

solve(string, --open, closed, ++index);

至

solve(string, open-1, closed, ++index);

改变了结果.这导致了一个java.lang.ArrayIndexOutOfBoundsException.最后,我用相应的算术运算(例如,++indexto index+1)替换了所有预增量操作,并且代码正确运行.

我的问题是,不应该 …

任何人都可以解释为什么c在执行后仍然等于15

int main(void)
{
    int t,a=5,b=10,c=15;
        t= ++a||++c;
        printf("%d  %d  %d",t,a,c);
}

大家好,我在学习用c ++编写代码时有一个非常基本的问题.

我正在阅读通过引用传递和传递值之间的区别.我写了一个简单的代码来测试它,但它做了我没想到的事情.

    #include <iostream>
    using namespace std;

    void MyIncr (float *x);
    int main() {
        float score = 10.0;
        cout << "Orignal Value = " << score << endl;
        MyIncr(&score);
        cout << "New Value = " << score << endl;
     }

     void MyIncr (float *x) {
        *++x;
     }

为什么我的两个couts都得到10分？但是,如果我将功能更改为:

     void MyIncr (float *x) {
        *x += 1;
     }

我得到10为旧值,11为新值,这也是我在前一种情况下所期望的.