10.5 Я моделирую Марковский процесс с конечным числом состояний, и у меня
есть набор функций для каждого состояния. Я хочу, чтобы смена
состояний происходила путем возврата функцией указателя на функцию,
соответветствующую следующему состоянию. Однако, я обнаружил
ограничение в механизме деклараций языка С: нет возможности объявить
функцию, возвращающую указатель на функцию, возвращающую указатель
на функцию, возвращающую указатель на функцию...

О: Да, непосредственно это сделать нельзя. Пусть функция возвращает
обобщенный указатель на функцию, к которому перед вызовом функции
будет применен оператор приведения типа, или пусть она возвращает
структуру, содержащую только указатель на функцию, возвращающую
эту структуру.

#include <iostream>

struct Next {
   Next(Next (*p)()) : fun(p){}
   Next (*fun)();
};

Next fun1()
{
  std::cout<<"fun1()\n";
  Next fun2();
  return Next(fun2);
}

Next fun2()
{
  std::cout<<"fun2()\n";
  Next fun3();
  return Next(fun3);
}

Next fun3()
{
   std::cout<<"fun3(), final state\n";
   return Next(0);
}

int main()
{
  Next state(fun1);
  while(state.fun) {
     state = state.fun();
  }
}

typedef void (*generic)();

generic fun1()
{
   generic fun2();
   std::cout<<"fun1\n";
   return reinterpret_cast<generic>(fun2);
}

generic fun2()
{
   generic fun3();
   std::cout<<"fun2\n";
   return reinterpret_cast<generic>(fun3);
}

generic fun3()
{
   std::cout<<"fun3, final state\n";
   return 0;
}

int main()
{
   generic state = reinterpret_cast<generic>(fun1);
   while (state) {
      state = reinterpret_cast<generic (*)()>(state)();
   }
}

struct Result;
typedef Result F();

struct Result
{
  operator F*() const;
};

Result foo();

int main()
{
  F* f = foo(); 
  for(;;)
    f = f();
}

typedef Result F();

Next(Next (*p)()) : fun(p){}

return Next(fun2);

std::cout

W>Next(Next (*p)()) : fun(p){}
W>

return Next(fun2);

W>return Next(fun2);
W>

W>std::cout
W>

#include <stdio.h>

struct Next {
   struct Next (*fun)();
};

struct Next fun1()
{
  printf("fun1()\n");
  struct Next fun2();
  struct Next retVal = {fun2};
  return retVal;
}

struct Next fun2()
{
  printf("fun2()\n");
  struct Next fun3();
  struct Next retVal = {fun3};
  return retVal;
}

struct Next fun3()
{
   printf("fun3(), final state\n");
   struct Next retVal = {0};
   return retVal;
}

int main()
{
  struct Next state = {fun1};
  while(state.fun) {
     state = state.fun();
  }
}

#include <stdio.h>

typedef struct Next_ {
   struct Next_ (*fun)();
} Next;

Next fun1()
{
  printf("fun1()\n");
  Next fun2();
  return (Next){fun2};
}

Next fun2()
{
  printf("fun2()\n");
  Next fun3();
  return (Next){fun3};
}

Next fun3()
{
  printf("fun3(), final state\n");
  return (Next){0};
}

int main()
{
  Next state = {fun1};
  while(state.fun) {
     state = state.fun();
  }
}