小编Ear*_*ine的帖子

嗨,我正在尝试使用std::threadG ++.这是我的测试代码

#include <thread>
#include <iostream>

int main(int, char **){
    std::thread tt([](){ std::cout<<"Thread!"<<std::endl; });
    tt.join();
}

它编译,但当我尝试运行它时,结果是:

terminate called after throwing an instance of 'std::system_error'
  what():  Operation not permitted 
Aborted

我的编译器版本:

$ g++ --version
g++ (Ubuntu/Linaro 4.6.1-9ubuntu3) 4.6.1
Copyright (C) 2011 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

我的测试代码出了什么问题？

更新:我使用以下命令行来编译和运行我的代码.

$ g++ -std=c++0x test.cpp
$ ./a.out

我试过 …

有一个众所周知的问题是我们不能forall在Cont返回类型中使用类型.

但是,可以使用以下定义:

class Monad m => MonadCont' m where
    callCC' :: ((a -> forall b. m b) -> m a) -> m a
    shift :: (forall r.(a -> m r) -> m r) -> m a
    reset :: m a -> m a

然后找一个有意义的实例.在本文中,作者声称我们可以MonadFix在ContT r m提供m实现MonadFix和实现之上实现MonadRef.但我想如果我们确实有一个,MonadRef我们可以实际上实现callCC'如下:

--satisfy law: mzero >>= f === mzero
class Monad m => MonadZero …

我在类中有以下两种方法:

public void Test(int i){
    System.out.println("1");
}
public void Test(Integer i){
    System.out.println("2");
}

以下代码行

this.getClass().getMethod("Test",Integer.class).invoke(this, 10);

打印2,如何打印1？

我尝试过以下方法:

std::function<void ()> getAction(std::unique_ptr<MyClass> &&psomething){
    //The caller given ownership of psomething
    return [psomething](){ 
        psomething->do_some_thing();
        //psomething is expected to be released after this point
    };
}

但它没有编译.有任何想法吗？

更新:

AS建议,需要一些新的语法来明确指定我们需要将所有权转移到lambda,我现在考虑以下语法:

std::function<void ()> getAction(std::unique_ptr<MyClass> psomething){
    //The caller given ownership of psomething
    return [auto psomething=move(psomething)](){ 
        psomething->do_some_thing();
        //psomething is expected to be released after this point
    };
}

它会是一个好的候选人吗？

更新1:

我将展示我的实施move和copy如下:

template<typename T>
T copy(const T &t) {
    return t;
}

//process lvalue references
template<typename T>
T move(T &t) {
    return …

我刚读了一篇关于量子物理学的文章.一个有趣的事情是,在Haskell程序员看来,这两个领域之间存在一些相似之处.

首先,量子世界中的测量看起来类似于Haskell中的懒惰评估:如果你不测量,你不知道猫是生还是死.如果您不评估,则不知道该值是否已定义或undefined.

其次,在量子中我们有EPR悖论,这可以通过高于光的速度或等效的时间机器的相互作用来解释.在Haskell,正如我们在看到大会:递归循环编程做-Monad.Reader问题6,我们可以访问,通过使用递归的来自未来的值do.

最后,在量子中,我们必须区分熵永不减少的可观察世界和时间在两个方向上相等的"纯"量子世界.在Haskell中,我们拥有IO()描述程序实际执行情况的世界,以及从未产生副作用的纯粹功能世界,并且价值从不依赖于评估顺序.

所以我猜上述事实表明这两个领域之间存在一些相互联系.这会产生更有趣的后果吗？例如,虽然我已经谈到了EPR悖论,但我不知道如何创建一个Haskell程序来模拟这个:一个函数创建两个值,后来对其中一个的评估会影响另一个(我认为这些值必须有IO()类型,但我不知道如何把它们放在一起).

好吧,我正在研究Haskell Monads.当我阅读Wikibook 类别理论文章时,我发现monad态射的签名看起来很像逻辑中的重言式,但你需要转换M a为~~A,这里~是逻辑否定.

return :: a -> M a -- Map to tautology A => ~~A, double negation introduction
(>>=) :: M a -> (a -> M b) -> M b -- Map to tautology ~~A => (A => ~~B) => ~~B

其他业务也是重言式:

fmap :: (a -> b) -> M a -> M b -- Map to (A => B) -> (~~A => ~~B)
join :: M (M a) -> M a …

我发现我可以说

{-# LANGUAGE RankNTypes #-}
f1 :: (forall b.b -> b) -> (forall c.c -> c)
f1 f = id f

(和HLint告诉我,我可以在这里做"Eta减少"),但是

f2 :: (forall b.b -> b) -> (forall c.c -> c)
f2 = id

无法编译:

Couldn't match expected type `c -> c'
            with actual type `forall b. b -> b'
Expected type: (forall b. b -> b) -> c -> c
  Actual type: (forall b. b -> b) -> forall b. b -> b
In the expression: id …

我不希望以下代码工作,但作为语法探索的一部分,我在操场上尝试:

fn main() {
    struct EOF {};
    let lines = vec![Ok("line 1"), Ok("line 2"), Err(EOF {})];
    for Ok(line) in lines {
        println!("{}", line);
    }
}

错误消息是

error[E0005]: refutable pattern in `for` loop binding: `Err(_)` not covered
 --> src/main.rs:4:9
  |
4 |     for Ok(line) in lines {
  |         ^^^^^^^^ pattern `Err(_)` not covered

根据上面的消息,看起来我只需要为Err案例添加一个匹配臂.但这样做的正确语法是什么？

我有一个共享对象需要发送到系统API并稍后将其解压缩.系统API仅接收void*.我不能使用shared_ptr :: get(),因为它不会增加引用计数,并且可以在从系统API中提取之前由其他线程释放.发送新的shared_ptr*将起作用,但涉及额外的堆分配.

一种方法是让对象派生自enable_shared_from_this.但是,因为此类模板仅拥有weak_ptr,所以仅保持释放对象是不够的.

所以我的解决方案如下所示:

class MyClass:public enable_shared_from_this<MyClass> {
private:
    shared_ptr<MyClass> m_this;
public:
    void *lock(){
        m_this=shared_from_this();
        return this;
    }
    static shared_ptr<MyClass> unlock(void *p){
        auto pthis = static_cast<MyClass *>(p);
        return move(pthis->m_this);
    }
/* ... */
}

/* ... */
autp pobj = make_shared<MyObject>(...);
/* ... */
system_api_send_obj(pobj->lock());
/* ... */
auto punlocked = MyClass::unlock(system_api_reveive_obj());

有没有更简单的方法来做到这一点？

这个解决方案的缺点:

• 除了基类中shared_ptr<MyClass>的a 之外,它还需要在MyClass对象布局中添加一个.weak_ptrenable_shared_from_this

• 正如我在评论中提到的,访问lock()和unlock()同时不安全.

• 最糟糕的是,这个解决方案只能lock()在呼叫之前支持一次unlock().如果要将同一对象用于多个系统API调用,则必须实现其他引用计数.

如果我们有另一个enable_lockable_shared_from_this类,那将是更大的:

class MyClass:public enable_lockable_shared_from_this<MyClass> {
/* ... …

某些数据库引擎（例如 Microsoft Access）支持FIRST()聚合函数，我在知道该列在组中只有一个值的情况下使用它。

数据库引擎可能可以对此进行优化，就好像它达到任何值一样，它可以将该值标记为已计算。因此，令人惊讶的是为什么 Oracle 或 SQL Server 等中不支持这一点，更重要的是，SQL 标准也不支持这一点。

实际中，人们用MIN()orMAX()代替，但都要求

1. 下面的数据类型具有自然的排序语义，并且排序对用户来说很重要；

2. 数据库引擎必须将中间值与每行中的值进行比较

所以在很多情况下这并不是最优的。

人们有什么不想允许的具体原因吗SELECT ANY(FIELD) ...？（我可以想到两种变体：ANY()给出结果集中该列不为空的任何值；FIRST()给出结果集中第一行的列值，如果没有行则给出 null）