由于C++中的重载：

double f(int var)
{
 return double(var);
} 

int f(double var)
{
 return -int(var);
}

int main(){
int n(42);
std::cout<<f(f(n));
}

Python 2.6：

f = lambda n: (n % 2 * n or -n) + (n > 0) - (n < 0)

我意识到这对讨论毫无帮助，但我无法抗拒。

使用复数，您可以有效地将否定数字的任务分为两个步骤：

将n乘以i，得到n*i，n逆时针旋转90°再乘以i，得到-n

最棒的是，您不需要任何特殊的处理代码。只要乘以i就可以了。

但不允许使用复数。因此，您必须使用部分数据范围创建自己的虚拟轴。由于需要的虚（中间）值与初始值一样多，因此只剩下一半的数据范围。

我试图在下图中显示这一点，假设有符号的8位数据。您必须将其缩放为32位整数。初始n的允许范围为-64到+63。下面是函数对正n的作用：

如果n在0..63（初始范围）内，函数调用将添加64，将n映射到范围64..127（中间范围）如果n在64..127（中间范围）内，则函数从64中减去n，将n映射到范围0..-63

对于负n，函数使用中间范围-65..-128。

很简单，只需让f返回看起来等于任何整数的值，并且可以从整数转换。

public class Agreeable
{
    public static bool operator==(Agreeable c, int n)
        { return true; }

    public static bool operator!=(Agreeable c, int n)
        { return false; }

    public static implicit operator Agreeable(int n)
        { return new Agreeable(); }
}

class Program
{
    public static Agreeable f(Agreeable c)
        { return c; }

    static void Main(string[] args)
    {
        Debug.Assert(f(f(0)) == 0);
        Debug.Assert(f(f(5)) == -5);
        Debug.Assert(f(f(-5)) == 5);
        Debug.Assert(f(f(int.MaxValue)) == -int.MaxValue);
    }
}

这个怎么样：

do
    local function makeFunc()
        local var
        return function(x)
            if x == true then
                return -var
            else
                var = x
                return true
            end
        end

    end
    f = makeFunc()
end
print(f(f(20000)))

我不知道这是否完全正确，但一个简单的标志不起作用吗？在C语言中，使用静态局部变量，我成功地做到了这一点：

int main()
{
    int n = -256; // 32-bit signed integer
    printf("%d", f(f(n)));
}

int f(int n){
    static int x = 0; // not returning negative;
    switch(x){
        case 0:
            x = 1;
            return n;
            break;

        case 1:
            x = 0;
            return -n;
            break;
        default:
            return -999;
            break;
    }
}