Можно ли использовать новые лямбда-выражения в Visual С++ 2010 в качестве обработчиков событий CLR? Я пробовал следующий код:
SomeEvent += gcnew EventHandler(
[] (Object^ sender, EventArgs^ e) {
// code here
}
);
В результате появляется следующее сообщение об ошибке:
ошибка C3364: 'System:: EventHandler': недопустимый аргумент для конструктора делегата; цель делегата должна быть указателем на функцию-член.
Я пытаюсь сделать невозможное или просто не свой синтаксис?
Нет, компилятор С++/CLI не обновляется, чтобы принять синтаксис лямбда. Чрезвычайно ироничный btw дал начальный старт, который управлял кодом.
Следующее - это мое решение, которое позволяет обернуть lambdas (а также любые объекты функций, то есть все, на что можно вызвать operator()), в делегаты. Он имеет некоторые ограничения - в частности, он не поддерживает делегатов с опорными параметрами отслеживания (% в С++/CLI, ref/out в С#); и он имеет верхний предел количества параметров, которые может принять делегат (поскольку VС++ 2010 не поддерживает шаблоны vararg), хотя код может быть тривиально настроен для поддержки до тех пор, пока вы хотите.
#pragma once
#include <new>
#include <type_traits>
namespace detail
{
struct return_type_helper
{
private:
template<class D>
struct dependent_false { enum { value = false }; };
template <class D>
struct illegal_delegate_type
{
static_assert(dependent_false<D>::value, "Delegates with more than 2 parameters, or with parameters of tracking reference types (T%), are not supported.");
};
struct anything
{
template<class T>
operator T() const;
};
public:
template<class D>
static decltype(static_cast<D^>(nullptr)()) dummy(int(*)[1]);
template<class D>
static decltype(static_cast<D^>(nullptr)(anything())) dummy(int(*)[2]);
template<class D>
static decltype(static_cast<D^>(nullptr)(anything(), anything())) dummy(int(*)[3]);
template <class D>
static illegal_delegate_type<D> dummy(...);
};
template<class Func, class Aligner = char, bool Match = (std::tr1::alignment_of<Func>::value == std::tr1::alignment_of<Aligner>::value)>
struct aligner
{
static_assert(Match, "Function object has unsupported alignment");
};
template<class Func, class Aligner>
struct aligner<Func, Aligner, true>
{
typedef Aligner type;
};
template<class Func>
struct aligner<Func, char, false> : aligner<Func, short>
{
};
template<class Func>
struct aligner<Func, short, false> : aligner<Func, int>
{
};
template<class Func>
struct aligner<Func, int, false> : aligner<Func, long>
{
};
template<class Func>
struct aligner<Func, long, false> : aligner<Func, long long>
{
};
template<class Func>
struct aligner<Func, long long, false> : aligner<Func, double>
{
};
template<class Func>
struct aligner<Func, double, false> : aligner<Func, void*>
{
};
template<class F>
ref class lambda_wrapper
{
public:
lambda_wrapper(const F& f)
{
pin_ptr<F> pf = (interior_ptr<F>)&f_storage;
new(pf) F(f);
}
~lambda_wrapper()
{
pin_ptr<F> pf = (interior_ptr<F>)&f_storage;
pf->~F();
}
template <class D>
operator D^ ()
{
D^ d = nullptr;
return gcnew D(this, &lambda_wrapper<F>::invoke<decltype(return_type_helper::dummy<D>(0))>);
}
private:
template<class T>
[System::Runtime::InteropServices::StructLayout(System::Runtime::InteropServices::LayoutKind::Sequential, Size = sizeof(T))]
value struct embedded_storage
{
private:
typename aligner<T>::type dummy;
};
embedded_storage<F> f_storage;
template<class R>
R invoke()
{
pin_ptr<F> pf = (interior_ptr<F>)&f_storage;
return (*pf)();
}
template<class R, class A1>
R invoke(A1 a1)
{
pin_ptr<F> pf = (interior_ptr<F>)&f_storage;
return (*pf)(a1);
}
template<class R, class A1, class A2>
R invoke(A1 a1, A2 a2)
{
pin_ptr<F> pf = (interior_ptr<F>)&f_storage;
return (*pf)(a1, a2);
}
};
}
template<class F>
detail::lambda_wrapper<F>^ make_delegate(F f)
{
return gcnew detail::lambda_wrapper<F>(f);
}
Использование образца:
Func<int, String^, int>^ f2 = make_delegate([&](int x, String^ y) -> int {
Console::WriteLine("Func {0} {1}", x, y);
return 2;
});
Хотя это технически делает то, что вы хотите, практические приложения несколько ограничены из-за того, что С++ 0x lambdas расширены в простые классы, а не ref или value. Поскольку простые классы не могут содержать управляемые типы в С++/CLI (т.е. Нет элементов типа дескриптора объекта, нет элементов ссылочного типа отслеживания и нет членов типа value class), это означает, что lambdas не может захватывать любые переменные этих типов, либо, Не существует обходного пути, о котором я знаю для отслеживания ссылок. Для value class вы можете взять неуправляемый указатель на него (pin_ptr при необходимости) и зафиксировать это.
Для дескрипторов объектов вы можете сохранить их в gcroot<T> и зафиксировать это - но есть серьезные последствия для производительности - в моих тестах доступ к элементу через gcroot<T> примерно в 40 раз меньше, чем при использовании простого объекта ручка. На самом деле это не так много в абсолютной мере для одного вызова, но для того, что многократно повторяется в цикле - скажем, большинство алгоритмов LINQ - это будет убийца. Но обратите внимание, что это применимо только тогда, когда вам нужно захватить ручку в лямбда! Если вы просто используете его для написания встроенного предиката или для обновления счетчика, он будет работать нормально.
На этой странице есть несколько примеров lambdas для С++:
http://msdn.microsoft.com/en-us/library/dd293608%28v=VS.100%29.aspx
Усовершенствования Microsoft VS2010 С++ выглядят так, как будто они реализуют С++ 0x lambda spec. Как таковые, они являются чисто неуправляемыми и имеют тип lambda.
В документации Microsoft нет ничего намека на возможность использования С++ lambdas как CLR lambdas. На этом этапе я должен сказать, что вы не можете использовать С++ lambdas в качестве обработчиков для управляемых делегатов.