Что означает [&] при определении лямбды? - PullRequest
Новая
       11

Что означает [&] при определении лямбды?

1 голос
/ 17 января 2020

В справочной документации к методу приведен пример кода, скопированного ниже: 

char8 GetNext()
{
    if (i >= str.Length)
        return 0;
    return str[i++];
}

/* Allocates a delegate bound to GetNext() */
delegate char8() strDlg = scope => GetNext;

strDlg = scope () =>
{
    return 'A';
};

strDlg = scope [&] () =>
{
    return GetNext();
};

/* This delegate owns a string */
String tempStr = new String(str);
tempStr.EnsureNullTerminated();
strDlg = scope [&] () =>
{
    return str[i++];
}
~
{
    delete tempStr;
};

В двух из трех примеров определений лямбда-выражения между [&] выражение выделения (scope) и параметры лямбда. Что это такое [&]?

Для дополнительных примеров, вот некоторые выдержки из тестов , включенных в источник IDE : 

struct Splattable
{
    public int32 mA = 10;
    public int16 mB = 200;

    public void TestLambda() mut
    {
        delegate int(ref int a, ref int b) dlg = scope [&] (a, b) => 
        {
            a += 20;
            b += 30;
            mA++;
            return mA + a + b;
        };

        mA = 100;
        int testA = 8;
        int testB = 9;
        Test.Assert(dlg(ref testA, ref testB) == 100+1 + 20+8 + 30+9);
        Test.Assert(testA == 28);
        Test.Assert(testB == 39);
        Test.Assert(mA == 101);
    }
}

class ClassA
{
    public int mA;

    public void TestLambda()
    {
        delegate int(ref int a, ref int b) dlg = scope (a, b) => 
        {
            a += 20;
            b += 30;
            mA++;
            return mA + a + b;
        };

        mA = 100;
        int testA = 8;
        int testB = 9;
        Test.Assert(dlg(ref testA, ref testB) == 100+1 + 20+8 + 30+9);
        Test.Assert(testA == 28);
        Test.Assert(testB == 39);
        Test.Assert(mA == 101);
    }
}

Вот еще один пример / тестирует из части IDEHelper исходного кода , где каждое лямбда-определение имеет [&]: 

using System;

namespace Tests
{
    class Lambdas
    {
        [Test]
        static void TestBasics()
        {
            int a = 1;

            Action act = scope [&] () =>
            {
                Action act2 = scope [&] () =>
                {
                    a += 100;
                };
                act2();
            };
            act();

            Test.Assert(a == 101);
        }

        static int Add3<T>(T func) where T : delegate int()
        {
            return func() + func() + func();
        }

        [Test]
        static void TestValueless()
        {
            Test.Assert(Add3(() => 100) == 300);

            int a = 20;
            int result = Add3(() => a++);
            Test.Assert(result == 63);
        }

        [Test]
        static void LambdaWithDtor()
        {
            int a = 10;
            int b = 20;

            //
            {
                delegate void() dlg = scope [&] () =>
                {
                    a++;
                }
                ~
                {
                    b++;
                };
                dlg();
            }

            Test.Assert(a == 11);
            Test.Assert(b == 21);

            delegate void() dlg = new [&] () =>
            {
                a += 100;
            }
            ~
            {
                b += 200;
            };
            dlg();
            Test.Assert(a == 111);
            Test.Assert(b == 21);
            delete dlg;
            Test.Assert(b == 221);
        }
    }
}

Наконец, [&] может быть не совсем лямбда-выражением. Я могу поместить его в другие определения, такие как let s = new [&] String();, и он компилируется без проблем, и, насколько я могу судить, работает с тем же результатом, что и без него. Но я еще не видел, чтобы это произошло где-либо еще в примере / тестовом коде.

1 Ответ

1 голос
/ 20 апреля 2020

[&] Средство захвата любых ссылочных локальных объектов по ссылке, а не по значению.

В этом примере для ClassA this передается по значению в лямбду. Эффективно: this.mA++;

...