小编Ste*_*mer的帖子

我有一个std::future在一个线程,正在等待std::promise在另一个线程中设置.

编辑: 使用示例应用程序更新了问题,该应用程序将永久阻止:

更新:如果我使用一个pthread_barrier代替,下面的代码并没有阻止.

我创建了一个测试应用程序,说明了这一点:

非常基本类foo创建一个在其run函数中thread设置a promise,并在构造函数中等待promise设置它.设置后,它会递增atomic计数

然后我创建了一堆这些foo对象,将它们拆掉,然后检查我的count.

#include <iostream>
#include <thread>
#include <atomic>
#include <future>
#include <list>
#include <unistd.h>

struct foo
{
    foo(std::atomic<int>& count)
        : _stop(false)
    {
        std::promise<void> p;
        std::future <void> f = p.get_future();

        _thread = std::move(std::thread(std::bind(&foo::run, this, std::ref(p))));

        // block caller until my thread has started 
        f.wait();

        ++count; // my thread has started, increment the count …

是否有人知道如何在Eclipse CDT中的宏扩展弹出窗口中更改突出显示颜色？颜色为浅灰色,对于那些匹配项目,它显示在"原始"和"完全展开"视图中.

我没有在任何偏好选项中找到它:(

代码悬停背景可以更改:

宏扩展背景无法更改:

我已经看到这个问题允许人们检查是否存在成员函数,但我试图找出一个类是否有成员类型.

在下面的示例中,两者都评估为"false",但我想找到一种方法,以便has_bar<foo1>::value计算为false,并has_bar<foo2>::value计算为true.

这可能吗？

#include <iostream>

struct foo1;
struct foo2 { typedef int bar; };

template <typename T>
class has_bar
{
    typedef char yes;
    typedef long no;

    template <typename C> static yes check( decltype(&C::bar) ) ;
    template <typename C> static no  check(...);
public:
    enum { value = sizeof(check<T>(0)) == sizeof(yes) };
};

int main()
{
    std::cout << has_bar<foo1>::value << std::endl;
    std::cout << has_bar<foo2>::value << std::endl;
    return 0;
}

编辑:实施专业化以回应以下答案: …

C++ 14 在关联容器中引入Compare::is_transparent了等效的查找操作.

template< class K > iterator       find( const K& x );
template< class K > const_iterator find( const K& x ) const;

查找具有键的元素,该元素与值x进行比较.如果qualified-id Compare :: is_transparent有效并且表示类型,则此重载仅参与重载解析.它允许在不构造Key实例的情况下调用此函数

由于不再Key构造临时实例,因此这些实例可以更高效.

对于无序容器,似乎没有等价物.

为什么没有Compare::key_equal/ Compare::hash_equal？

我想,有效查找例如无序容器中的字符串文字会相对简单吗？

template<>
struct hash<string>
{
    std::size_t operator()(const string& s) const 
    {
        return ...;
    }
    // hash_equal=true allows hashing string literals
    std::size_t operator()(const char* s) const
    {
        return ...;
    }
};

是否有可能告诉cmake链接静态库而不是共享？

在我的顶部,我CMakeLists.txt有以下配置:

set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES})

后来,我添加了一个二进制文件,并告诉它tcmalloc在发布模式下链接:

target_link_libraries(${BIN_NAME} optimized tcmalloc_minimal)

生成的makefile链接共享版本tcmalloc:

$ make VERBOSE=1 | grep tcmalloc
/usr/bin/c++ ... -Wl,-Bdynamic ltcmalloc_minimal 

进一步证明:

$ ldd app 
    ...
    libtcmalloc_minimal.so.4 => /usr/local/lib/libtcmalloc_minimal.so.4 (0x00007eff89733000)
    ...

tcmalloc的静态和共享版本都存在:

$ ls -1 /usr/local/lib/libtcmalloc_minimal*
/usr/local/lib/libtcmalloc_minimal.a
/usr/local/lib/libtcmalloc_minimal_debug.a
/usr/local/lib/libtcmalloc_minimal_debug.la
/usr/local/lib/libtcmalloc_minimal_debug.so
/usr/local/lib/libtcmalloc_minimal_debug.so.4
/usr/local/lib/libtcmalloc_minimal_debug.so.4.2.6
/usr/local/lib/libtcmalloc_minimal.la
/usr/local/lib/libtcmalloc_minimal.so
/usr/local/lib/libtcmalloc_minimal.so.4
/usr/local/lib/libtcmalloc_minimal.so.4.2.6

题:

如何配置cmake链接静态版本tcmalloc？

是否有可能有一些抽象接口的部分实现,然后通过使用多个继承将这些部分实现收集到一个具体的类中？

我有以下示例代码:

#include <iostream>

struct Base
{
    virtual void F1() = 0;
    virtual void F2() = 0;
};

struct D1 : Base
{
    void F1() override { std::cout << __func__ << std::endl; }
};

struct D2 : Base
{
    void F2() override { std::cout << __func__ << std::endl; }
};

// collection of the two partial implementations to form the concrete implementation
struct Deriv : D1, D2
{
    using D1::F1; // I …

我想辨别静态数组和指针.

由于数组到指针的转换具有完全匹配,以下示例无法编译,这使得两者都成为foo可能的候选者.

我是否能够foo使用类型特征明确选择第二次重载？

#include <iostream>

template<typename T>
void foo(const T* str)
{
    std::cout << "ptr: " << str << std::endl;
}

template<typename T, size_t N>
void foo(const T (&str)[N])
{
    std::cout << "arr: " << str << std::endl;
}

int main()
{
    foo("hello world"); // I would like the array version to be selected
    return 0;
}

虽然今天重构了一些代码以更改原始指针std::unique_ptr,但由于评估错误的顺序,我遇到了分段错误.

旧代码执行如下操作:

void add(const std::string& name, Foo* f)
{
    _foo_map[name] = f;
}

void process(Foo* f)
{
    add(f->name, f);
}

第一个,天真的,重构代码使用std::unique_ptr:

void add(const std::string& name, std::unique_ptr<Foo> f)
{
    _foo_map[name] = std::move(f);
}

void process(std::unique_ptr<Foo> f)
{
    add(f->name, std::move(f)); // segmentation-fault on f->name
}

重构的代码导致分段错误,因为第一个参数(std::move(f))首先处理,然后第一个参数(f->name)取消引用移动变量,繁荣!

可能的解决方法是在调用Foo::name 之前获取句柄add:

void process(std::unique_ptr<Foo> f)
{
    const std::string& name = f->name;
    add(name, std::move(f));
}

也许:

void process(std::unique_ptr<Foo> f)
{
    Foo* …

读马修的回答后在这里,我决定试试这个自己.

我的尝试无法编译,因为SFINAE没有启动并剔除has_foo尝试访问的功能T::foo.

error: ‘struct Bar’ has no member named ‘foo’

我错过了什么,或者是我试图以这种方式做不到的事情？

(我正在使用gcc-4.7.2)

完整示例如下:

#include <iostream>

// culled by SFINAE if foo does not exist
template<typename T>
constexpr auto has_foo(T& t) -> decltype((void)t.foo, bool())
{
    return true;
}
// catch-all fallback for items with no foo
constexpr bool has_foo(...)
{
    return false;
}
//-----------------------------------------------------

template<typename T, bool>
struct GetFoo
{
    static int value(T& t)
    {
        return t.foo;
    }
};
template<typename T>
struct GetFoo<T, false>
{ …

一个简单的linux多线程程序.在其中一个线程中,我启动一个计时器,计时器将SIGRTMIN发送到该线程.

当使用eclipse gdb进行调试时,线程将始终被SIGRTMIN挂起,恢复后,程序运行良好.

出了eclipse gdb,一切顺利.有人可以帮忙吗？