小编Ger*_*ago的帖子

摘自cppcon2015的幻灯片:

unique_ptr<A> f() {
   auto a = make_unique<A>();
   return a;
}

//Why does this even compile?
const A & dangling = *f(); 

//BOOM!!!
use(dangling);

我的问题是:对于*this的rvalue引用,这可以解决吗？

我在cppreference的spec中看到:

typename std::add_lvalue_reference<T>::type operator*() const;

题:

1. 拒绝operator*rvalue 是否有意义unique_ptr并且只有对于左值有效的解引用unique_ptr？
2. 还有一些有效的用例可以保持rvalue可unique_ptr解除引用吗？

像这样:

//Make sure it is an lvalue.
typename std::add_lvalue_reference<T>::type operator*() const &;

注意:我不确定语法或正确性,我对*this的rvalue引用没有经验.

我对异步编程不是很熟悉，我有一个问题。

我的问题如下。鉴于 boost.asio 中 C++11 的 echo_server 示例：http : //www.boost.org/doc/libs/1_60_0/doc/html/boost_asio/example/cpp11/spawn/echo_server.cpp

我想知道是否std::make_shared<session>可以用C++14中的a替换C++14中的a std::unique_ptr<session>，避免引用计数的开销。

我不确定，因为我们有shared_from_this()但没有类似的东西unique_from_this()，所以我如何unique_ptr<session>从内部访问this？。

我的问题很简单.在C++ 11我们有std::mutex和std::lock_guard和std::unique_lock.

使用这些类的常用方法是锁定std::mutex任何锁.这可以防止因异常抛出而导致的互斥量泄漏:

{
   std::lock_guard<std::mutex> l(some_mutex);
   //Cannot leak mutex.
}

为什么std::mutex::lock和std::mutex::unlock公开？这要求使用不正确:

{ 
     some_mutex.lock();
     //Mutex leaked due to exception.
     some_mutex.unlock();
}

制作std::lock_guard和std::unique_lock朋友std::mutex制作std::mutex锁定操作是不是更安全？这样可以防止不安全的使用.

我猜这个设计的唯一原因是,如果我有自己的锁,它就无法使用,std::mutex因为我无法成为我自己的锁友std::mutex.这是将这些成员函数公开的主要原因吗？

问题很简单:看看代码.两个静态断言都通过了.我不希望第二个通过.这是一个错误还是正常行为？

#include <array>
#include <type_traits>

template <template <class...> class Temp, class Specialization>
struct IsSpecialization : std::false_type {};

template <template <class...> class Temp, class... Ts>
struct IsSpecialization<Temp, Temp<Ts...>> : std::true_type {};

template <class...Args>
struct A {};

template <class...Args>
using AT = A<Args...>;


int main() {
    static_assert(IsSpecialization<A, A<int>>{});
    static_assert(!IsSpecialization<AT, AT<int>>{});
}

我试图看一下r7rs的状态,但我在计划报告页面等中找不到任何信息,只是2013年的一次演讲.我搜索谷歌也没有成功.

• 还活着吗？
• 我在哪里可以找到信息？
• 暂定日期是什么？
• 目前进展如何？

谢谢.

我有一个设备可以传输一些事件.我想使用反应式扩展来模拟以下行为:

1. 检测用户何时连接加密狗(我的程序检查加密狗连接的事件).
2. 连接加密狗后,开始从加密狗捕获数据流.
3. 能够检测到加密狗何时断开连接并返回1.,如果用户再次连接加密狗,我想转到2.如果键盘被击中我流数据的状态,则程序结束.

我知道如何等待加密狗连接(1.):

auto waitForDongle = events.take_while([](auto const & event) {
      return event == DongleConnected
      }).subscribe([](auto) {});

我知道如何捕获流(2.):

auto streamMotionData = events.take_while([](auto const &) { return !keyboardPressed(); })
    .map([](auto const & evt) -> boost::optional<std::vector<double>> {
            ...
            return data;
        }).subscribe([](vector<double> const &) { ...});

我的问题是我不知道如何组合流以便回到1.以及之后2.我只知道如何一次又一次地执行此操作.但我想要上述行为.

问题很简单.

这是模板化operator = for的声明std::any:

template<typename ValueType>
any& operator=( ValueType&& rhs );

我希望它是:

template<typename ValueType>
any& operator=( ValueType&& rhs ) noexcept(noexcept(std::declval<std::any>() = std::forward<ValueType>(std::declval<ValueType>()));

也就是说,如果您可以以noexcept方式将ValueType复制分配给任何一个,那么您应该能够使用noexcept.

也许我错过了什么.

我的计划的事实

1. Cocos2d-x主循环在自己的线程中运行.我们称之为cocos2d-x-thread.
2. 我有一个task_scheduler在自己的线程中运行,您可以在其中提交轻量级任务.我们称之为task_scheduler-thread.
3. 每隔x毫秒,就会从task_scheduler线程发出一个回调.我们称之为task_scheduler-tick-callback.

我想做的事

我想在发出task_scheduler-tick-callback时加载一个sprite ,但是我不能从那个线程中执行它,所以我必须提交一些由cocos2d-x线程执行的工作.

问题

1. 如何在接收此工作时使cocos2d-x-thread被执行？因为cocos2d-x已经运行了自己的循环,我想避免不惜一切代价将自定义代码注入cocos2d-x生成的项目.

任何模式？

编辑:想法 - >在cocos2d-x中为每个循环迭代调用的任何回调函数？那存在吗？我可以集成在调用我的工作片那样.

我最近对DSL很感兴趣,特别是如何在Lisp中实现它们,因为它看起来像是替代品中的小菜一碟.

寻找信息我在互联网上的Lisp中找不到任何非lisp DSEL的证据.

所以我的问题是:

• 是否可以使用宏在lisp中实现具有非lisp语法的DSL？

• 这是如何实现的？

• lisp的读者可以用自定义读取器替换,将代码转换为lisp结构吗？

  • 如果前者是真的:这是实现"非lispy"DSEL的常用方法吗？

我正在使用精彩的org-babel包用于emacs.

我想为C++代码生成一些没有主函数的代码,但我无法弄清楚如何去做.

#+begin_src C++ :tangle MyClass.h
namespace ns {
    class MyClass {};
}
#+end_src

这将产生:

int main() {
    namespace ns {
       class MyClass {};
    }
}

有没有办法可以指示org-babel不生成主要功能？我无法在任何地方找到任何文档或提示.

任何允许我内联org文件中的代码并在没有评估的情况下纠缠它的替代方案对我当前的问题也是一个解决方案.

我只是尝试使同一帧中的两个块一次显示一个，同一帧，但投影仪应该生成 2 张幻灯片。我不知道怎么办。orgmode的文档对我来说还不够。

我将非常感激了解如何在某个时刻暂停幻灯片，...如果可能的话，与 Pandoc 中的一样。我不确定在使用投影仪的组织模式下这是否可能。

我的例子如下：

我有这样的东西，我希望一次显示每个列。我的设置是H:3针对帧级别的。

*** Continuous integration with Jenkins
  :PROPERTIES:
  :BEAMER_env: theorem
  :END:
**** Jenkins
    :PROPERTIES:
    :BEAMER_col: 0.65
    :END:
     [[./jenkins-dashboard.png]]
**** Jenkins
    :PROPERTIES:
    :BEAMER_col: 0.35
    :END:
     #+ATTR_BEAMER: :overlay +-
     - contiuosly building
     - latest failure
     - latest success
     - build durations

http://orgmode.org/worg/exporters/beamer/tutorial.html中的“3.4 使用 Babel”中的示例根据我的需要进行了调整（更改了帧级别）似乎也不起作用。

我boost.future<T>在 boost 1.56 中使用了 continuation。

我有一个返回未来的 API，我想从延续内部使用它。所以理论上，我需要.unwrap在链接第二个延续之前的未来。

所以我执行以下操作：

auto result = api_returns_future().then([](boost::future<R> && result) {
                    do_something_with_result();

                    //Note I could call .get() here, but I don't
                    return api_returns_future();
              }).unwrap() //Now I unwrap the future here
              .then([](boost::future<R> && result) { ... });

也就是说，我有：

1. future<R>::then
2. 在第一个延续中，我使用返回 a 的 API 调用从 lambda 返回boost::future<R>，然后我解开它。
3. 之后我想附加另一个延续，但从未调用过这个延续。

题：

1. 在第一个延续中这样做是正确的：（return api_returns_future().get()注意我.get()直接从延续内部调用`并放弃解包？。这个替代方案是否对我的代码的异步性有一些缺点？

编辑：我更新了问题以更好地反映经过更多研究后我想问的问题。

谢谢

我试图将其减少到最低限度:

#include <array>

template <std::size_t N>
void f(int, std::array<int, N> const & =
       std::array<int, 0>()) {
}


int main() {
    f(10);
}

array_test.cpp:4:6:注意:模板参数推断/替换失败:array_test.cpp:10:9:注意:无法推导出模板参数'N'f(10);

为什么这会失败？我不明白:它应该可以从默认参数中推断出来.我需要一个解决方法.