小编Fre*_*urk的帖子

C++ 0x的ranged-for循环有一个处理数组的特殊异常(FDIS§6.5.4),并且有两个函数std :: begin和end,它们被重载以处理数组或选择开始/结束方法.这使我相信可以编写接受通用序列的函数来匹配ranged-for循环的行为:

template<class C>
void f(C &c) {
  using std::begin;
  using std::end;
  do_something_with(begin(c), end(c));
}

如果在C的命名空间中有一个"更具体"的开始/结束,它将通过ADL选择,否则代码"默认"为std :: begin/end.

但是,有一个原因,因为有特殊例外.如果在命名空间中传递一个类型的数组,其中一个语义不同的begin/end接受一个指针,则不会选择std :: begin/end的数组形式:

namespace ns {
  struct A {};
  void begin(A*);  // Does something completely different from std::begin.
}

void f_A() {  // Imagine above f() called with an array of ns::A objects.
  ns::A c[42];
  using std::begin;
  begin(c);  // Selects ns::begin, not array form of std::begin!
}

为了避免这种情况,有没有比编写我自己的开始/结束包装器(内部使用ADL)并显式调用它们而不是std :: begin或ADLized begin更好的解决方案？

namespace my {
  template<class T>
  auto begin(T &c)  // …

到目前为止,我一直在使用gcc,g ++进行C,C++应用程序开发,并发现它非常棒.但是浏览Stack Overflow我发现许多成员声称Comeau编译器中的错误报告比任何其他编译器都要多得多.这是真的？我没有投资任何编译器的商业版本.当gcc,g ++正在做的时候,真的值得在C/C++编译器的商业版本上花钱吗？

如果一个静态数据成员依赖于另一个静态数据成员,C#/ .NET是否保证依赖成员之前初始化依赖的静态成员？

例如,我们有一个类,如:

class Foo
{
    public static string a = "abc";

    public static string b = Foo.a + "def";
}

当访问Foo.b时,它总是"abcdef"还是"def"？

如果不能保证,有没有更好的方法来确保首先初始化depen成员？

我现在正在与下面的提案作斗争,我想知道合法的,在较小程度上反对它的道德论点.

我们有什么:

#include <vector>

class T;

class C
{
public:
    C() { }
    ~C( ) { /*something non-trivial: say, calls delete for all elements in v*/ }
    // a lot of member functions that modify C
    // a lot of member functions that don't modify C
private:
    C(C const &);
    C& operator=(C const&);
private:
    std::vector< T* > v;
};

void init(C& c) { } // cannot be moved inside C

// ...
int main()
{
    // bad: two-phase initialization exposed …

是否有任何编译器能够通过std :: tuple对函数返回的多个值进行返回值优化？需要说明的是,在下面的代码中,是否有任何编译器能够避免不必要的副本？

std::vector<int> a;
std::list<float> b;
std::tie(a,b) = myFunctionThatReturnsAVectorAndList();

我在读" 想要速度"？在C++ Next博客上传递Value并创建此程序以了解复制省略并在C++ 0x中移动语义:

#include <vector>
#include <iostream>

class MoveableClass {
public:
    MoveableClass() : m_simpleData(0), instance(++Instances) {
        std::cout << "Construct instance " << instance << " (no data)" << std::endl;
    }

    MoveableClass(std::vector<double> data) : m_data(std::move(data)), m_simpleData(0), instance(++Instances) {
        std::cout << "Construct instance " << instance << " (with data)" << std::endl;
    }

    MoveableClass(int simpleData) : m_simpleData(simpleData), instance(++Instances) {
        std::cout << "Construct instance " << instance << " (with simple data)" << std::endl;
    } …

我正在尝试使用SFINAE来检测某个类是否具有需要特定类型的重载成员函数.我的代码似乎在Visual Studio和GCC中正常工作,但不使用Comeau在线编译器进行编译.

这是我正在使用的代码:

#include <stdio.h>

//Comeau doesnt' have boost, so define our own enable_if_c
template<bool value> struct enable_if_c { typedef void type; };
template<> struct enable_if_c< false > {}; 


//Class that has the overloaded member function
class TestClass
{
public:
    void Func(float value) { printf( "%f\n", value ); }
    void Func(int value) { printf( "%i\n", value ); }
};


//Struct to detect if TestClass has an overloaded member function for type T
template<typename T>
struct HasFunc
{
    template<typename U, void …

Koenig查找的基本原理是什么？

无法避免将其视为使您的代码更难以阅读且更不稳定的东西.

他们不能定义Koenig查找,以便它只适用于特定情况(即:非成员运营商)或明确要求时？

借用Howard Hinnant的例子并将其修改为使用copy-and-swap,这是op =线程安全吗？

struct A {
  A() = default;
  A(A const &x);  // Assume implements correct locking and copying.

  A& operator=(A x) {
    std::lock_guard<std::mutex> lock_data (_mut);
    using std::swap;
    swap(_data, x._data);
    return *this;
  }

private:
  mutable std::mutex _mut;
  std::vector<double> _data;
};

我相信这个线程安全(记住op =的参数是通过值传递的),我能找到的唯一问题是在地毯下扫描的那个:复制ctor.但是,它是一种罕见的类,它允许复制赋值而不是复制构造,因此在两种选择中都存在同样的问题.

鉴于自我分配是如此罕见(至少在这个例子中)我不介意额外的副本如果发生,考虑这个!=&rhs的潜在优化要么可以忽略不计,要么是悲观化.与原始策略(下面)相比,是否还有其他理由更喜欢或避免它？

A& operator=(A const &rhs) {
  if (this != &rhs) {
    std::unique_lock<std::mutex> lhs_lock(    _mut, std::defer_lock);
    std::unique_lock<std::mutex> rhs_lock(rhs._mut, std::defer_lock);
    std::lock(lhs_lock, rhs_lock);
    _data = rhs._data;
  }
  return *this;
}

顺便说一句,我认为这简洁地处理了复制文件,至少在本课程中,即使它有点迟钝:

A(A const &x) : _data {(std::lock_guard<std::mutex>(x._mut), x._data)} {}

给定遗留代码,系统具有以下类的层次结构:

          Base
          ^
          |
----------+---------------
^      ^     ^     ^     ^ 
|      |     |     |     |
A1     B1    C1    D1    E1
^      ^     ^     ^     ^ 
|      |     |     |     |
A2     B2    C2    D2    E2
.......
^      ^     ^     ^     ^ 
|      |     |     |     |
An     Bn    Cn    Dn    En

层次结构表示某个特定域中的消息.

基类当然是所有消息的基类.A1..E1是属于域的版本1,A2..E2到版本2的消息,依此类推.请注意,An必须直接从An-1继承,因为An会覆盖An-1的特定方法.

所有消息都有一些共同的功能,因此它被定义为Base :: PerformFunctionality.功能的某些部分仅特定于版本n,因此存在虚函数Base :: SpecificPartOfFunctionality,它由Base :: PerformFunctionality调用.

所以我的问题是如何通过所有An..En 覆盖Base :: SpecificPartOfFunctionality.

我看到了两种可能的解决方案,我不太喜欢它们:

1. 在每个An..En中实现Base :: SpecificPartOfFunctionality …