标签: lambda

可以lambda表达式被用来作为类模板参数？(注意这是比一个非常不同的问题这一个,其中询问是否lambda表达式本身可以模板化).

我问你是否可以这样做:

template <class Functor> 
struct Foo { };
// ...
Foo<decltype([]()->void { })> foo;

这在例如类模板具有各种参数之类的情况下是有用的,这些参数equal_to通常被实现为单行仿函数.例如,假设我想实例化一个使用我自己的自定义相等比较函数的哈希表.我希望能够说出类似的话:

typedef std::unordered_map<
  std::string,
  std::string,
  std::hash<std::string>,
  decltype([](const std::string& s1, const std::string& s2)->bool 
    { /* Custom implementation of equal_to */ })
  > map_type;

但我在GCC 4.4和4.6上对此进行了测试,但它不起作用,显然是因为lambda表达式创建的匿名类型没有默认构造函数.(我记得有一个类似的问题boost::bind.)是否有某些原因标准草案不允许这样做,或者我错了并且允许但是GCC仅仅落后于它们的实施？

在我的C++应用程序中(使用Visual Studio 2010),我需要存储一个std :: function,如下所示:

class MyClass
   {
   public:
      typedef std::function<int(int)> MyFunction;
      MyClass (Myfunction &myFunction);
   private:
      MyFunction m_myFunction;    // Should I use this one?
      MyFunction &m_myFunction;   // Or should I use this one?
   };

如您所见,我在构造函数中添加了函数参数作为引用.

但是,在我的班级中存储该功能的最佳方法是什么？

• 我可以将函数存储为引用,因为std :: function只是一个函数指针,函数的"可执行代码"保证保留在内存中吗？
• 如果传递lambda并且调用者返回,我是否必须复制？

我的直觉是说存储引用是安全的(甚至是const引用).我希望编译器在编译时为lambda生成代码,并在应用程序运行时将此可执行代码保存在"虚拟"内存中.因此,可执行代码永远不会被"删除",我可以安全地存储对它的引用.但这是真的吗？

我经常遇到Java lambda表达式的问题,当我想在对象的任意属性或方法上使用distinct()一个流时,但想要保留对象而不是将其映射到该属性或方法.我开始创建这里讨论的容器,但我开始做足够的事情,它变得烦人,并制作了很多样板类.

我将这个Pairing类放在一起,该类包含两个类型的两个对象,并允许您指定左,右或两个对象的键控.我的问题是......对于某些类型的关键供应商,distinct()是否真的没有内置的lambda流功能？那真让我感到惊讶.如果没有,该课程能否可靠地完成该功能？

以下是它的调用方式

BigDecimal totalShare = orders.stream().map(c -> Pairing.keyLeft(c.getCompany().getId(), c.getShare())).distinct().map(Pairing::getRightItem).reduce(BigDecimal.ZERO, (x,y) -> x.add(y));

这是配对课程

    public final class Pairing<X,Y>  {
           private final X item1;
           private final Y item2;
           private final KeySetup keySetup;

           private static enum KeySetup {LEFT,RIGHT,BOTH};

           private Pairing(X item1, Y item2, KeySetup keySetup) {
                  this.item1 = item1;
                  this.item2 = item2;
                  this.keySetup = keySetup;
           }
           public X getLeftItem() { 
                  return item1;
           }
           public Y getRightItem() { 
                  return item2;
           }

           public static <X,Y> Pairing<X,Y> keyLeft(X item1, Y item2) { …

我已经实现了一个AlertDialog正常的负面和正面按钮点击监听器.当我打电话时,new DialogInterface.OnClickListener()它向我展示了一个建议:Anonymous new DialogInterface.OnClickListener() can be replaced with lambda.我知道这不是错误或大事,但这个建议究竟是什么,我能做些什么呢？很少的帮助将不胜感激!

编辑

AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setPositiveButton("Text", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        // do something here
    }
});

Android Studio V1.2.1.1 compileSdkVersion 22 buildToolsVersion "22.0.0" minSdkVersion 14 targetSdkVersion 22

在不使用auto或模板的情况下声明lambda变量或函数参数的符号是​​什么？有没有办法这样做？或者编译器是否为每个lambda定义一个唯一的类对象,其编程时间之前程序员的名称是未知的？如果是这样,为什么？它们不能仅作为某种函数指针传递吗？如果不可能,那将是一个很大的失望.

以下代码吐出1两次,我期望看到0然后1

def pv(v) :
  print v


def test() :
  value = []
  value.append(0)
  value.append(1)
  x=[]
  for v in value :
    x.append(lambda : pv(v))
  return x

x = test()
for xx in x:
  xx()

我希望python lambdas绑定到一个局部变量指向的引用,在场景后面.然而,情况似乎并非如此.我已经在一个大型系统中遇到了这个问题,其中lambda正在做现代C++的一个绑定的等价物(例如'boost :: bind'),在这种情况下,你将绑定到智能ptr或复制contstruct lambda的副本.

那么,如何将局部变量绑定到lambda函数并在使用时保留正确的引用？我对这种行为非常惊讶,因为我不希望这种语言来自垃圾收集器.

有问题的代码如下所示(l3_e是导致问题的变量):

 for category in cat :
      for l2 in cat[category].entries :
        for l3 in cat[category].entries[l2].entry["sub_entries"] :
          l3_e = cat[category].entries[l2].entry["sub_entries"][l3]
          url = "http://forums.heroesofnewerth.com/" + l3_e.entry["url"]
          self.l4_processing_status[l3_e] = 0
          l3_discovery_requests.append( Request(
            url, callback = lambda response : self.parse_l4(response,l3_e))) …

考虑一下:

#include <functional>
#include <iostream>

std::function<void()> make_function(int& x) {
    return [&]{ std::cout << x << std::endl; };
}

int main() {
    int i = 3;
    auto f = make_function(i);
    i = 5;
    f();
}

是否保证在5不调用未定义行为的情况下输出该程序？

我理解如果我x通过value([=])捕获它是如何工作的,但我不确定我是否通过引用捕获它来调用未定义的行为.可能是我在make_function返回后最终会有一个悬空引用,或者只要原始引用的对象仍然存在,捕获的引用是否可以保证工作？

在这里寻找明确的基于标准的答案:) 到目前为止它在实践中运作良好;)

我有一个double[],我想在一行中过滤掉(创建一个没有新的数组)负值而不添加for循环.这是否可以使用Java 8 lambda表达式？

在python中,这将使用生成器:

[i for i in x if i > 0]

是否有可能在Java 8中做同样简洁的事情？

我正在使用Java 8进行项目,发现了一种我无法理解的情况.

我有这样的代码:

void deleteEntity(Node node) throws SomeException {
    for (ChildNode child: node.getChildren()) {
       deleteChild(child);
    }
}

void deleteChild(Object child) throws SomeException {
    //some code
}

这段代码工作正常,但我可以用方法引用重写它:

void deleteEntity(Node node) throws SomeException {
    node.getChildren().forEach(this::deleteChild);
}

并且此代码无法编译,从而产生错误Incompatible thrown types *SomeException* in method reference.

IDEA也给了我错误unhandled exception.

所以,我的问题是为什么？为什么代码为每个循环编译而不用lambda编译？

function foo(x) {
   console.log(arguments)
} //foo(1) prints [1]

但

var bar = x => console.log(arguments) 

以相同方式调用时出现以下错误:

Uncaught ReferenceError: arguments is not defined