更改循环增量/减量值

Question

赏金将在 6 天后到期。 此问题的答案有资格获得+50声望赏金。 CPP_is_no_STANDARD想提请更多注意这个问题：

我想要一些更详细的答案。

考虑这段代码：

# include <iostream>
using namespace std;

int main()
{
    for(int i = 5; i>0;)
    {
        i--;
        cout <<i<<" ";
    }
    return 0;
}

此代码的输出将是4 3 2 1 0 。

我可以更改递减/递增值吗？

详细地说，这意味着默认的递减/递增值是 1。所以你要么减 1，要么加 1。

我可以将其更改为负 0.2 或添加 1.3 吗？

---

如果是这样，有没有办法告诉编译器我想将--值从1更改为0.2并且仍然使用--运算符而不是将其更改为-= 0.2 ？

Answer 1

d--是d -= 1的简写，它是d = d - 1的简写。 您不应将其视为数学方程式，而应将其视为“计算d - 1并将结果分配为d的新值”。

#include <iostream>

int main()
{
    float day = 1.2;
    for(int i = 0; i < 5; i++)
    {
        day -= 0.2;
        std::cout << day;
    }
    return 0;
}

（我也删除了using namespace std ，因为这是不好的做法）。

请注意， for循环的第二部分是一个条件，只要它为 true 就保持循环继续进行。 在你的情况下， i > 5从一开始就是假的（因为0 < 5 ）所以循环永远不会运行。 我以为您的意思是i < 5 。

Answer 2

您可以随意更改 for 和 body 内部的循环变量。 例如：

for (double d = 4; d > 0; d = cos(d) + 1 / d) {
    d = sin(d);
    std::cout << d << " ";
}

C++ 没有像其他语言那样的固定计数循环for i = 0 to 10 do ... done在i无法更改的情况下。 做任何你喜欢的事。

注意：我将类型更改为double ，因为您询问减0.2 。 int类型不允许这样做。

Answer 3

我可以更改递减/递增值吗？

是的，这就是 for 循环中的第三个参数（？）的作用。

#include <iostream>

int main()
{
    
    for(int i = 5; i > 0; i -= 2)
    {
        std::cout << i << std::endl;
    }
    return 0;
}

我可以将其更改为负 0.2 或添加 1.3 吗？

是的，您只需将第一个参数更改为浮点数，将第三个参数更改为按您喜欢的任意值递减/递增。

#include <iostream>


int main()
{
    for (float i = 5; i > 0; i -= .2)
    {
        std::cout << i << std::endl;
    }
    return 0;
}

Answer 4

如果我理解正确，您想要做的是改变T operator --(); .
你可以用你自己的类型来做到这一点：

struct Foo {
  float boat;
  auto operator --() noexcept { return boat -= .2f; }
  operator float() const noexcept { return boat; }
};

#include <cstdio>
int main() {
  for (Foo i{ 5 }; i > 0; --i) {
    std::printf("%1.2f, ", static_cast<float> (i));
  }
}

实时编译器资源管理器
你应该这样做吗？ 不，你不应该。 但是现在你知道如果机会不来怎么不去做。

Answer 5

i--是后置减量运算符。 对于内置类型，这意味着i减一 (1)。 表达式i--的值是i在递减之前的值。

--i是前缀减量运算符。 对于内置类型，这意味着i减一 (1)。 表达式--i的值是i递减后的值。

对于内置类型，您无法更改递增或递减运算符的行为。 如果你想有另一种行为，你需要回退到运算符+=和-= ，你可以在其中添加任何你想要的东西。 但请注意，您的代码使用int并且您可能希望在添加或减去0.1或0.2之前先更改为float或double 。

不过，您可以为自己的类型更改递增和递减运算符的行为。 这是一个例子

#include <iostream>

struct S {
    S& operator++() { // prefix increment "++s"
        d += increment_value;
        return *this;
    }
    S& operator--() { // prefix decrement "--s"
        d -= decrement_value;
        return *this;
    }
    S operator++(int) { // postfix increment "s++"
        S copy{*this};
        d += increment_value;
        return copy;
    }
    S operator--(int) { // postfix decrement "s--"
        S copy{*this};
        d -= decrement_value;
        return copy;
    }

    double d{};
    double increment_value{0.2};
    double decrement_value{0.1};

    friend std::ostream& operator<<(std::ostream& os, const S& s) {
        os << s.d;
        return os;
    }
};

int main(int, char**) {
    S s{1};
    std::cout << "val=" << s.d << '\n';
    std::cout << "prefix++=" << ++s << '\n';
    ;
    std::cout << "val=" << s.d << '\n';
    std::cout << "postfix++=" << s++ << '\n';
    std::cout << "val=" << s.d << '\n';
    std::cout << "prefix--=" << --s << '\n';
    std::cout << "val=" << s.d << '\n';
    std::cout << "postfix--=" << s-- << '\n';
    std::cout << "val=" << s.d << '\n';
}

输出是

值=1
前缀++=1.2
值=1.2
后缀++=1.2
值=1.4
前缀--=1.3
值=1.3
后缀--=1.3
值=1.2

您可能会注意到我添加了两个operator ++和两个operator-- -- 。 其中一个是没有参数，另一个是得到一个int 。 正如cppreference所描述的， int参数只是一个虚拟参数，用于区分运算符的前缀和后缀版本。 (*)

您还可以看到，前缀运算符的性能更高，因为它们不需要额外的副本。 所以通常请使用前缀版本（比较CppCoreGuidelines ）。

但是，请忽略更改增量和减量运算符的可能性。 这是反直觉的，只是错误和头痛的来源。 不要这样做！

(*) 这个参数也可以用于更令人困惑的行为，但应该清楚的是，这会使这个想法变得更糟。 因此，请将此视为技术上可行的示例。

#include <iostream>

struct S {
    S operator++(int diff) { // postfix increment "s++", diff defaults to zero (0)
        S copy{*this};
        d += diff ? diff : increment_value;
        return copy;
    }
    S operator--(int diff) { // postfix decrement "s--", diff defaults to zero (0)
        S copy{*this};
        d -= diff ? diff : decrement_value;
        return copy;
    }

    double d{};
    double increment_value{0.2};
    double decrement_value{0.1};

    friend std::ostream& operator<<(std::ostream& os, const S& s) {
        os << s.d;
        return os;
    }
};

int main(int, char**) {
    S s{1};
    std::cout << "val=" << s.d << '\n';
    s++;
    std::cout << "val=" << s.d << '\n';
    s.operator++(2);
    std::cout << "val=" << s.d << '\n';
    s--;
    std::cout << "val=" << s.d << '\n';
    s.operator--(2);
    std::cout << "val=" << s.d << '\n';
}

结果是

值=1
值=1.2
值=3.2
值=3.1
值=1.1