(int)i

int(i)

MA>2. количество атрибутов private/protected/public стремиться к колличеству полей в классе

private int _someIdentifier=0;

public class SomeIdentifier
{
}

S>(int)i 
S>

S>int(i)
S>

  ((MyClass) obj).xxx

       MyClass(obj).xxx

СГ>TYPE
СГ>  Action = PROCEDURE (a: Action): Action;
СГ>

#include <iostream>
using namespace std;

struct action_wrapper
{
  typedef action_wrapper (*func_type) (action_wrapper a, int x);

  func_type func; // обёрнутое данное

  action_wrapper(func_type f) : func(f) {} // приведение функции к обёртке
  operator func_type() const { return func; } // приведение обёртки к функции
};
typedef action_wrapper::func_type action; // вынесем, для удобства, в глобальное пространство имён

// это - глобальные функции
action_wrapper foo(action_wrapper a, int x);
action_wrapper bar(action_wrapper a, int x);
action_wrapper buz(action_wrapper a, int x);

// реализацию сделаем какую-нибудь кудрявую, чтобы не было шансов для инлайна
action_wrapper foo(action_wrapper a, int x)
{
  cout << "foo(" << x << ")" << endl;
  return x%2 ? a : bar;
}
action_wrapper bar(action_wrapper a, int x)
{
  cout << "bar(" << x << ")" << endl;
  return foo(buz,x);
}
action_wrapper buz(action_wrapper a, int x)
{
  cout << "buz(" << x << ")" << endl;
  return a(foo,x);
}

int main()
{
  cout << "--- цепочка ---" << endl;
  buz(foo,1)(bar,2)(buz,3);

  cout << "--- автомат ---" << endl;
  action f = foo, g = bar;
  for(int i=1; i<10; ++i)
  {
    g = f(g,i);
    f = g;
  }
  return 0;
}

C>void* func(void* someFunc)
C>{
C>    return someFunc;
C>}

C>...
C>void funcPtr=func(&func);
C>assert(funcPtr==&func);

typedef void(*voidfunc)();

typedef voidfunc(*automate)(voidfunc);

voidfunc foo(voidfunc f) { return rand()%2 ? f : bar; }
voidfunc bar(voidfunc f) { return rand()%2 ? f : foo; }

int main()
{
  automate f = foo, g = bar;
  for(int i=0; i<10; ++i) f=(automate)(g(f)), g=f;
}