using System;
public class Test
{
    public delegate int retInc();
    public static void Main(string[] args) {
        retInc func = create();
        retInc func2 = create();
        Console.WriteLine(func());
        Console.WriteLine(func2());
    }
    public static retInc create() {
        int val = 0;
        return delegate () {
            return val++;
        };
    }
}

using System;
public class Test
{
    public delegate int retInc();
    public static void Main(string[] args) {
        retInc func1, func2;
        create(out func1, out func2);
        Console.WriteLine(func1());
        Console.WriteLine(func2());
    }

    public static void create(out retInc f1, out retInc f2) {
        int val = 0;
        f1 = delegate () {
            return val++;
        };
        f2 = delegate () {
            return val++;
        };
    }
}

using System;
public class Test
{
    public delegate int retInc();
    public static void Main(string[] args) {
        retInc func = create();
        retInc func2 = create();
        Console.WriteLine(func());
        Console.WriteLine(func());
        Console.WriteLine(func2());
    }

    public static retInc create() {
        int val = 0;
        return delegate () {
            return val++;
        };
    }
    
}

std::vector<C> v;
. . .
std::for_each( v, void lambda(C& c) { c.print(); } );

delegate bool Predicate<T>(T t);

VD>>Страуструп как всегда высказался в своем духе "мы даем людям универсальные абстракции вроде классов", типа другие не дают

struct push_max {

  typedef int result_type;

  push_max() : max_value(), got_first(false) {}

  // returns false when we want to stop
  bool operator()(int result) {

    if (!got_first) {
      got_first = true;
      max_value = result;
    } else
    if (result > max_value)
      max_value = result;

    if (result > 100)
      return false;

    return true;
  }

  int get_value() const 
  { 
    if (!got_first)
      throw std::runtime_error("Empty!");
    return max_value; 
  }

private:
  int  max_value; 
  bool got_first;
};

typedef boost::signals<int*(void), push_max> sig_type;

sig_type signal;
signal.connect(...);
signal.connect(...);
signal(); //Call signal!

const push_max result=signal.combiner(); //Get combiner

> VD>>delegate bool Predicate<T>(T t);
> VD>>

boost::function<bool(T)> Predicate;

People comparing languages using lists love such features. The snag is that the problems we face are essentially infinite, so we need an infinity of such specialized features. Examples are Pascal procedure parameters and C# delegates. The alternative traditionally offered by C++ (and before that by K&R C) is to provide very general features from which good programmers can construct solutions to a wide variety of problems. Examples are pointers and classes.

Require exact type matches between a delegate and what it is calling.

Only return the result of the last target called, with no option for customization.

Must call a method with this already bound.

void fun1(int a)
{
    cout << a << endl;
}

void fun2(short a)
{
    cout << a << endl;
}

int main()
{
    signal<void (int)> fun;
    fun.connect(&fun1);
    fun.connect(&fun2);
    fun(10);
}

GetData getDataMulticast = f1 + (GetData)f2 + f3;

int sum = 0;

foreach (GetData getData in getDataMulticast.GetInvocationList())
    sum += getData();

delegate int GetData();
...
GetData[] getDataArray = new GetData[] { f1, f2, f3 };

int sum = 0;

foreach (GetData getData in getDataArray)
    sum += getData();

C>struct push_max {

C>  typedef int result_type;

C>  push_max() : max_value(), got_first(false) {}

C>  // returns false when we want to stop
C>  bool operator()(int result) {

C>    if (!got_first) {
C>      got_first = true;
C>      max_value = result;
C>    } else
C>    if (result > max_value)
C>      max_value = result;

C>    if (result > 100)
C>      return false;

C>    return true;
C>  }

C>  int get_value() const 
C>  { 
C>    if (!got_first)
C>      throw std::runtime_error("Empty!");
C>    return max_value; 
C>  }

C>private:
C>  int  max_value; 
C>  bool got_first;
C>};

C>typedef boost::signals<int*(void), push_max> sig_type;

C>sig_type signal;
C>signal.connect(...);
C>signal.connect(...);
C>signal(); //Call signal!

C>const push_max result=signal.combiner(); //Get combiner
C>

A>void fun1(int a)
A>{
A>    cout << a << endl;
A>}

A>void fun2(short a)
A>{
A>    cout << a << endl;
A>}

A>int main()
A>{
A>    signal<void (int)> fun;
A>    fun.connect(&fun1);
A>    fun.connect(&fun2);
A>    fun(10);
A>}
A>

delegate void Test(int a);

static void Main(string[] args)
{
    Test fun = fun1 + new Test(delegate(int a) { fun2((short)a); });
    fun(10);
}

static void fun1(int a)
{
    Console.WriteLine("void fun1(int a); a = " + a);
}

static void fun2(short a)
{
    Console.WriteLine("void fun1(int a); a = " + a);
}

class A { }
class B : A { }

class Program
{
    delegate void Test(B b);

    static void Main(string[] args)
    {
        Test fun = fun1 + (Test)fun2;
        fun(new B());
    }

    static void fun1(A a)
    {
        Console.WriteLine("void fun1(A a); a is " + a.GetType().Name);
    }

    static void fun2(B b)
    {
        Console.WriteLine("void fun1(B b); b is " + b.GetType().Name);
    }
}

> A>void fun1(int a)
> A>{
> A>    cout << a << endl;
> A>}
>
> A>void fun2(short a)
> A>{
> A>    cout << a << endl;
> A>}
>
> A>int main()
> A>{
> A>    signal<void (int)> fun;
> A>    fun.connect(&fun1);
> A>    fun.connect(&fun2);
> A>    fun(10);
> A>}
> A>

void fun1(int a)
{
     cout << a << endl;
}

void fun2(long a)
{
     cout << a << endl;
}

int main()
{
     signal<void (int)> fun;
     fun.connect(&fun1);
     fun.connect(&fun2);
     fun(10);
}

function Outer() : ??? {некий тип};
var
   val : Integer;
   A: function(): Integer;
   B: function(): Integer;
begin
    val := 0;
    function InnerA
    begin
        inc(val);
        InnerA := val
    end;
    function InnerB
    begin
        dec(val);
        InnerB := val
    end;
    A := InnerA;
    B := InnerB;
    { Как-то возвращаем A и B наружу }
end;

A();
A();
s := B();