小编wco*_*ran的帖子

我想通过添加适当的退化四边形将下图中的五个四边形条带(下面指定为黑色索引)转换为单个四边形条带.增加的灰色指数似乎可以解决问题,但我想知道是否有更紧凑的方式.

下面的lambda函数捕获this(因此bar()可以访问其实例变量)和局部变量a,b,c.

class Foo {
  int x, y, z;
  std::function<void(void)> _func;
  // ...
  void bar() {
     int a,b,c;
     // ...
     _func = [this,a,b,c]() { // lambda func
        int u = this->x + a;
        // ...
     };
  }
};

但是,如果我想捕捉许多实例变量,并希望避免明确的捕获列表命名他们,我也不会似乎能够做到这一点:

     _func = [this,=]() { // lambda func
        // ...
     };

我在=下面遇到编译器错误this,:

  error: expected variable name or 'this' in lambda capture list 

如果我试试这个

     _func = [=,this]() { // lambda func
        // …

JavaScript函数

function tile(u,v, a,b,c,d) {
  var c0 = tileCorners[a].eval(u,v);
  var c1 = tileCorners[b].eval(u-1,v);
  var c2 = tileCorners[c].eval(u,v-1);
  var c3 = tileCorners[d].eval(u-1,v-1);
  return c0 + c1 + c2 + c3;
}

应该相当于

function tile(u,v, a,b,c,d) {
  return
    tileCorners[a].eval(u,v) +
    tileCorners[b].eval(u-1,v) +
    tileCorners[c].eval(u,v-1) +
    tileCorners[d].eval(u-1,v-1);
}

但第二个函数总是返回undefined(调试器不会"进入"调用eval),而第一个函数表现正常.eval在表达式中有多个方法调用是否有问题？

在尝试实现Swift编程指南第35页的"实验"时,我在Xcode游戏中遇到了一个非常奇怪的错误.在该pokerDeck方法中,let card...在从最里面的循环开始的行上,我得到错误Value of optional type 'Rank?' not unwrapped.如何/为什么是Rank可选的？

struct Card {
    var rank : Rank
    var suit : Suit
    init(rank : Rank, suit : Suit) {
        self.rank = rank
        self.suit = suit
    }
    func pokerDeck() -> Card[] {
        let suits = [Suit.Spades, Suit.Clubs, Suit.Hearts, Suit.Diamonds]
        var deck = Card[]()
        for suit in suits {
            for r in 1 ... 13 {
                let card = Card(rank: Rank.fromRaw(r), suit: suit) // ERROR
                deck += …

我试图了解如何NSLayoutManager使用Swift闭包.我可以成功注册undo如下:

doThing();
undoManager?.registerUndoWithTarget(self, handler: { _ in
    undoThing();
}
undoManager?.setActionName("do thing")

当然,我需要支持redo撤消撤销的数量.我能做到:

doThing();
undoManager?.registerUndoWithTarget(self, handler: { _ in
    undoThing();

    undoManager?.registerUndoWithTarget(self, handler: { _ in
        doThing();
    }
    undoManager?.setActionName("do thing")
}
undoManager?.setActionName("do thing")

但现在我需要支持重做的撤消...嗯....好的:

doThing();
undoManager?.registerUndoWithTarget(self, handler: { _ in
    undoThing();

    undoManager?.registerUndoWithTarget(self, handler: { _ in
        doThing();

        undoManager?.registerUndoWithTarget(self, handler: { _ in
             undoThing();
        }
        undoManager?.setActionName("do thing")
    }
    undoManager?.setActionName("do thing")
}
undoManager?.setActionName("do thing")

正如你可以看到它的"乌龟一直向下".我如何摆脱这种疯狂？也就是说,在我能找到的所有示例代码中,人们使用代码的选择器版本来注册一个可以自行撤消的方法 - 这对于我正在使用的闭包方法显然不可行...如何使用闭包版本并获得无限制的撤消/重做？

我正在编写一个OpenCL内核,用5x5高斯滤波器对图像进行卷积,并且想知道存储滤波器常量的最佳实践是什么.在内核中,32x32工作组中的每个线程执行以下操作:

1. 将像素加载到__local内存缓冲区中,
2. 同步通过barrier(CLK_LOCAL_MEM_FENCE),
3. 然后对其对应的像素执行卷积.

以下是本地图像数据和过滤器的缓冲区:

 __local float4 localRegion[32][32]; // image region w 2 pixel apron
 .... 
 static const float filter[5][5] = { // __constant vs __private ??
    {1/256.0,  4/256.0,  6/256.0,  4/256.0, 1/256.0},
    {4/256.0, 16/256.0, 24/256.0, 16/256.0, 4/256.0},
    {6/256.0, 24/256.0, 36/256.0, 24/256.0, 6/256.0},
    {4/256.0, 16/256.0, 24/256.0, 16/256.0, 4/256.0},
    {1/256.0,  4/256.0,  6/256.0,  4/256.0, 1/256.0}
  };

哪种内存区域可以容纳filter,哪种情况最好,以及在每种情况下如何进行初始化？最理想的__private是最好的,但我不知道,你可以静态初始化私有数组？__local没有意义,除非一些线程负责加载filter条目(我认为)？另外,根据khronos docs Sec 6.5,我不确定static也_private可以一起去.

根据这里和这里的答案 …

我正在尝试构想一个C ++数据结构，用于对一个简单的N阶段过程进行建模，其中每个阶段都可以用不同的函数替换。一种方法是使用OO方法，并在每个阶段都有一个带有虚拟方法的抽象基类。例如：

class Pipeline {
protected:
  virtual void processA(const In& in, BType& B) = 0;
  virtual void processB(const BType& B, BType& C) = 0;
  virtual void processC(const CType& C, BType& D) = 0;
  virtual void processD(const DType& D, Out& out) = 0;
public:
  void process(const In& in, Out& out) {
    Btype B;
    processA(in, B);
    Ctype C;
    processB(B, C);
    Btype D;
    processC(C, D);
    processD(D,out);
  }
};

这种方法的问题是，如果N个阶段中的每一个都可以与M个过程互换，那么您就有N * M个可能的子类。

另一个想法是存储函数对象：

class Pipeline {
public:
  std::function<void(const In& in, BType& B)> processA;
  std::function<void(const …

斯威夫特提供map,filter,reduce,...对Array的,但我没有找到some(或any)或every(或all)其在同行中的JavaScript是Array.some和Array.every.我不够努力或存在吗？

这里的一个相关问题是寻找Swift all方法,但JS程序员可能找不到它(allJS中没有,some或者any没有提到).

在下面的C++ 11/14代码片段中,我使用std::move"移动" Y内部作用域中向量的内容到X 外部作用域中的向量:

void foo() {
   vector<int> X(10);
   ...
   for (...) {
      vector<int> Y(100);
      ...
      X = std::move(Y);
   }
   ...Safe to use X here which contains Y's last content?
 }

Y每次迭代时,在循环的顶部/底部调用contructor /析构函数.由于内容被"移动" Y到X那些内容仍然可行(现在存储在X)循环结束之后正确吗？

我习惯于applicationDidFinishLaunching在 iOS 中执行应用程序初始化，但在 appKit 中它在主视图的方法之后被调用draw！由于应用程序尚未初始化，因此现在绘制任何内容还为时过早。这是顺序：

1. viewDidLoad （主视图控制器）
2. draw(_ dirtyRect:) （主控制器视图）
3. applicationDidFinishLaunching （为时已晚！）

该API参考说，有关以下applicationDidFinishLaunching

在应用程序的主运行循环启动之后但在处理任何事件之前调用此方法。

因此，应该在之后 发布抽奖事件applicationDidFinishLaunching。我不习惯这种行为——这是怎么回事？

我放置了一个自定义类的实例，该实例BigView是IB NSView内部的子类NSScrollView。my的内容大小BigView将在运行时计算。设置内容大小的最佳做法是什么？

重写intrinsicContentSize，因为大书呆子牧场指南中的建议，并没有似乎工作-框架仍保持其原始尺寸：

class BigView: NSView {
   ...
   override var intrinsicContentSize: NSSize { // doesn't work?!
      return NSSize(width: 10000, height: 10000)
   }
   ...
 }

以编程方式（或在IB中）设置框架确实有效：

class BigView: NSView {
   ...
    override func awakeFromNib() {
       ...
       self.frame = NSRect(x: 0, y: 0, width: 10000, height: 10000)
    }
    ...
}I 

或从控制器：

class ViewController: NSViewController {
   @IBOutlet weak var bigView: BigView!
   ...
   override func viewDidLoad() {
       super.viewDidLoad()
       bigView.frame = NSRect(x: 0, y: …

下面的参考变量foo使用的实例Foo或其Bar基于的派生类进行初始化condition。基于say()方法的输出，足够奇怪的是，它foo似乎是的实例，Foo而不是的实例Bar-为什么？

#include <iostream>

class Foo {
public:
    virtual void say() const {
        std::cout << "Foo\n";
    }
};

class Bar : public Foo {
public:
    virtual void say() const {
        std::cout << "Bar\n";
    }
};

int main() {
    constexpr bool condition = false;
    const Foo& foo = condition ? Foo() : Bar();
    foo.say();   // outputs "Foo” ???                                                                                                  
    return 0;
}

如果我注释每个构造函数，我可以看到Bar在评估三元表达式时会调用该构造函数。如果我注释每个析构函数，我会看到Bar析构函数 …