小编zwo*_*wol的帖子

我正在使用一个非常大的遗留C++代码库,它仍然是无名的.作为遗留代码库,它会在整个地方传递原始指针.但我们正在逐步尝试对其进行现代化,因此也有一些智能指针模板.这些智能指针(与Boost的scoped_ptr不同)具有对原始指针的隐式转换,因此您可以将其中一个传递给一个采用原始指针而无需编写的例程.get().一个很大的缺点是你也可能在一个delete声明中意外地使用一个,然后你有一个双重免费的bug,这可能是一个真正的痛苦追踪.

有没有办法修改模板,使其仍然具有对原始指针的隐式转换,但如果在delete语句中使用,则会导致编译错误？像这样:

#include <my_scoped_ptr>

struct A {};
extern void f(A*);

struct B
{
    scoped_ptr<A> a;

    B();
    ~B();
};

B::B()
    : a(new A)
{
    f(a); // this should compile
}

B::~B()
{
    delete a; // this should NOT compile
}

PostScript/PDF字符串文字由括号括起,只要括号完全平衡,就允许包含未转义的括号.所以举个例子

( () )  % valid string constant
( ( )   % invalid string constant, the inner ( should be escaped

我知道一个算法来告诉我,如果有是任何不平衡的括号中的字符串; 我正在寻找的是一种算法,它将找到一组不平衡的最小括号,这样我就可以在它们前面加上反斜杠,使整个字符串成为有效字符串.更多例子:

(     ?   \(
()    ?   ()
(()   ?   \(() or (\()
())   ?   ()\) or (\))
()(   ?   ()\(

C++编译器可以假设'const bool&'值不会改变吗？

例如,假设我有一个类:

class test {
public:
  test(const bool &state)
    : _test(state) {
  }

  void doSomething() {
    if (_test) {
      doMore();
    }
  }
  void doMore();

private:
  const bool &_test;
};

我用它如下:

void example() {
  bool myState = true;
  test myTest(myState);

  while (someTest()) {
    myTest.doSomething();
    myState = anotherTest();
  }
}

是否允许编译器的标准假设_test的值不会改变.

我想不是,但只是想确定.

对于加密实用程序的单元测试,我希望能够强制OpenSSL的加密随机数生成器(两者RAND_bytes和两者RAND_pseudo_bytes)返回可预测的,可重复的字节序列,以便各种密文可以预测并且可以烘焙到测试向量中.(所有其他关键材料都在我的控制之下.)

我知道这完全打败了安全.这仅用于单元测试.

我不能简单地RAND_seed在每次测试之前使用固定的种子进行调用,因为(看起来)RNG会根据/dev/urandom我是否需要它来自动播种,并且无论如何RAND_seed都不会重置 RNG,它只会将种子添加到熵池中.

有没有办法做到这一点？(在极端情况下,看起来我可以编写自己的PRNG引擎,但我想有一个更简单的选择.)

为什么object似乎没有__getattr__方法？它定义了__setattr__和__delattr__.它不需要这三个吗？

>>> object.__setattr__
<slot wrapper '__setattr__' of 'object' objects>
>>> 
>>> object.__delattr__
<slot wrapper '__delattr__' of 'object' objects>
>>> 
>>> object.__getattr__
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'object' has no attribute '__getattr__'
>>> sys.version
'2.7.3 (default, Feb 27 2014, 19:58:35) \n[GCC 4.6.3]'

我正在实现一个函数,它比较两个JavaScript对象的"深度"相等性.这个函数的骨架,现在看起来像这样:

function check_equal(actual, expected) {
    var stack = [];
    function check_equal_r(act, exp) {
        if (is_scalar(act) || is_scalar(exp)) {
            assert(act === exp);

        } else if (stack.indexOf(act) == -1) {
            assert(have_all_the_same_properties(act, exp));
            stack.push(act);
            for (var k of Object.getOwnPropertyNames(exp)) {
                check_equal_r(act[k], exp[k]);
            }
            stack.pop(act);

        } else {
            // ??? cyclic reference detected
        }
    }
    check_equal_r(act, exp);
}

问题是该说些什么// ??? cyclic reference detected.理想情况下,我希望能够说这些对象非常平等:

var a = {foo:1, bar:2, baz:null},
    b = {foo:1, bar:2, baz:null};
a.baz = a;
b.baz = b;

而且这些对象不是 …

有时异步任务没有有意义的终止条件——例如，在下面的程序中，“rate_limiter”任务在队列上以固定速率永远生成令牌流。

import asyncio
import sys

@asyncio.coroutine
def rate_limiter(queue, rate):
    """Push tokens to QUEUE at a rate of RATE per second."""
    delay = 1/rate
    while True:
        yield from asyncio.sleep(delay)
        yield from queue.put(None)

@asyncio.coroutine
def do_work(n, rate):
    for i in range(n):
        yield from rate.get()
        sys.stdout.write("job {}\n".format(i))

def main():
    loop   = asyncio.get_event_loop()
    rate   = asyncio.Queue()
    rltask = loop.create_task(rate_limiter(rate, 10))
    wtask  = loop.create_task(do_work(20, rate))
    loop.run_until_complete(wtask)

main()

这个程序完美运行，只是asyncio 库认为这是一个编程错误，rltask当没有任何东西可以限制速率时就扔掉它；你会收到这样的投诉

...
job 18
job 19
Task was destroyed but it is pending! …

我想写一个macro_rules!宏，它的参数是一个，ident并且是字符串文字列表。宏的扩展需要同时包含字符串文字和相应的字节文字。该宏用于测试，将仅与仅包含U + 0000 ... U + 007F范围内的字符的字符串一起使用。如果将字符串文字以外的任何内容提供给宏会导致编译时错误，则可以。

如果当前无法不使用过程宏来实现，请告诉我，不要费心实际编写过程宏;-)

所需的调用和扩展是这样的：

all_s! isalpha [ "abcdefghijklmnopqrstuvwxyz" /* , ... */ ];

=>

assert!(isalpha("abcdefghijklmnopqrstuvwxyz"));
assert!("abcdefghijklmnopqrstuvwxyz".chars().all(|b| isalpha(b));
assert!(isalpha(b"abcdefghijklmnopqrstuvwxyz"));
assert!(b"abcdefghijklmnopqrstuvwxyz".iter().all(|b| isalpha(b)));
/* ... */

据我所知：

macro_rules! all_s {
    ($what: ident, $( $str: tt ),* ) => {{
        $(
            assert!($what($str));
            assert!($str.chars().all(|b| $what(b));
            assert!($what(BYTE_LITERAL!($str)));
            assert!(BYTE_LITERAL!($str).iter().all(|b| $what(b)));
        )*
    }}
}

但是我不知道该说什么BYTE_LITERAL!，而且我也收到错误消息，提示我没有正确编写匹配模式，例如“ macro all_s！期望没有ident参数，给定'isalpha'” “ $ what：ident”就在那里。

这是非常基本的，但是我在Rails文档中找不到任何运气。有一个视图帮助器方法（Ruby代码，不是 HAML）返回

link_to(user_controlled_text, destination, options)

并且我需要将HTML元素（即<bdi>）包装在周围user_controlled_text。如果我做

link_to("<bdi>#{user_controlled_text}</bdi>", ...)

那么我的元素将被视为要转义的用户控制文本的一部分。很公平。我该如何告诉Rails不要逃避<bdi>并且</bdi>仍然逃避user_controlled_text？

在 Node.js 中，process.stdout流被记录为“同步”运行，这意味着每次调用都会stdout.write导致立即write系统调用 - 没有缓冲。例如

import { stdout } from 'process';

for (let i = 1; i <= 1000; i++) {
    stdout.write(`line ${i}\n`);
}
stdout.end();

进行 1000 次write系统调用。当您编写传统的 Unix 数据发送实用程序时，这不是您想要的。可以绕过process.stdout并创建一个单独的可写流，该流下沉到文件描述符 1，例如

import { stdout } from 'process';
import { createWriteStream } from 'fs';
let ostream = createWriteStream("/ignored", { fd: stdout.fd });
for (let i = 1; i <= 1000; i++) {
    ostream.write(`line ${i}\n`);
}
ostream.end();

仅进行一次系统调用。然而，像这样的绕过是危险的——调用之后ostream.end，文件描述符 1 …