我有一些代码如下:
class bar;
class foo
{
public:
operator bar() const;
};
class bar
{
public:
bar(const foo& foo);
};
void baz() {
foo f;
bar b = f; // [1]
const foo f2;
bar b2 = f2; // [2]
}
GCC在[2]处给出错误,但不是[1].Clang给出了两个错误,显然MSVC都没有给出错误.谁是对的？
c++ conversion-operator language-lawyer overload-resolution copy-initialization
我有很多处理特定消息类型的处理程序类.要注册所有这些处理程序,我需要知道存在哪些处理程序.目前,它们都使用特定的注释进行注释,并且我使用Java 6注释处理器来获取所有这些注释,并创建一个包含每个注释类型的实例的Register类.
如果整个树一次构建,这很有效,但如果只构建一个带注释的类(例如,当我在Eclipse中保存文件时),处理器只能看到该类型,并构建一个不完整的Register.如何检查此方案中的其他类型？
有了Iterable<T>,很容易:
T last = null;
for (T t : iterable) {
if (last != null && last.compareTo(t) > 0) {
return false;
}
last = t;
}
return true;
但我想不出一个干净的方法来做同样的事情Stream<T>,避免消耗所有元素,而不必.
我们使用自定义Guice范围,@TestScoped对于一些持续用于单个测试方法的JUnit测试,以及用于@Rule适当地进入和退出范围的JUnit .它看起来像这样:
public class MyJUnitTest {
@Rule public CustomRule customRule = new CustomRule(MyModule.class);
@Inject private Thing thing;
@Test
public void test1() {
// Use "thing"
}
@Test
public void test2() {
// Assuming "Thing" is @TestScoped, we'll have a new instance
}
}
我们开始在其他项目中使用TestNG进行一些测试,我们希望有类似的模式.到目前为止,我们已经想出了这个:
@Listeners(CustomTestNGListener.class)
@Guice(modules = MyModule.class)
public class MyTestNGTest {
@Inject private Provider<Thing> thingProvider;
@Test
public void test1() {
Thing thing = thingProvider.get();
// Use "thing"
}
@Test
public void test2() {
Thing thing …我是对的,对任何浮点数的任何算术运算都是由IEEE浮点标准明确定义的吗？如果是的话,只是出于好奇,那是(+0)+(-0)什么？有没有办法在实践中用C++或其他常用的编程语言来检查这些东西？
用于乘以4x4矩阵的朴素算法如下所示:
void matrix_mul(double out[4][4], double lhs[4][4], double rhs[4][4]) {
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
out[i][j] = 0.0;
for (int k = 0; k < 4; ++k) {
out[i][j] += lhs[i][k] * rhs[k][j];
}
}
}
}
显然,这个算法给出了假结果,如果out == lhs或out == rhs(这里==指的是参考相等).是否有允许这些案例中的一个或两个不仅仅复制矩阵的版本？如果有必要,我很高兴为每个案例提供不同的功能.
我发现了这篇论文,但它讨论了Strassen-Winograd算法,这对我的小矩阵来说太过分了.这个问题的答案似乎表明,如果out == lhs && out == rhs(即,我们试图对矩阵进行平方),那么它就无法在适当的位置完成,但即使在那里也没有令人信服的证据或证据.
我知道,自Java 8以来,如果HashMap有足够的哈希冲突,并且密钥实现Comparable,它将使用平衡树而不是bin的链表.但是,从我所看到的,Comparable接口并不需要说compareTo()是"一致equals()"(虽然它强烈推荐).
我错过了什么？如果密钥碰巧具有合规但非推荐的实现,则新实现似乎允许HashMap违反Map接口的要求Comparable.
以下JUnit测试在OpenJDK 8u72上公开此行为:
import static org.junit.Assert.*;
import java.util.HashSet;
import java.util.Set;
import org.junit.Test;
class Foo
implements Comparable<Foo> // Comment this out to fix the test case
{
private final int bar;
private final int baz;
Foo(int bar, int baz) {
this.bar = bar;
this.baz = baz;
}
public boolean equals(Object obj) {
// Note that this ignores 'baz'
return …这是一个将int加到另一个的 C 函数，如果发生溢出则失败：
int safe_add(int *value, int delta) {
if (*value >= 0) {
if (delta > INT_MAX - *value) {
return -1;
}
} else {
if (delta < INT_MIN - *value) {
return -1;
}
}
*value += delta;
return 0;
}
safe_add(int*, int):
movl (%rdi), %eax
testl %eax, %eax
js .L2
movl $2147483647, %edx
subl %eax, %edx
cmpl %esi, %edx
jl .L6
.L4:
addl %esi, %eax
movl …例如,stream.read()假设com.google包存在于某个JAR(例如,Guava )中,此代码段会在该行上抛出NullPointerException(!).
ClassLoader classLoader = getClass().getClassLoader();
URL resource = classLoader.getResource("com/google");
InputStream stream = resource.openStream();
System.out.println(stream.toString()); // Fine -- stream is not null
stream.read(); // NPE inside FilterInputStream.read()!
如果com/google与文件系统中的包而不是JAR交换,则代码段根本不会崩溃.事实上,它似乎读取该目录中的文件,由换行符分隔,但我无法想象在任何地方都指定了行为.
如果资源路径"com/google"指向"普通"资源文件或目录,是否有方法测试？