小编mar*_*ark的帖子

我刚看了Chandler在2012年Going Native上对Clang的演讲.他提出了以下代码:

#include <iostream>

struct S{ int n; };
struct X{ X(int) {}; };

void f( void* ) 
{
   std::cerr << "Pointer!\n";
}

void f( X ) 
{
   std::cerr << "X!\n";
}

int main()
{
    f(S().n);
}

Chandler声称这需要f(void*)c ++ 11和f(X)c ++ 03.他还说,原因是S().n默认初始化为0,使其成为nullptr常数.

首先,我正确地假设成员变量n的零初始化是依赖于编译器实现的并且不是由标准保证(或者用c ++ 11进行了这种改变)？钱德勒暗示这是由于对持续表达的支持,但我仍然不能完全遵循他的推理.

其次,为什么f(X)要用C++ 03而不是c ++ 11调用？我认为f(void*)无论S().n隐含转换的价值如何,都会启动X

对于Chandler的解释,请参阅以下链接,45分钟:

Clang:从Murphy的Million Monkeys中捍卫C++

我正在使用C++ Concurrency in Action中的一个示例,它std::memory_order_relaxed用于从5个不同的线程读取和写入3个原子变量.示例程序如下:

#include <thread>
#include <atomic>
#include <iostream>

std::atomic<int> x(0);
std::atomic<int> y(0);
std::atomic<int> z(0);
std::atomic<bool> go(false);

const unsigned int loop_count = 10;

struct read_values
{
   int x;
   int y;
   int z;
};

read_values values1[loop_count];
read_values values2[loop_count];
read_values values3[loop_count];
read_values values4[loop_count];
read_values values5[loop_count];

void increment( std::atomic<int>* v, read_values* values )
{
    while (!go)
       std::this_thread::yield();

    for (unsigned i=0;i<loop_count;++i)
    {
       values[i].x=x.load( std::memory_order_relaxed );
       values[i].y=y.load( std::memory_order_relaxed );
       values[i].z=z.load( std::memory_order_relaxed );
       v->store( i+1, std::memory_order_relaxed );
       std::this_thread::yield();
    }
}

void read_vals( read_values* …

我目前正在编写一个接口类,它应该提供对复杂结构的内部元素的访问,作为const或非const引用.这个想法是一些模块被授予const访问权限,一些模块被授予完全访问权限.

我已经使用'type_traits''std :: add_const'来有条件地限定内部成员函数的返回类型,遗憾的是我无法想到一种有条件地将成员函数定义为const或非const的方法.

这甚至可能吗？如果是这样的话？

例如:

template< typename T, bool isConst  >
struct apply_const
{
    typedef T type;
};

template<typename T>
struct apply_const<T, true>
{
    typedef typename std::add_const<T>::type type;
};

template< bool isConst >
const Interface
{
    /// @brief get the TypeA member
    typename apply_const<TypeA, isConst >::type& GetXpo3Container()  // how do I conditionally add a const qualifier
    {
        return config_.type_a_member_;
    }

    typename apply_const<Profile, isConst >::type& GetProfile( unint32_t id )  // qualifier ???
    {
        return config_.profiles.get( id );
    }

    // .... …

如何使用gnu-make从传递给用户定义函数的参数中去除前导空格？

例如:

define FOO
# --- some build rules

# run the built target
/home/user/dir/bin/$(1)

endef

以下调用正常,因为没有前导空格:

$(eval $(call FOO,my_test ) )

不幸的是,以下失败,因为$(1)有一个领先的空间

$(eval $(call FOO, my_test ) )
                  ^
                Additional space to 'prettier' formatting

这最终扩展到:

/home/user/dir/bin/ $(1)
                   ^
                 Leading whitespace

如何从传递给用户定义函数的参数中去除前导空格？

这样做是不好的形式还是我应该简单地假设参数是在没有前导空格的情况下传递的？

我试图在boost::phoenix缺乏C++ 11支持的旧编译器上模拟C++ lambda表达式,我无法从lambda表达式中调用一个简单的函数.

C++ 11版本:

[](unsigned a) { foo( a ); }( 12678u );   // calls foo( 12678u )

我的Phoenix Lambda代码如下:

#include <cstdint>
#include <iostream>
#include <boost/phoenix.hpp>

namespace ph = boost::phoenix;
using ph::local_names::_a;
using ph::placeholders::arg1;

void foo( uint32_t val )
{
   std::cout << "\t" << __func__ << "( " << val << " ) called...\n";
}

int main()
{
   auto myLambda = ph::lambda( _a = arg1 )
      [
          foo( _a )
          //std::cout << ph::val( "Called with: " ) …

我正在尝试使用可变参数模板进行类组合.这个想法是Composer该类简单地聚合了许多变量并将函数调用转发给所有实例化的变量.

首先,我使用以下简单的包装类:

template< typename T >
struct WrapperType
{
    typedef T wrapped_type;
    typedef typename wrapped_type::value_type value_type;
    wrapped_type wrapee_;

    WrapperType() : wrapee_{}
    {}
};

这与下面的Composer类一起使用,希望从WrapperType参数包中的每个类型实例化派生Args:

template< typename... Args >
struct Composer : public WrapperType<Args>...
{
    Composer() : WrapperType<Args>{}...
    {}

    void display()
    {
        ((WrapperType<Args>...)::wrapee_).display();   // HOW?
    }
};

假设每个包装类型都有一个display()成员函数,如何display()为参数包中的每个类型调用该函数？

IE如果我有:

Composer< T1, T2, T3 > myComposer{};
myComposer.display();  

我想myComposer.display()呼吁display()的T1,T2,T3.

我有一个简单的包装模板，允许自由函数（例如open() close()等）作为模板参数传递。代码如下：

template <auto fn, typename ReturnType=void>
struct func_wrapper {

    template<typename... Args>
    constexpr ReturnType operator()(Args&&... args) const {
        if constexpr( std::is_same<ReturnType, void>::value) {
            fn(std::forward<Args>(args)...);
        } else {
            return fn(std::forward<Args>(args)...);
        }
    }
};

其用法如下：

    void CloseFunc2(int a);
    into OpenFunc2(const std::string&, int flags);

    using FileWrapper2 = DevFileWrapper<func_wrapper<OpenFunc2, int>,
                                        func_wrapper<CloseFunc2>>;

该代码工作正常，但我想删除ReturnType创建func_wrapper.

我尝试使用std::result_of但失败了，因为fn它是非类型模板参数，例如：

template<typename... Args>
constexpr auto operator()(Args&&... args) const 
    -> std::invoke_result<fn(std::forward<Args>(args)...)>::type {
    if constexpr( std::is_same<ReturnType, void>::value) {
        fn(std::forward<Args>(args)...);
    } else {
        return fn(std::forward<Args>(args)...); …