当整数转换为浮点数，并且值不能直接用目标类型表示时，通常选择最接近的值（IEEE-754 要求）。
我想将整数转换为浮点数，并朝零舍入，以防整数值不能直接由浮点类型表示。
例子：
int i = 2147483647;
float nearest = static_cast<float>(i); // 2147483648 (likely)
float towards_zero = convert(i); // 2147483520
? eval
'eval' is not recognized as an internal or external command, operable program or batch file.
刚刚为Windows 10下载了它.
请考虑以下两个示例：
1。
union test{
struct {
int a;
int b[];
};
};
int main(void){
union test test;
test.a = 10;
printf("test.b[0] = %d", test.b[0]); //prints 0, UB?
}
2。
#include <stdio.h>
union test{
int a;
int b[]; //error: flexible array member in union
};
int main(void){
union test test;
test.a = 10;
printf("test.b[0] = %d", test.b[0]);
}
行为尚不清楚。我希望这些示例的行为相同（即，第一个示例也将无法编译），因为6.7.2.1(p13)：
匿名结构或联合的成员被视为包含结构或联合的成员。
因此，我将措辞解释为，好像一个union包含匿名者struct的成员，该匿名struct者的成员将被视为包含成员的成员union。
问题：为什么第一个示例可以很好地编译，而不是像第二个那样失败？
该代码的行为是否定义明确？
#include <stdatomic.h>
const int test = 42;
const int * _Atomic atomic_int_ptr;
atomic_init(&atomic_int_ptr, &test);
const int ** int_ptr_ptr = &atomic_int_ptr;
printf("int = %d\n", **int_ptr_ptr); //prints int = 42
我将原子类型的指针分配给非原子类型的指针（类型相同）。这是我对这个示例的看法：
标准中明确规定的区别const，volatile并restrict从预选赛_Atomic资格赛6.2.5(p27)：
只要允许一种类型的原子版本以及该类型的其他合格版本，本标准就明确使用短语“原子，限定或不限定类型”。在没有具体提及原子的情况下，短语“合格或不合格类型”不包括原子类型。
合格类型的兼容性也定义为6.7.3(p10)：
为了使两个合格的类型兼容，两个都应具有相同的合格类型的兼容类型；指定符或限定符列表中类型限定符的顺序不会影响指定的类型。
结合以上引用的引言，我得出结论，原子类型和非原子类型是兼容的类型。因此，应用简单分配规则6.5.16.1(p1)（emp.mine）：
左操作数具有原子，合格或不合格的指针类型，并且（考虑到左操作数在左值转换后将具有的类型）， 两个操作数都是指向 兼容类型的合格或不合格版本的指针，并且由左侧指向的类型具有全部右边指出的类型的限定词；
因此，我得出的结论是，行为已得到很好的定义（即使将原子类型分配给非原子类型也是如此）。
所有这些的问题是，应用上述规则，我们还可以得出结论：将非原子类型简单分配给原子类型也定义得很好，这显然是不正确的，因为我们atomic_store为此拥有专用的泛型函数。
我正在读关于宏观替换的标准N1570并且误解了一些措辞6.10.3.4.
1替换列表中的所有参数都已被替换并且#和##处理已经发生后,将删除所有地标标记预处理标记.然后重新扫描生成的预处理标记序列以及源文件的所有后续预处理标记,以替换更多的宏名称
所以,毕竟#并##解决了我们重新扫描替换列表.但第2节规定:
2如果在替换列表的扫描期间找到要替换的宏的名称(不包括源文件的其余预处理标记),则不会替换它.此外,如果任何嵌套替换遇到要替换的宏的名称,则不会替换它.
这看起来与我相矛盾.那么在重新扫描中可以进行哪种替换？我尝试了以下示例:
#define FOOBAR(a, b) printf(#a #b)
#define INVOKE(a, b) a##b(a, b)
int main() {
INVOKE(FOO, BAR); //expands to printf("FOO" "BAR")
}
因此INVOKE(FOO, BAR),FOOBAR(FOO, BAR)在取代之后扩展到##.然后FOOBAR(FOO, BAR)重新扫描替换列表.但是该部分2.指定被替换的宏的名称(FOOBAR)是(是的,上面定义的)它没有被替换(但实际上被替换,如在演示中可以看到的).
你能澄清一下这个措辞吗？我错过了什么？
我刚刚遇到了为我不拥有的类型实现我不拥有的特征的问题。然后我用谷歌搜索了确切的如何为我不拥有的类型实现我不拥有的特征？问题。
让我困惑的是这种限制背后的动机。我来自 Scala，在那里可以为外部类型提供外部类型类实例。
为什么 Rust 会限制这一点？
我正在尝试理解严格的别名规则,如下所述6.5(p6):
如果通过具有非字符类型的左值的值将值存储到没有声明类型的对象中,则左值的类型将成为该访问的对象的有效类型以及不修改该值的后续访问的有效类型储值.
并且6.5(p7):
对象的存储值只能由具有以下类型之一的左值表达式访问:88)
- 兼容对象的有效类型的类型
请考虑以下示例:
struct test_internal_struct_t{
int a;
int b;
};
struct test_struct_t{
struct test_internal_struct_t tis;
};
int main(){
//alocated object, no declared type
struct test_struct_t *test_struct_ptr = malloc(sizeof(*test_struct_ptr));
//object designated by the lvalue has type int
test_struct_ptr->tis.a = 1;
//object designated by the lvalue has type int
test_struct_ptr->tis.b = 2;
//VIOLATION OF STRICT ALIASING RULE???
struct test_internal_struct_t tis = test_struct_ptr->tis;
return 0;
}
在malloc(sizeof(*test_struct_ptr))没有声明的类型,因为它被分配作为脚注87:
87)分配的对象没有声明的类型
对象通过访问test_struct_ptr->tis.a和test_struct_ptr->tis.b具有 …
我有两个Tuple2[String, String]，我想检查它们是否没有重叠的坐标。这是一个例子：
def checkOverlapping(t1: (String, String), t2: (String, String)) =
t1._1 == t2._1 || t1._1 == t2._2 || t1._2 == t2._1 || t1._2 == t2._2
它可以工作，但是看起来非常难看。万一Tuple4[String, String, String, String]手动检查所有碰撞似乎很疯狂。
是否有一种适用TupleX于Strings 的简洁方法？
我正在编写一个类型安全的代码，并希望用我自己的实现替换apply()为case classes生成的代码。这里是：
import shapeless._
sealed trait Data
case object Remote extends Data
case object Local extends Data
case class SomeClass(){
type T <: Data
}
object SomeClass {
type Aux[TT] = SomeClass { type T = TT }
def apply[TT <: Data](implicit ev: TT =:!= Data): SomeClass.Aux[TT] = new SomeClass() {type T = TT}
}
val t: SomeClass = SomeClass() // <------------------ still compiles, bad
val tt: SomeClass.Aux[Remote.type] = SomeClass.apply[Remote.type] //compiles, good
val ttt: SomeClass.Aux[Data] = …我正在阅读avro格式规范，并试图了解其实现。这是解码long值的方法：
@Override
public long readLong() throws IOException {
ensureBounds(10);
int b = buf[pos++] & 0xff;
int n = b & 0x7f;
long l;
if (b > 0x7f) {
b = buf[pos++] & 0xff;
n ^= (b & 0x7f) << 7;
if (b > 0x7f) {
b = buf[pos++] & 0xff;
n ^= (b & 0x7f) << 14;
if (b > 0x7f) {
b = buf[pos++] & 0xff;
n ^= (b & 0x7f) << 21;
if (b > 0x7f) …c ×4
scala ×2
bash ×1
c++ ×1
c11 ×1
case-class ×1
cmder ×1
concurrency ×1
java ×1
long-integer ×1
macros ×1
preprocessor ×1
rounding ×1
rust ×1
shapeless ×1
stdatomic ×1
struct ×1
traits ×1
tuples ×1
type-safety ×1
union ×1