小编Hal*_*ast的帖子

在浏览Guava的源代码时,我遇到了以下一段代码(hashCode内部类的实现的一部分CartesianSet):

int adjust = size() - 1;
for (int i = 0; i < axes.size(); i++) {
    adjust *= 31;
    adjust = ~~adjust;
    // in GWT, we have to deal with integer overflow carefully
}
int hash = 1;
for (Set<E> axis : axes) {
    hash = 31 * hash + (size() / axis.size() * axis.hashCode());

    hash = ~~hash;
}
hash += adjust;
return ~~hash;

两者的adjust和hash是int秒.从我所知道的关于Java,~意味着位求反,所以adjust = …

可能重复:
为什么GCC不优化结构？
为什么C++不能使结构更紧凑？

请考虑以下32位x86计算机上的示例:

由于对齐约束,以下结构

struct s1 {
    char a;
    int b;
    char c;
    char d;
    char e;
}

如果成员被重新排序,则可以更有效地表示内存(12对8字节)

struct s2 {
    int b;
    char a;
    char c;
    char d;
    char e;
}

我知道C/C++编译器不允许这样做.我的问题是为什么语言是这样设计的.毕竟,我们最终可能会浪费大量的内存,而且struct_ref->b不会关心差异.

编辑:谢谢大家的非常有用的答案.您解释为什么由于语言的设计方式,重新排列不起作用.然而,它让我想到:如果重新排列是语言的一部分,这些论点是否仍然有效？让我们说有一些指定的重新排列规则,我们至少需要这个规则

1. 我们应该只在实际需要时重新组织结构(如果结构已经"紧",不要做任何事情)
2. 规则只查看结构的定义,而不是内部结构.这可确保结构类型具有相同的布局,无论它是否在另一个结构中是内部的
3. 给定结构的编译内存布局是可预测的,因为它的定义(即规则是固定的)

我一个接一个地论证你的论点:

• 低级别的数据映射,"最惊喜的元素":只写你的结构以紧身款式自己(像@佩里的回答),并没有发生任何改变(要求1).如果由于一些奇怪的原因,你想要内部填充,你可以使用虚拟变量手动插入,和/或可能有关键字/指令.

• 编译器差异:要求3消除了这种担忧.实际上,从@David Heffernan的评论来看,我们今天似乎遇到了这个问题,因为不同的编译器填充不同？

• 优化:重新排序的重点是(内存)优化.我在这看到很多潜力.我们可能无法一起删除填充,但我没有看到重新排序如何以任何方式限制优化.

• 类型铸造:在我看来,这是最大的问题.不过,应该有办法解决这个问题.由于规则是用语言修复的,编译器能够弄清楚成员的重新排序方式,并做出相应的反应.如上所述,在您想要完全控制的情况下,始终可以防止重新排序.此外,要求2确保类型安全代码永远不会中断.

我认为这样的规则有意义的原因是因为我发现按结构内容而不是按类型对结构成员进行分组更为自然.当我有很多内部结构时,编译器也更容易选择最适合我的顺序.最佳布局甚至可能是我无法以类型安全的方式表达的布局.另一方面,它似乎使语言更复杂,这当然是一个缺点.

请注意,我不是在谈论改变语言 - 只有它可以(/应该)设计不同.

我知道我的问题是假设的,但我认为讨论提供了对机器和语言设计较低层次的更深入的了解.

我在这里很新,所以我不知道是否应该为此产生一个新问题.请告诉我是否是这种情况.

请考虑以下表达式评估：

$ echo .
.
$ echo .[]
.[]
$ echo .[].
.[].
$ echo .[].[]
..                # <- WAT??
$ echo .[].[].
.[].[].
$ echo .[].[].[]
.[].[].[]

有人可以解释为什么.[].[]有这种特殊行为吗？

（经过bash 3.2.57(1)-release (x86_64-apple-darwin18)和4.4.23(1)-release (arm-unknown-linux-androideabi)。

我怀疑这与..有效的“文件”（父目录）有关。但是，为什么不.[].产生相同的结果呢？

在研究操作系统(主要以Linux作为参考)时,我在研究的材料中找不到很好的解释.

加载到存储器中的程序通常被描述为被分成文本,数据,堆栈等的段,甚至在诸如Linux的操作系统的上下文中,其中虚拟存储器完全基于分页.它只是程序,而不是被称为分段的内存本身吗？如果是这样,我发现术语令人困惑.

我看到malloc可以在Linux中使用调用'sbrk'来实现,这会增加数据段的大小.同样,这个"数据段"是否只是按惯例用于数据的内存区域而不是"真实"段？(额外的问题:'sbrk'似乎无法减小'段'的大小.这是否意味着进程永远不会释放内存到操作系统而不是退出？)

此外,我有兴趣知道为什么现代操作系统似乎不使用(分页)分段.它不会阻止某些类型的攻击使代码驻留在它自己的受保护段中,从而提高安全性吗？另一方面,这会使JIT编译变得不可能/困难吗？

除了上述问题的"是"/"否"答案之外,我对任何有关该主题的深刻阐述感兴趣.

先感谢您.

我正在编写一个应用程序，需要在运行时实现功能接口。我事先不知道要实现哪些接口，但可以Method使用接口Class对象的反射来解析对象。

为了简化问题，假设我传递一个Function包含该方法的实现的对象。

直接的东西：

@SuppressWarnings("unchecked")
private <T> T implement(Class<T> interfaceType, Method m, Function<Object[], ?> f) {
    return (T) Proxy.newProxyInstance(
            getClass().getClassLoader(),
            new Class<?>[]{interfaceType},
            (proxy, method, args) -> {
                if (method.equals(m)) {
                    return f.apply(args);
                }

                // Calls to toString, hashCode, and equals go here.
                throw new UnsupportedOperationException(method.getName());
            }
    );
}

因此，对toString、hashCode、 和 的调用equals当前失败。我显然不希望这样。

来自以下文档java.lang.reflect.Proxy：

代理实例上声明的hashCode、equals或toString方法的调用java.lang.Object将被编码并分派到调用处理程序的调用方法，其方式与接口方法调用的编码和分派相同，如上所述。传递给调用的对象的声明类Method将为java.lang.Object。继承自的代理实例的其他公共方法java.lang.Object …

作为功​​能数据类型分配的一部分,我们被要求在Haskell中给出不同的队列实现,其中两个在下面给出.

来自OO世界,第一反应是让他们实现一个通用接口,以便他们可以共享测试代码.从我们在Haskell上读到的内容来看,这转化为两种数据类型,它们是常见类型类的实例.这部分相当简单:

data SimpleQueue a = SimpleQueue [a]
data FancyQueue a = FancyQueue ([a], [a])

class Queue q where
  empty :: q a
  enqueue :: a -> q a -> q a
  dequeue :: q a -> (a, q a)

instance Queue SimpleQueue where
  empty = SimpleQueue []
  enqueue e (SimpleQueue xs) = SimpleQueue $ xs ++ [e]
  dequeue (SimpleQueue (x:xs)) = (x, SimpleQueue xs)

instance Queue FancyQueue where
  empty = FancyQueue ([], [])
  enqueue e (FancyQueue (h, t)) = …

我正在尝试将测试覆盖率报告添加到 Android 应用程序项目中。该应用程序是用 Kotlin 编写的，并使用 Gradle（Groovy 变体）构建为 5 种风格。

使用以下 Gradle 插件：

plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'kotlin-kapt'
}

我一直在遵循许多不同的集成 JaCoCo 指南，但没有一个对我有用。当我意识到 Android gradle 插件有（严重记录不足）内置支持.exec通过添加enableUnitTestCoverage true到buildTypes { debug { ... } }.

但是，我需要 XML 格式的报告，以便使用此 Action将结果发布到 GitHub PR 。

我还发现，包含testCoverageEnabled在上面的同一块中添加了 Gradle 任务create${flavor}CoverageReport，它似乎可以完成我正在寻找的任务

createProdMainNetDebugCoverageReport - Creates test coverage reports for the prodMainNetDebug variant.

但是，运行此任务会抱怨没有连接设备：

Execution failed for task ':app:connectedProdMainNetDebugAndroidTest'.
> com.android.builder.testing.api.DeviceException: No connected devices!

如何使用 Android Gradle …

我正在构建一个CMS系统,我使用jQuery和CKEditor来编辑内联内容.当编辑器模糊时,要求用户确认他/她想要丢弃编辑.如果选择"否",则应取消模糊事件,编辑器保持焦点而不更改光标位置.因为在我看来这是不可能的,所以我尝试在模糊完成后重新聚焦编辑器.以下代码段来自blur事件处理程序:

var $this = $(this);
if (confirm('Discard your changes?')) {
    $this.html($this.data('previous'));
} else {
    // Optimally prevent the blur event, but alternatively
    // reintroduce focus at correct position...
    $this.data('editor').focus();
}

请注意,focus调用是在包含的编辑器实例上完成的$this.data('editor'),但结果似乎与我直接执行的操作相同$this.

这个解决方案的问题在于,尽管它重新引入焦点,但光标现在位于文本的开头,这对于最终用户来说是非常不直观和恼人的,他们认为没有任何改变.另一方面,放弃焦点不是一种选择,因为我不希望用户能够阻止重置内容,然后继续进行其他更改,认为更改是持久的.

因此,我想要一个解决方案,我可以完全阻止模糊,或者将光标重新引入它的最后位置.

作为Haskell的新手,我正在尝试通过为简单的命令式玩具语言编写解释器来提高我的技能.

该语言中的一个表达式是input从标准输入读取单个整数.但是,当我将此表达式的值赋给变量然后稍后使用此变量时,我似乎实际上存储了读取值的计算而不是读取值本身.这意味着例如陈述

x = input;
y = x + x;

将导致解释器调用输入过程3次,而不是一个.

在评估器模块的内部,我使用a Map来存储变量的值.因为我需要处理IO,所以它包含在IOmonad中,在下面的最小例子中永生化:

import qualified Data.Map as Map

type State = Map.Map String Int
type Op = Int -> Int -> Int

input :: String -> IO State -> IO State
input x state = do line <- getLine
                   st <- state
                   return $ Map.insert x (read line) st

get :: String -> IO State -> IO Int
get x state …

如果我的部署仅定义了一个副本，我能否确保只有一个 pod 正在运行？

我注意到，当我kubectl rollout在很短的时间内执行类似操作时，我会在日志中看到两个 Pod。

有一个字符串列表（每行一个），比​​如

str1
str2
...

如何将这些转换为 JSON 列表["str1", "str2"]？