标签: unary-operator

我还在学习函数式接口。我想知道为什么我可以将 a 链接UnaryOperator到a的末尾Function，但不能将 an 链接IntUnaryOperator到同一个 Function 的末尾。

UnaryOperator <String> twoOfMe = s -> s + s;
Function <String, Integer> convertMe = s -> Integer.parseInt (s);

UnaryOperator <Integer> twiceMe = n -> 2*n;

IntUnaryOperator doubleMe = n -> 2*n;

int a = twoOfMe.andThen(convertMe).andThen(twiceMe).apply ("2");

int b = twoOfMe.andThen(convertMe).andThen(doubleMe).apply ("2");

int a使用twiceMe但int b不适用于doubleMe.

谢谢

编辑：它说不兼容的类型。必需的整数。找到 java.lang.Object

我写这段代码,但我不知道为什么编译.

UnaryOperator接受特定类型参数,并返回与其参数类型相同的结果.

我的问题:如果我把一个if-statement返回null,是不是有编译器错误？

null 不是它的论点的类型(在我的例子中是Doll)？

内置的功能接口(如Consumer,UnaryOperator,Function)是否可以返回null而不是标准返回值？

这是我的代码:

import java.util.function.*;

public class Doll {

    private int layer;

    public Doll(int layer) {
        super();
        this.layer = layer;
    }

    public static void open(UnaryOperator<Doll> task, Doll doll) {
        while ((doll = task.apply(doll)) != null) {
            System.out.println("X");
        }
    }

    public static void main(String[] args) {
        open(s -> {
            if (s.layer <= 0)
                return null;
            else
                return new Doll(s.layer--);
        }, new Doll(5));
    }
}

非常感谢!

C++11 标准是否保证零值有符号整数的一元减为零？

例如：

int zero = 0;
int n = -zero;
int m = -0;
assert(memcmp(&n, &zero, sizeof(int)) == 0);
assert(memcmp(&m, &zero, sizeof(int)) == 0);

我知道这一点-0并且0在二进制的恭维表示中是相同的，但我想知道标准是否允许有符号整数零的否定为其他表示的负零，例如一个人的恭维或有符号幅度。

我在 C++11 草案中所能找到的只是 §5.3.1，第 8 段：

一元运算符的操作数应具有算术或无作用域枚举类型，结果是其操作数的否定。积分提升是在积分或枚举操作数上执行的。无符号量的负数是通过从 2^n 中减去其值来计算的，其中 n 是提升操作数中的位数。结果的类型是提升操作数的类型。

我在草案中找不到否定的定义。

动机：我正在为一个库（最终可能是开源的）编写一个专门的整数解析器，我想知道我是否应该担心在不常见的架构上"-0"被解释为负零有符号整数的可能性。

注意：我已经知道负零浮点数。

在这里,我有以下代码:

int a,b,x;
a=b=1;
x=a+++b;

现在,值x将是2,因为a第一个是后递增,然后它被添加到b.

以下是编译的字节代码:

 0  iconst_1
 1  dup
 2  istore_2 [b]
 3  istore_1 [a]
 4  iload_1 [a]
 5  iinc 1 1 [a]
 8  iload_2 [b]
 9  iadd
10  istore_3 [x]

所以表达式将等同于x = (a++) + b.

现在另一个表达式x=a++++b,因为最大的munch规则而不会编译.它将成为x = (a++) ++ b编译错误.

上述行为是x=a+++b因为运算符 ++ 的优先级还是因为最大的munch规则？

c中是否有任何一元和二元的运算符？在一次采访中提出了这个问题.

我刚才注意到我可以在JavaScript中执行以下操作:

var z = -0;
console.log(z); // prints -0

为什么一元否定在零上有效？

这是众多JavaScript怪癖之一还是它(某种程度上)有目的？

PS:

它似乎发生在Firefox 38.0a2和Chrome 41.0.2272上.在Node.js v0.10.36上没有发生.关于IE的Dunno.

根据Oracle运算符优先级规范,执行如下操作:

x-- // Returns x, then subtracts 1 from x.

应优先于:

--x // Subtracts 1 from x, then returns x.

所以,鉴于下面的小片段,为什么:

int x = 5;
int y = --x * 5 + x--;
System.out.println(x+" vs "+y);

打印3 vs 24而不是3 vs 20？

精

假设运算符优先级的给定顺序,可以将代码段的第2行分解为以下伪块(先前评估的值放在方括号中):

1. 评估 x--

2. 评估 --x

3. 评估 [--x] * 5

4. 评估 [--x * 5] + [x--]

5. 评估 y = [--x * 5 + x--]

然后将解决如下:

1点之后 returns 5 sets x to 4

2点以后 …

我试图定义一个类并覆盖代字号运算符:

class foo:
    def __invert__(self, other)
        return 1232 # a random number , just as test

然后称之为:

>>> f = foo()
>>> g = foo()
>>> f ~ g
  File "<input>", line 1
    f ~ g
      ^
SyntaxError: invalid syntax

我们可以用二进制运算符替换波浪运算符,这样我们就可以像f ~ g不引发语法错误那样进行操作.

只是为了看看我对++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？

#include <stdio.h>

int main() {
    int a;
    char b;
    short int c;
    double d;
    printf("%d %d %d %d\n", sizeof(a), sizeof(b), sizeof(c), sizeof(d));
    printf("%d %d %d %d\n", sizeof(+a), sizeof(+b), sizeof(+c), sizeof(+d));
    printf("%d %d %d %d\n", sizeof(-a), sizeof(-b), sizeof(-c), sizeof(-d));
    return 0;
}

32 位编译器输出：

4 1 2 8
4 4 4 8
4 4 4 8

如果我更改 . 中的符号，输出相同sizeof()，例如sizeof(-a). 我想知道为什么会发生这种情况。+和-运算符是否在促进数据类型？