小编Luc*_*iel的帖子

我有一个Derived直接从两个基类继承的类,Base1和Base2.我想知道一般来说,将指针与基类进行比较以确定它们是否是同一个Derived对象是否安全:

Base1* p1;
Base2* p2;

/*
 * Stuff happens here. p1 and p2 now point to valid objects of either their
 * base type or Derived
 */

//assert(p1 == p2); //This is illegal
assert(p1 == static_cast<Base1*>(p2)); //Is this ok?
assert(static_cast<Derived*>(p1) == static_cast<Derived*>(p2)); //How about this?

指针保证有效,但不一定指向Derived对象.我的猜测是这可能很好,但我想从技术C++的角度来看它是否可以.我实际上从不对指针进行任何操作,我只是想知道它们是否指向同一个对象.

编辑:如果我可以保证p1并p2指向Derrived对象似乎是安全的.我基本上想知道如果它们不是 - 如果一个或两个都指向基础对象,它是否安全,那么比较是否必然会失败？同样,我可以保证指针有效(即,p1永远不会指向Base2对象,反之亦然)

所以我有一个类,我将其用作本地命名空间.我在类中有一些静态函数,但它们无法访问类范围变量.为什么是这样？

class Foo:
    foo_string = "I am a foo"

    @staticmethod
    def foo():
        print foo_string

>>> Foo.foo()
  [Stack Trace]
  NameError: global name 'foo_string' is not defined

有什么想法吗？

我正在构建一个实现字符串连接的库; 也就是说,打印由分隔符分隔的容器的所有元素.我的基本设计如下:

use std::fmt;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Join<Container, Sep> {
    container: Container,
    sep: Sep,
}

impl<Container, Sep> fmt::Display for Join<Container, Sep>
where
    for<'a> &'a Container: IntoIterator,
    for<'a> <&'a Container as IntoIterator>::Item: fmt::Display,
    Sep: fmt::Display,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut iter = self.container.into_iter();

        match iter.next() {
            None => Ok(()),
            Some(first) => {
                first.fmt(f)?;

                iter.try_for_each(move |element| {
                    self.sep.fmt(f)?;
                    element.fmt(f)
                })
            }
        }
    }
}

这种特质实施无需投诉即可编译.注意绑定&'a C: IntoIterator.许多容器实现IntoIterator对自身的引用,以允许迭代对包含项的引用(例如,在此处Vec …

我正在使用一个互斥的组,但我不止一个选项在一个独家集合中.我希望我的用法看起来像这样:

[--conf CONF | --hostname HOSTNAME --port PORT]

知道如何实现这一点吗？我已经尝试将参数组添加到互斥组,但互斥部分不适用于子组,它允许--conf file --hostname host --port 22

目前，我有一个看起来像这样的表格：

class SelectBoard(generic.FormView):
    form_class = forms.SelectBoard

    def form_valid(self, form):
        board_name = form.cleaned_data['name']
        return redirect('leaderboard', board_name=board_name)

但是，我更喜欢做更惯用的事情，并使用get_success_url. 像这样的东西：

class SelectBoard(generic.FormView):
    form_class = forms.SelectBoard

    def get_success_url(self):
        form = ???
        board_name = form.cleaned_data['name']
        return reverse('leaderboard', board_name=board_name)

然而，该形式不传递到get_success_url，并且不同于请求上下文的许多其他件（如self.request，self.kwargs，或self.object（在DetailView）），的形式不附着如在标准的任何点的属性FormView调度序列。有没有什么好方法可以访问经过清理和验证的表单数据get_success_url（即，无需self.request.POST从头开始访问或重建表单）？

我希望能够为一个“框架”睡我的未来，以便其他工作可以发生。这是这个想法的有效实现吗？

use std::future::Future;
use std::task::{Context, Poll};
use std::pin::Pin;

struct Yield {
    yielded: bool,
}

impl Future for Yield {
    type Output = ();

    fn poll(mut self: Pin<&mut Self>, ctx: &mut Context) -> Poll<()> {
        if self.yielded {
            Poll::Ready(())
        } else {
            self.yielded = true;

            // This is the part I'm concerned about
            ctx.waker().wake_by_ref();

            Poll::Pending
        }
    }
}

具体来说，我担心的是，wake_by_ref如果调用是在轮询返回之前进行的，则上下文不会“注意到”该调用Pending。poll以这种方式执行时，接口契约是否保证此任务会立即重新轮询？

我正在使用asyncio和tkinter开发一个简单的图形网络应用程序.我遇到了将asyncio事件循环与Tk的mainloop相结合的问题.如果可能的话,我想在没有线程的情况下这样做,因为这两个库(但特别是tkinter)都不是非常线程安全的.目前,我在asyncio协程中使用Tk.update,它只运行tk事件循环的一次迭代:

@asyncio.coroutine
def run_tk(tk, interval=0.1):
    try:
        while True:
            tk.update()
            yield from asyncio.sleep(interval)
    except TclError as e:
        if "application has been destroyed" not in e.args[0]:
            raise

但是,为了探索所有选项,我想知道是否可以执行反向 - 如果可以在tk回调中仅调用asyncio事件循环的单次迭代.

我正在开发一个库，该库帮助处理适合 FFI 边界上的指针大小 int 的类型。假设我有一个这样的结构：

use std::mem::{size_of, align_of};

struct PaddingDemo {
    data: u8,
    force_pad: [usize; 0]
}

assert_eq!(size_of::<PaddingDemo>(), size_of::<usize>());
assert_eq!(align_of::<PaddingDemo>(), align_of::<usize>());

这个结构体有 1 个数据字节和 7 个填充字节。我想将此结构的一个实例打包到 a 中usize，然后在 FFI 边界的另一侧解包。因为这个库是通用的，我使用MaybeUninit和ptr::write：

use std::ptr;
use std::mem::MaybeUninit;

let data = PaddingDemo { data: 12, force_pad: [] };

// In order to ensure all the bytes are initialized,
// zero-initialize the buffer
let mut packed: MaybeUninit<usize> = MaybeUninit::zeroed();
let ptr = packed.as_mut_ptr() as *mut PaddingDemo;

let packed_int = …

如果我有一个简单的功能:

def add(a, b, c):
    return a + b + c

我有可能做到这一点,如果我提供一个未使用的kwarg,它会被忽略吗？

kwargs = dict(a=1, b=2, c=3, d=4)
print add(**kwargs) #prints 6

考虑字符串"abc?"。根据unicode的分词demo实现，这个字符串应该被拆分成两个词，"abc"和"?"。然而，词边界检测的 3 个不同 Rust 实现（regex，unic-segment，unicode-segmentation）都不一致，并将该字符串分组为一个词。哪种行为是正确的？

作为后续，如果分组行为是正确的，那么以仍然主要尊重单词边界的方式扫描此字符串以查找搜索词“abc”的好方法是什么（目的是检查字符串翻译的有效性） . 我想匹配类似"abc?"但不匹配类似的东西abcdef。