我认为我的问题与此有关,但并不完全相似.考虑以下代码:
def countdown(n):
try:
while n > 0:
yield n
n -= 1
finally:
print('In the finally block')
def main():
for n in countdown(10):
if n == 5:
break
print('Counting... ', n)
print('Finished counting')
main()
此代码的输出是:
Counting... 10
Counting... 9
Counting... 8
Counting... 7
Counting... 6
In the finally block
Finished counting
是否保证在"完成计数"之前打印"在最后一个块中"这一行？或者这是因为cPython实现细节,当引用计数达到0时,对象将被垃圾收集.
另外我对如何好奇finally的块countdown执行发电机？例如,如果我将代码更改main为
def main():
c = countdown(10)
for n in c:
if n == 5:
break
print('Counting... ', n)
print('Finished …我正在通过了解你是一本哈斯克书,在第8章中有一段代码看起来像这样
data LockerState = Taken | Free deriving (Eq, Show)
type Code = String
type LockerMap = Map.Map Int (LockerState, Code)
lookup' :: Int -> LockerMap -> Either String Code
lookup' num_ map_ =
case (Map.lookup num_ map_) of
Nothing -> Left $ "LockerNumber doesn't exist!"
Just (state, code) -> if state == Taken
then Left $ "LockerNumber already taken!"
else Right $ code
这有效.但是,我想将if/else块转换为保护语句,如下所示:
lookup' :: Int -> LockerMap -> Either String Code
lookup' num_ map_ = …C++17string_view当我们只需要查看底层字符序列时,我们已经让我们优化了我们不必要地分配内存的场景.智慧是,你几乎可以随时更换const std::string&使用std::string_view.请考虑以下示例:
char foo(const std::string& str)
{
return str[0];
}
以上是所有值的有效函数std::string.但是,如果我们将其更改为:
char foo(std::string_view sv)
{
return sv[0];
}
我们已经为大小为0的字符串触发了Undefined Behavior!最后有一个注释:
与std :: basic_string :: operator []不同,std :: basic_string_view :: operator [](size())具有未定义的行为,而不是返回CharT().
有谁知道为什么索引操作符的行为是不协调的？
为什么要in为生成器定义运算符？
>>> def foo():
... yield 42
...
>>>
>>> f = foo()
>>> 10 in f
False
可能的用例有哪些？
我知道range(...)对象__contains__定义了一个函数，这样我们就可以做这样的事情：
>>> r = range(10)
>>> 4 in r
True
>>> r.__contains__
<method-wrapper '__contains__' of range object at 0x7f82bd51cc00>
但f上面没有__contains__方法。
所以,我有一个返回布尔值的函数
bool func_true()
{
// do some stuff
return true;
}
现在实际代码就像这样调用它
if (auto err = func_true())
{
// some stuff
std::cout << std::boolalpha << err << '\n';
}
一切都很好,直到这一点.如果我在我的呼叫周围放置一个额外的圆括号,则编译失败:
if ((auto err = func_true())) // doesn't compile!
{
std::cout << std::boolalpha << err << '\n';
}
GCC错误:
error: expected primary-expression before 'auto'
if ((auto err = func_true()))
^~~~
http://coliru.stacked-crooked.com/a/812424bfdb66eec3
这是一个gcc bug,还是我做了一些愚蠢的错误？
考虑一下C ++中的这段代码
struct Base
{
std::int64_t x;
std::int64_t y;
};
static_assert(sizeof(Base) == 16, "Base not of size 16!");
struct Derived : Base
{
std::int32_t z;
}__attribute__((packed));
static_assert(sizeof(Derived) == 20, "Derived not of size 20!");
clang认为此代码有效，因为gcc会导致第二个static_assert触发。（“不是大小为20的派生！）。如果我还添加了打包在Base中的属性，则在两个编译器中都可以。没有人知道哪个是正确的，为什么？
我想知道是否可以通过 Boost Preprocessor 序列完成以下操作。（大多数 SO 问题以及 Boost Preprocessor 示例仅讨论 1 个序列）
#define seq1 (a)(b)(c)
#define seq2 (1)(2)(3)
// Now iterate over both of them at the same time
这是我的动机。我必须为很多类型定义几个函数，例如
void add(int val) { obj.AddInt(val); }
void add(double val) { obj.AddDouble(val); }
我正在考虑定义两个序列，例如
#define types (int)(double)...
#define funcs (AddInt)(AddDouble)...
然后为函数 add 编写一个宏，并迭代这两个序列。
我很好奇为什么namedtuple比python中的常规类慢。考虑以下：
In [1]: from collections import namedtuple
In [2]: Stock = namedtuple('Stock', 'name price shares')
In [3]: s = Stock('AAPL', 750.34, 90)
In [4]: %%timeit
...: value = s.price * s.shares
...:
175 ns ± 1.17 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
In [5]: class Stock2:
...: __slots__ = ('name', 'price', 'shares')
...: def __init__(self, name, price, shares):
...: self.name = name
...: self.price = price
...: self.shares = shares
In [6]: s2 …考虑这个 C++ 代码：
#include <iostream>
#include <functional>
using namespace std;
std::function<int(int, int)> foo(int c) {
auto add = [] (int a, int b) { return a + b; };
auto sub = [] (int a, int b) { return a - b; };
if (c > 42) {
return add;
} else {
return sub;
}
}
int main() {
cout << foo(100)(10, 20) << '\n';
}
两个 lambdas (add和sub) 都通过类型擦除std::function，然后在 main 中调用该函数。我想知道如何在 Rust …
考虑以下代码：
#include <stdio.h>
void foo() {
printf("Hello world\n");
}
void bar() {
printf("Hello world");
}
这两个函数产生的程序集是：
.LC0:
.string "Hello world"
foo():
mov edi, OFFSET FLAT:.LC0
jmp puts
bar():
mov edi, OFFSET FLAT:.LC0
xor eax, eax
jmp printf
现在我知道puts 和 printf之间的区别，但我发现这很有趣，因为 gcc 能够内省 const char* 并确定是调用 printf 还是 puts。
另一个有趣的事情是bar，编译器将返回寄存器 ( eax)清零，即使它是一个void函数。为什么它在那里而不是在里面foo？
我假设编译器“内省了我的字符串”是否正确，或者对此有另一种解释？
#[rustfmt::skip]允许您在格式化时跳过“代码块”，但这需要skip在每个代码块上{}而不是 Clang 样式on/off
考虑这个代码：
fn add(a : i32, b : i32) -> i32 { a + b }
fn sub(a : i32, b : i32) -> i32 { a - b }
rustfmt 将其格式化为：
fn add(a: i32, b: i32) -> i32 {
a + b
}
fn sub(a: i32, b: i32) -> i32 {
a - b
}
一个需要两个#[rustfmt::skip]属性而不是单个on/off.
单行函数有一个 rustfmt 选项，但此示例仅用于演示目的。我想控制该地区任何可能的 rustfmt 设置。
考虑这个简单的函数：
struct Foo {
int a;
int b;
int c;
int d;
int e;
int f;
};
Foo foo() {
Foo f;
f.a = 1;
f.b = 2;
f.c = 3;
f.d = 4;
f.e = 5;
f.f = 6;
return f;
}
它生成以下程序集：
0000000000400500 <foo()>:
400500: 48 ba 01 00 00 00 02 movabs rdx,0x200000001
400507: 00 00 00
40050a: 48 b9 03 00 00 00 04 movabs rcx,0x400000003
400511: 00 00 00
400514: 48 be 05 00 00 …