小编use*_*784的帖子

int *nums = {5, 2, 1, 4};
printf("%d\n", nums[0]);

导致段错误,而

int nums[] = {5, 2, 1, 4};
printf("%d\n", nums[0]);

没有.现在:

int *nums = {5, 2, 1, 4};
printf("%d\n", nums);

打印5.

基于此,我猜想数组初始化符号{}会盲目地将这些数据加载到左边的任何变量中.当它是int []时,数组将根据需要填充.当它是int*时,指针被填满5,并且存储指针之后的存储器位置被填充为2,1和4.因此nums [0]尝试deref 5,导致段错误.

如果我错了,请纠正我.如果我是正确的,请详细说明,因为我不明白为什么数组初始化程序按照它们的方式工作.

我正在编写一个代码段,遍历n个数字的每个排列.因此,例如,如果n = 3,我想迭代以下每个元素:

0,0,0

...

0,1,0

...

1,0,0

...

2,3,4

...

9,9,9

使用嵌套for循环很容易编码:

for(digit1 0 to 9)
    for(digit2 0 to 9)
        for(digit3 0 to 9)

但我想将这个概括为n位数.如果例如n = 10,我现在需要10个嵌套for循环.

我已经考虑过这个并且意识到问题可以通过递归来解决(深度优先搜索树,每个节点有10个子节点,0到10,并且在深度n处停止).但我的目标是高性能,所以我不想因为开销而使用递归.我还有其他什么选择？

我正在编写一个游戏引擎/库,其中我有一个事件调度程序类,它通过调用"已注册"事件处理程序类的侦听器方法来调度事件.可以通过调用适当的调度程序方法向事件调度程序注册事件处理程序/侦听器.

这显然会导致一些样板代码用于注册每个事件处理程序(以及我的引擎的其他方面都有类似的bolierplate代码),所以我想知道 - 如何在加载事件处理程序期间使用Instrumentation添加所有必需的代码class,因此编码时不需要事件调度程序的显式注册 - 在程序运行时自动添加对调度程序寄存器方法的调用.

我的理解是,为了使用Instrumentation,应该使用一些字节码修饰符API.我知道两个 - ASM和BCEL.我应该使用哪一个？显然,这是我想要做的一个简单的任务,所以我想要一个更容易学习和更好记录的那个.

编辑:这是一个具体的例子.

原始事件处理程序类:

@Handler //indicates this this class should be transformed
public class MouseEventHandler implements EventHandler<MouseEvent>
{
    //hidden default constructor
    public void handleEvent(MouseEvent event)
    { ... }
}

改造后:

@Handler
public class MouseEventHandler implements EventHandler<MouseEvent>
{
    public MouseEventHandler()
    {
        //add this line of code to default constructor
        Game.getEventDispatcher().addEventHandler(this);
    }
    public void handleEvent(MouseEvent event)
    { ... }
}

void foo(const int constant)
{
    for(int i = 0; i < 1000000; i++) {
        // do stuff
        if(constant < 10) {              // Condition is tested million times :(
            // inner loop stuff
        }
    }
}

对于外循环的每次执行,都检查"常量"的值.但是,常量永远不会改变,所以浪费了大量的CPU时间来测试条件常数<10？一遍又一遍地.人类会在前几次传球后意识到常数永远不变,并且智能地避免一遍又一遍地检查它.编译器是否注意到这一点并对其进行智能优化,或者重复if循环是否不可避免？

就个人而言,我认为这个问题是不可避免的.即使编译器在外部循环之前进行比较并设置某种布尔变量"skip_inner_stuff",仍然必须为外部for循环的每次传递检查此变量.

你对此事有何看法？有没有更有效的方法来编写上述代码段,以避免这个问题？

在我的程序中，我想在类加载器加载类时拦截它们，并用它们做一些事情，例如。检查某些注释等。我该怎么做？

我已经在网上做了很多研究，但还没有得到答案。我应该重写 ClassLoader 吗？问题在于，在大多数情况下，父类加载器会加载该类，因此我无法获取所有类。在这个网站上的几个问题中，我看到提到了仪器，但我不知道这是否与我的问题相关。

所以我有这个界面

public interface EventHandler<E extends EventObject>
{   
    public void handleEvent(E event);
}

我想为它处理处理事件的类,如下所示:

public class WorkingHandler implements EventHandler<MouseEvent>
{
    public void handleEvent(MouseEvent event)
    {
        //handle event
    }
}

以上示例工作正常.但是编译器不会让我多次实现EventHandler,因为类型擦除非常令人沮丧.

public class NotWorkingHandler implements EventHandler<MouseEvent>, EventHandler<KeyEvent>
{
    public void handleEvent(MouseEvent event)
    {
        //handle mouse event
    }

    public void handleEvent(KeyEvent event)
    {
        //handle key event
    }
}

几个问题......

1. 为什么Java不允许Type Erasure？IIRC是否与早期版本的Java兼容,这是正确的吗？

编辑:我的意思是为什么Java有类型擦除(反过来说)

1. 是否有任何类型的"mod"/"扩展"(缺少一个更好的词)或编程语言,让我绕过Type Erasure？由于我没有使用旧版本的Java,因此我不关心我的代码是否与旧代码兼容.

2. Java语言中是否有任何可以用来绕过Type Erasure的变通办法？

3. 如果不是,在我的程序中编写事件处理的其他方法有哪些让编译器满意？

我正在编写一个允许用户登录服务器的客户端程序.该程序期望用户已经设置了ssh代理并向其添加了RSA密钥对.它抓取公钥并将其发送给远程签名者,该签名者返回公钥的SSH证书.此证书声明允许公钥的所有者登录服务器.

我想让客户端程序将证书添加到代理并将其与密钥关联,以便它可以使用带有证书的密钥ssh到远程服务器.我怎样才能做到这一点？

我按照以下说明为github设置了SSH登录名，尽管它可以工作，但我无法弄清楚它为什么工作：https : //help.github.com/articles/generating-ssh-keys/

我对SSH的理解如下：客户端创建一个密钥对，客户端将公用密钥提供给服务器，并且当客户端要登录时，他使用其私钥加密服务器选择的消息，以证明自己确实是客户端。

现在：我将我的公钥XXX上传到Github。当我执行“ ssh -T git@github.com”时，Github必须知道我正在尝试以我的身份登录，以便他可以使用XXX解密我的消息，对吗？所以ssh必须发送该信息...但是ssh如何知道有关Github的信息，或者我的用户名是什么？而且，如果我有多个密钥对-ssh将使用哪个密钥？

假设我创建了两个断点2和3。断点3位于第10行，该行经常通过程序执行。如何配置3，使其仅在被击中2次后才断裂？

我正在扩展ArrayList以创建一个自定义ArrayList,可以在迭代它时使用常规ArrayList方法进行修改.为此,我也创建了一个迭代器.

public class SynchronizedList<E> extends ArrayList<E>
{
    // Fields here

    //Constructors and methods here

public class SynchronizedListIterator<E> implements Iterator<E>
{
    public int index;
    private E current;

    public boolean hasNext()
    {
        synchronized (/* reference to enclosing List object */) {
                    //code goes here
        }
        return false;
    }

    //more methods here
}
}

在我的hasNext()和next()方法中,我需要确保列表未被修改(可以在任何其他时间修改它).因此,我需要在synchronized()块中引用我的封闭类型.