小编kfm*_*e04的帖子

我有一个经常出现的代码块,我循环遍历所有成员enum class.

for与新的相比,我目前使用的循环看起来非常笨拙range-based for.

有没有办法利用新的C++ 11功能来减少当前for循环的详细程度？

我希望改进的当前代码:

enum class COLOR
{
    Blue,
    Red,
    Green,
    Purple,
    First=Blue,
    Last=Purple
};

inline COLOR operator++( COLOR& x ) { return x = (COLOR)(((int)(x) + 1)); }

int main(int argc, char** argv)
{
  // any way to improve the next line with range-based for?
  for( COLOR c=COLOR::First; c!=COLOR::Last; ++c )
  {
    // do work
  }
  return 0;
}

换句话说,如果我可以做以下事情会很好:

for( const auto& c : COLOR )
{
  // …

背景

我正在尝试使用NSCoding协议对String样式的枚举进行编码,但是我遇到了从String转换回来的错误.

解码和编码时出现以下错误:

字符串不可转换为Stage

额外参数ForKey:在电话中

码

    enum Stage : String
    {
        case DisplayAll    = "Display All"
        case HideQuarter   = "Hide Quarter"
        case HideHalf      = "Hide Half"
        case HideTwoThirds = "Hide Two Thirds"
        case HideAll       = "Hide All"
    }

    class AppState : NSCoding, NSObject
    {
        var idx   = 0
        var stage = Stage.DisplayAll

        override init() {}

        required init(coder aDecoder: NSCoder) {
            self.idx   = aDecoder.decodeIntegerForKey( "idx"   )
            self.stage = aDecoder.decodeObjectForKey(  "stage" ) as String    // ERROR
        }

        func encodeWithCoder(aCoder: NSCoder) {
            aCoder.encodeInteger( …

随着它的出现std::unique_ptr,瑕疵std::auto_ptr最终可以得到休息.所以在过去的几天里,我一直在改变我的代码以使用智能指针并delete从我的代码中消除所有代码.

虽然valgrind说我的代码是内存清晰的,但智能指针的语义丰富性将使代码更清晰,更易于理解.

在大多数代码中,转换很简单:std::unique_ptr用于代替拥有对象持有的原始指针,抛弃delete,仔细撒取get(),reset()并move()根据需要调用,以便与其余代码良好地连接.

我现在正在将非拥有原始指针转换为智能指针.

由于我小心对象的生命周期(我确保我的模块只依赖于一个方向),valgrind告诉我,我没有任何未初始化的读取,悬空指针或泄漏.所以,从技术上讲,我现在可以单独留下那些非拥有的原始指针.

但是,一种选择是将那些非拥有的原始指针更改为,std::shared_ptr因为我知道它们是非循环的.或者,将它们留作原始指针会更好吗？

我需要智能指针的资深用户提供一些建议,告诉你使用什么经验法则来决定是否保留非拥有的原始指针,或将它们翻译成std::shared_ptr,请记住我经常进行单元测试和valgrind我的码.

编辑:我可能误解了它的使用std::shared_ptr- 它们是否可以结合使用std::unique_ptr,或者如果我使用的话std::shared_ptr,所有句柄也应该是这样的情况std::shared_ptr？

这些定义std::atomic<>似乎表明其对原始或POD类型的明显有用性.

你什么时候才能将它用于课堂？

什么时候应该避免将它用于课堂？

我目前的实施,简化:

#include <string>
#include <memory>

class Log
{
  public:
    ~Log() {
      // closing file-descriptors, etc...
    }
    static void LogMsg( const std::string& msg )
    {
      static std::unique_ptr<Log> g_singleton;
      if ( !g_singleton.get() )
        g_singleton.reset( new Log );
      g_singleton->logMsg( msg );
    }
  private:
    Log() { }
    void logMsg( const std::string& msg ) {
      // do work
    }
};

总的来说,我对此实现感到满意,因为:

• 懒惰的实例化意味着我不付钱,除非我使用它
• 使用unique_ptr意味着自动清理,因此valgrind很高兴
• 相对简单,易于理解的实施

但是,负面因素是:

• 单身人士不利于单元测试
• 在我的脑海中引入一种伪全局(一点代码气味)的不和谐

所以这里是我的问题针对那些成功从他们的C++代码中驱逐所有单例的开发人员:

• 您在应用程序范围的日志记录中使用什么类型的非Singleton实现？
• 接口是否像上面的Log :: LogMsg()调用一样简单易用？

我想避免在我的代码中传递一个Log实例,如果可能的话 - 注意:我问,因为,如果有一个好的,合理的选择,我也想从我的代码中驱除所有Singletons.

我是否有一种标准方法可以在编译时在c ++ 11中的无符号索引上选择类型？

例如,类似于:

using type_0 = static_switch<0,T,U>;  // yields type T
using type_1 = static_switch<1,T,U>;  // yields type U

如果有一个variadic-template版本,那将非常有用.

据我了解,在当前的C++ 11规范中,应该使用:

• std::unique_ptr<> 对于一个所有者(大多数时间)
• std::shared_ptr<> 只有在非循环结构中有多个所有者时
• std::weak_ptr<> 只有在有需要打破的循环时才会谨慎
• 当引用不够时,原始指针作为内存句柄(无所有权)

所以我的问题是:

1. 这些政策是否足够或是否有我应该注意的其他政策？
2. 是scoped_ptr<>和auto_ptr<>有效地过时了？

假设我有以下代码我想重构:

int toFuture()
{
  precalc();
  int calc = 5 * foobar_x() + 3;
  postcalc();
  return calc;
}

int toPast()
{
  precalc();
  int calc = 5 * foobar_y() - 9;
  postcalc();
  return calc;
}

在classic-C中,我将这个代码重构为一个worker(),它接受一个执行计算的函数指针:worker()中的公共代码,函数指针提供的特定代码.

使用C++ 11,我应该使用lambda吗？如果是这样,在这种情况下我将如何实现它？

编辑:我只是想到一个模板也可以工作.模板实现如何与其他两个进行比较？

$ git branch
  develop
* feature/bug_76
  master
$ git branch -r
  origin/HEAD -> origin/master
  origin/develop
  origin/feature/implement_IBResponder
  origin/master
  origin/origin
  origin/sculptor_strategy

在当地,我很好.我想删除原产地上的所有内容,所以我尝试:

$ git push origin :origin/sculptor_strategy
error: unable to delete 'origin/sculptor_strategy': remote ref does not exist
error: failed to push some refs to 'git@gitlab:pitbull.git'

我究竟做错了什么？

(Wild Guess)是什么原产地的一些本地缓存？

回答

事实证明这是一个红鲱鱼 - 问题是,我的本地缓存是陈旧的,我怀疑.以下两个答案都可以.

有一个很好的C++解决方案(实际上是2个解决方案:递归和非递归),是一个整数向量向量的笛卡尔积.出于说明/简单的目的,让我们只关注非递归版本.

我的问题是,如何用模板推广这个代码来获取std::tuple看起来像这样的同类向量:

{{2,5,9},{"foo","bar"}}

并生成一个齐次的矢量 tuple

{{2,"foo"},{2,"bar"},{5,"foo"},{5,"bar"},{9,"foo"},{9,"bar"}}

如果它让生活更容易,让我们假设输入中的内部向量都是同质的.所以不允许这样的输入: {{5,"baz"}{'c',-2}}

编辑将输入从锯齿状矢量更改为元组