27

我将要在 C++ 中执行此操作，但我必须使用多种语言执行此操作，这是一个相当常见且简单的问题，这是最后一次。我已经写够了，我确信一定有更好的方法，所以我先在这里发帖，然后再用另一种语言写出同样冗长的方法；

考虑下面的（百合花！）代码；

// I want the difference between these two values as a positive integer
int x = 7
int y = 3
int diff;
// This means you have to find the largest number first 
// before making the subtract, to keep the answer positive
if (x>y) { 
     diff = (x-y);
} else if (y>x) {
     diff = (y-x);
} else if (x==y) {
    diff = 0;
}

这可能听起来很琐碎，但对我来说似乎很多，只是为了得到两个数字之间的差异。这实际上是一种完全合理的做事方式，而我是不必要的迂腐，还是我的蜘蛛侠感觉有充分的理由刺痛？

4

5 回答 5

54

只需得到差的绝对值：

#include <cstdlib>
int diff = std::abs(x-y);
于 2012-05-14T19:10:50.580 回答
31

正如其他人所建议的那样，使用该std::abs()功能是一种明确的方法。

但也许您有兴趣在没有库调用的情况下简洁地编写这个函数。

在这种情况下

diff = x > y ? x - y : y - x;

是一条捷径。

在您的评论中，您建议您对速度感兴趣。在这种情况下，您可能对不需要分支的执行此操作的方式感兴趣。这个链接描述了一些。

于 2012-05-14T19:17:12.047 回答
13 
#include <cstdlib>

int main()
{
    int x = 7;
    int y = 3;
    int diff = std::abs(x-y);
}
于 2012-05-14T19:09:41.990 回答
2

好吧，这取决于您所说的最短是什么意思。fastet 运行时，编译速度最快，行数最少，内存最少。我假设你的意思是运行时。

#include <algorithm>    // std::max/min   
int diff = std::max(x,y)-std::min(x,y);

这会进行两次比较和一次操作（这是不可避免的，但可以通过特定情况下的某些按位操作进行优化，尽管编译器实际上可能会为您执行此操作）。此外，如果编译器足够聪明，它可以只进行一次比较并将结果保存用于另一次比较。例如，如果 X>Y 那么你从第一次比较中知道 Y < X 但我不确定编译器是否利用了这一点。

于 2013-10-07T12:14:15.773 回答
2

所有现有的答案都会在极端输入时溢出，给出未定义的行为。@craq 在评论中指出了这一点。

如果您知道您的值将落在一个狭窄的范围内，则可以按照其他答案的建议进行操作，但要处理极端输入（即稳健地处理任何可能的输入值），您不能简单地减去这些值然后应用std::abs功能。正如 craq 正确指出的那样，减法可能会溢出，导致未定义的行为（考虑INT_MIN - 1），并且std::abs调用也可能导致未定义的行为（考虑std::abs(INT_MIN)）。确定这对的最小值和最大值然后执行减法并没有更好的办法。

更一般地说，a无法表示两个值signed int之间的最大差异。类型应该用于输出值signed int。unsigned int

我看到了 3 个解决方案。我从stdint.h这里使用了显式大小的整数类型，以关闭不确定性的大门，例如大小和范围是否long相同int。

解决方案1.低级方式。

// I'm unsure if it matters whether our target platform uses 2's complement,
// due to the way signed-to-unsigned conversions are defined in C and C++:
// >  the value is converted by repeatedly adding or subtracting
// >  one more than the maximum value that can be represented
// >  in the new type until the value is in the range of the new type
uint32_t difference_int32(int32_t i, int32_t j) {
    static_assert(
        (-(int64_t)INT32_MIN) == (int64_t)INT32_MAX + 1,
        "Unexpected numerical limits. This code assumes two's complement."
    );

    // Map the signed values across to the number-line of uint32_t.
    // Preserves the greater-than relation, such that an input of INT32_MIN
    // is mapped to 0, and an input of 0 is mapped to near the middle
    // of the uint32_t number-line.
    // Leverages the wrap-around behaviour of unsigned integer types.

    // It would be more intuitive to set the offset to (uint32_t)(-1 * INT32_MIN)
    // but that multiplication overflows the signed integer type,
    // causing undefined behaviour. We get the right effect subtracting from zero.
    const uint32_t offset = (uint32_t)0 - (uint32_t)(INT32_MIN);
    const uint32_t i_u = (uint32_t)i + offset;
    const uint32_t j_u = (uint32_t)j + offset;

    const uint32_t ret = (i_u > j_u) ? (i_u - j_u) : (j_u - i_u);
    return ret;
}

我尝试了使用从https://graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax获取的比特旋转聪明的变体，但现代代码生成器似乎使用这种变体生成更差的代码。（我已经删除了static_assert和评论。）

uint32_t difference_int32(int32_t i, int32_t j) {
    const uint32_t offset = (uint32_t)0 - (uint32_t)(INT32_MIN);
    const uint32_t i_u = (uint32_t)i + offset;
    const uint32_t j_u = (uint32_t)j + offset;

    // Surprisingly it helps code-gen in MSVC 2019 to manually factor-out
    // the common subexpression. (Even with optimisation /O2)
    const uint32_t t = (i_u ^ j_u) & -(i_u < j_u);
    const uint32_t min = j_u ^ t; // min(i_u, j_u)
    const uint32_t max = i_u ^ t; // max(i_u, j_u)
    const uint32_t ret = max - min;
    return ret;
}

解决方案 2.简单的方法。通过使用更广泛的有符号整数类型来避免溢出。如果输入有符号整数类型是可用的最大有符号整数类型，则不能使用此方法。

uint32_t difference_int32(int32_t i, int32_t j) {
    return (uint32_t)std::abs((int64_t)i - (int64_t)j);
}

解决方案 3.费力的方式。使用流控制来处理不同的情况。可能效率较低。

uint32_t difference_int32(int32_t i, int32_t j)
{   // This static assert should pass even on 1's complement.
    // It's just about impossible that int32_t could ever be capable of representing
    // *more* values than can uint32_t.
    // Recall that in 2's complement it's the same number, but in 1's complement,
    // uint32_t can represent one more value than can int32_t.
    static_assert( // Must use int64_t to subtract negative number from INT32_MAX
        ((int64_t)INT32_MAX - (int64_t)INT32_MIN) <= (int64_t)UINT32_MAX,
        "Unexpected numerical limits. Unable to represent greatest possible difference."
    );

    uint32_t ret;
    if (i == j) {
        ret = 0;
    } else {

        if (j > i) { // Swap them so that i > j
            const int32_t i_orig = i;
            i = j;
            j = i_orig;
        } // We may now safely assume i > j

        uint32_t magnitude_of_greater; // The magnitude, i.e. abs()
        bool     greater_is_negative; // Zero is of course non-negative
        uint32_t magnitude_of_lesser;
        bool     lesser_is_negative;

        if (i >= 0) {
            magnitude_of_greater = i;
            greater_is_negative = false;
        } else { // Here we know 'lesser' is also negative, but we'll keep it simple
            // magnitude_of_greater = -i; // DANGEROUS, overflows if i == INT32_MIN.
            magnitude_of_greater = (uint32_t)0 - (uint32_t)i;
            greater_is_negative = true;
        }

        if (j >= 0) {
            magnitude_of_lesser = j;
            lesser_is_negative = false;
        } else {
            // magnitude_of_lesser = -j; // DANGEROUS, overflows if i == INT32_MIN.
            magnitude_of_lesser = (uint32_t)0 - (uint32_t)j;
            lesser_is_negative = true;
        }

        // Finally compute the difference between lesser and greater
        if (!greater_is_negative && !lesser_is_negative) {
            ret = magnitude_of_greater - magnitude_of_lesser;
        } else if (greater_is_negative && lesser_is_negative) {
            ret = magnitude_of_lesser - magnitude_of_greater;
        } else { // One negative, one non-negative. Difference is sum of the magnitudes.
            // This will never overflow.
            ret = magnitude_of_lesser + magnitude_of_greater;
        }
    }
    return ret;
}
于 2020-05-10T11:31:17.203 回答