printf("-- FastDelegate demo --\nA no-parameter 
             delegate is declared using FastDelegate0\n\n");             
           
    FastDelegate0 noparameterdelegate(&SimpleVoidFunction);

    noparameterdelegate(); 
    // invoke the delegate - this calls SimpleVoidFunction()


    printf("\n-- Examples using two-parameter delegates (int, char *) --\n\n");

    typedef FastDelegate2<int, char *> MyDelegate;

    MyDelegate funclist[10]; // delegates are initialized to empty

    CBaseClass a("Base A");
    CBaseClass b("Base B");
    CDerivedClass d;
    CDerivedClass c;
    
  // Binding a simple member function

    funclist[0].bind(&a, &CBaseClass::SimpleMemberFunction);
  // You can also bind static (free) functions

    funclist[1].bind(&SimpleStaticFunction);
  // and static member functions

    funclist[2].bind(&CBaseClass::StaticMemberFunction);
  // and const member functions

    funclist[3].bind(&a, &CBaseClass::ConstMemberFunction);
  // and virtual member functions.

    funclist[4].bind(&b, &CBaseClass::SimpleVirtualFunction);

  // You can also use the = operator. For static functions,

  // a fastdelegate looks identical to a simple function pointer.

    funclist[5] = &CBaseClass::StaticMemberFunction;

  // The weird rule about the class of derived

  // member function pointers is avoided.

  // Note that as well as .bind(), you can also use the 

  // MakeDelegate() global function.

    funclist[6] = MakeDelegate(&d, &CBaseClass::SimpleVirtualFunction);

  // The worst case is an abstract virtual function of a 

  // virtually-derived class with at least one non-virtual base class.

  // This is a VERY obscure situation, which you're unlikely to encounter 

  // in the real world, but it's included as an extreme test.

    funclist[7].bind(&c, &CDerivedClass::TrickyVirtualFunction);
  // ...BUT in such cases you should be using the base class as an 

  // interface, anyway. The next line calls exactly the same function.

    funclist[8].bind(&c, &COtherClass::TrickyVirtualFunction);

  // You can also bind directly using the constructor

    MyDelegate dg(&b, &CBaseClass::SimpleVirtualFunction);

    char *msg = "Looking for equal delegate";
    for (int i=0; i<10; i++) {
        printf("%d :", i);
        // The ==, !=, <=,<,>, and >= operators are provided

        // Note that they work even for inline functions.

        if (funclist[i]==dg) { msg = "Found equal delegate"; };
        // There are several ways to test for an empty delegate

        // You can use if (funclist[i])

        // or          if (!funclist.empty())

        // or          if (funclist[i]!=0)

        // or          if (!!funclist[i])

        if (funclist[i]) {
            // Invocation generates optimal assembly code.

            funclist[i](i, msg);
        } else { 
            printf("Delegate is empty\n");
        };
    }