小编Paz*_*Paz的帖子

之间有什么区别:

static void findMax(LinkedList<? extends Number> list){...}

和:

static <T extends Number> void findMax(LinkedList<T> list){...}

既然两者都有效,我想知道两者之间是否有任何重大差异,建议采用哪种方法.

假设我有三个文件:

//m.h
const int RED = 1;
//m.h ends here

//f1.c
#include "m.h"
//f1.c ends here


//f2.c
#include "m.h"
int main() {return 0;}
//f2.c ends here

单独编译每个将工作,但gcc -Wall f1.o f2.o -o prog将产生: multiple definition of 'RED'

现在,如果我用以下内容替换const:

//m.h
enum {RED=1} colors;
//m.h ends here

我将能够编译prog并RED用作const,不会出现任何 multiple definition错误.

enum当您在不同文件中使用具有相同名称的全局变量或结构时,为什么s 的行为与可见的行为不同？

我在测试中遇到了这个问题,我仍然不明白给出的答案:

假设我写了以下代码:

#include <math.h>
#include <stdio.h>

float cos(float x){
    return 1-x*x/4;
}

int main()
{
    printf("%0f",cos(0.05f)+sin(0.05f));
}

让我们假设cos并sin在数学库中声明和定义(接收和返回double),并且我试图将我的代码与数学库链接起来.

另一个假设是cos定义于math.c.

问题是:

"代码是否会成功编译/链接？如果是,将调用哪个cos函数？"

答案是:

"是的,代码将编译,我的cos将被调用".

怎么解释这种行为？这些多个定义不是同一个函数吗？

我正在试图找出整个Java泛型主题.

更具体地说这个问题:

public class Node<E>{
    private E data;
    public Node(E data){
        this.data=data;
    }
    public E get(){
        return this.data;
    }
    public void set(E data){
        this.data=data;
    }
}

如何添加"扩展"通配符,指定set方法可以接收E 或任何继承类E(在这种情况下,Node将保留参数的上传版本).

或者即使我按原样离开它也会有效吗？

(我可能会对泛型类型的不变方面感到困惑.)

谢谢!

通常,当您在类声明中声明方法并在外部定义它时,您需要指定其范围.

由于我已经读过运算符是非常常规的方法,我发现很难理解以下行为:

class A
{
public:
    A(int x)
    { this->x = x;}
    int foo();
    friend const A operator+ (const A& left,const int right);

private:
    int x;
};

const A operator+ (const A& left,const int right) //can't be A::operator+
{
    return A(left.x + right);
}

int A::foo()  // A:: is needed here
{
    return 5;
}

int main(int argc, char **argv) {
    A a(1);
    a = a + 4;
    a.operator =(a+5);
    a.foo();
}

为什么我们不需要指定我们定义\ overloading的"operator +"？是从操作数推断出来的吗？

我在OOP方法中进行了测试,并被问到以下True\False问题:

"抛出异常以便从深度递归调用返回被认为是异常机制的合法使用".

我认为这是错误的,因为它在应用程序的流程中并不是一个例外,但我的老师将其标记为真,说这是从深度递归返回的快速方法.

在我看来,它类似于在处理IndexOutofBounds时使用try\catch包装for块,这是不正确的编码.

你觉得哪个是对的？

假设我正在编写一个C程序,它具有:

int a = 1;
int b = 5;
int *p = &a;

将:

int k = *(p+1);

总是给k = 5？

形式上:

这个变量'地址的"连续"属性是否依赖于堆栈实现？如果没有,是否有保证(例如&a < &b < &p)？

(这个在ubuntu上使用gcc的简单测试给出了k=5,但涉及不同类型的其他测试不起作用)