小编Nai*_*ree的帖子

我刚刚意识到Java中的枚举常量似乎包含了相同类型的所有枚举常量.

例如,以下代码是合法的:

enum State {
    enable, disable, deleted;
}

class Test {
    public static void main(String[] args) {
        for ( State s : State.enable.disable.values() ) {
            System.out.println(s);
         }
    }
}

当我看到输出结果是:

enable
disable
deleted

enable常量是否包含disable常量而不是反直觉甚至不合逻辑,而常量又包含所有State枚举常数？

这种语言设计背后的可能考虑因素是什么？

阅读Scala 中大括号和圆括号之间的正式区别是什么，什么时候应该使用它们？，我还是不知道怎么理解包裹在{}.

考虑以下两个 REPL 会话：

@ val f = { (x: Int) =>
    x
    val y = x
    y
  }
f: Int => Int = ammonite.$sess.cmd30$$$Lambda$1765/0x0000000801346840@24c7b944

@ { (x: Int) =>
    x
    val y = x
    y
  }
cmd31.sc:3: not found: value x
  val y = x
          ^
Compilation Failed

我有几个问题。

1. 为什么第一个片段编译而第二个不编译？在第一个片段中，编译器知道{...}整体上是一个函数值。在第二个片段中，只有(x: Int) => \n x部分是函数值（对不起\n，表示换行）。为什么？
2. 关于{ (x: Int) => \n ... }，它什么时候被解释为函数值，什么时候不是？
3. 花括号 ( {}) 是函数值的一部分，还是只有 …

我从C Primer Plus中了解到,如果你想保护数组不被函数意外修改,你应该const在函数定义的标题中的指针声明之前添加修饰符.

遵循这个明智的建议,在下面的最小例子中,我试图将一个非常数二维数组array传递给函数Sum2D,其中一个参数是a pointer-to-const-int[2].

#include <stdio.h>
#define ROWS 2
#define COLS 2
int Sum2D(const int ar[][COLS], int rows); //use `const` to protect input array
int main(void)
{
    int array[ROWS][COLS]={{1,2},{3,4}}; //the non-constant array

    printf( "%d\n", Sum2D(array,ROWS) );

    return 0;
}

int Sum2D(const int ar[][COLS], int rows)
{
    int total=0;
    int i,j;
    for( i=0 ; i<rows ; i++ )
    {
        for( j=0 ; j<COLS ; j++ )
        {
            total+=ar[i][j];
        }
    }
    return …

我正在学习C.在C Primer Plus中,我看到了一个字段示例如下:

struct box_props {
    bool opaque               : 1;
    unsigned int fill_color   : 3;
    unsigned int              : 4;
    bool show_border          : 1;
    unsigned int border_color : 3;
    unsigned int border_style : 2;
    unsigned int              : 2;
};

我知道中间的4位未命名位字段用于让以下位从一个新字节开始.但是,我不明白为什么在结构的末尾有另一个未命名的位字段.它的目的是什么？有必要吗？

请考虑以下示例:

format(97, 'c')
format(6211, 'c')

第一个产出'a'显然是正确的; 然而,第二个输出'C'我不明白为什么.

该字符串格式规范规定:

'c':性格.在打印之前将整数转换为相应的unicode字符.

所以不6211应该映射到中文的Unicode字符?？

相关的sysinfo:CPython 2.7.10,在Fedora 22上.

引用第2 BUGS节,从手册页alloca(3)

在许多系统alloca()中不能在函数调用的参数列表中使用,因为保留的堆栈空间alloca()将出现在函数参数的空间中间的堆栈中.

我没看到这会怎么样.以下面的代码为例:

void f(int a, void * b, int c);

int
main(void)
{
    f(1, alloca(100), 2);
}

根据我的理解,alloca将堆栈帧扩展为main100字节(通过修改堆栈指针寄存器),然后指向堆栈存储器块(以及2 int秒)的指针在堆栈帧上传递f.所以分配的空间不应该在中间a,b或者c实际上它应该在不同的帧上(main在这种情况下,它在帧上).

那么这里的误解是什么？

在 Scala 中，模式匹配匿名函数一直让我感到惊讶。我刚刚发现了以下行为，我想知道如何理解它。

看来，匿名函数的参数签名{ case (a, b) => (b, a) }既可以注释为单个元组参数，也可以注释为参数元组：

scala> ({ case (a, b) => (b, a) }: ((Int, Int)) => (Int, Int))
val res1: ((Int, Int)) => (Int, Int) = $Lambda$1160/0x0000000801127040@689fe2a3

scala> ({ case (a, b) => (b, a) }: (Int, Int) => (Int, Int))
val res2: (Int, Int) => (Int, Int) = $Lambda$1161/0x000000080106e840@1784d711

注意res1有一个元组参数，而res2有两个参数。这是为什么？这种行为是否在语言规范中定义？（抱歉还没有退房，目前对我来说似乎太密集了。）

此外，该res1函数神奇地同时接受一个元组参数和调用站点的两个参数。

scala> res1((1,2))
val res3: (Int, Int) = (2,1)

scala> res1(1,2)
val res4: (Int, …