C++でのローカル関数の実現法

int global(int n)
{
  return 2*n;
}

namespace {
  int file_local(int n)
  {
    return 2*n;
  }
}

static int file_local(int n)
{
  return 2*n;
}

#include <iostream>
using namespace std;

int main()
{
  // LocalFunc構造体は、add関数の定義に利用する
  struct LocalFunc {
    // add関数は2つの引数の和を返す
    // LocalFunc構造体のインスタンスは作らないので、静的メンバ関数にする
    static int add(int a, int b)
    {
      return a+b;
    }
  };

  cout<<LocalFunc::add(3,5)<<endl; // 3と5の和(8)を表示する
}

#include <iostream>
using namespace std;

int main()
{
  // LocalFunc構造体は、add関数とmul関数の定義に利用する
  struct LocalFunc {
    // add関数は2つの引数の和を返す
     static int add(int a, int b)
    {
      return a+b;
    }

    // mul関数は2つの引数の積を返す
    static int mul(int a, int b)
    {
      return a*b;
    }
  };

  cout<<LocalFunc::add(3,5)<<endl; // 3と5の和(8)を表示する
  cout<<LocalFunc::mul(3,5)<<endl; // 3と5の積(15)を表示する
}

#include <iostream>
using namespace std;

int main()
{
  // ローカル関数を定義するための無名のローカル構造体
  struct {
    // ()演算子をオーバーロードして関数オブジェクトにする
    int operator()(int a, int b)
    {
      return a+b;
    }
  } add; // addはローカル構造体の変数

  cout<<add(3,5)<<endl;
}

#include <iostream>
using namespace std;

int main()
{
  // ローカル関数を定義するための無名のローカル構造体
  struct {
    // 引数の階乗を計算する関数(再帰呼び出し使用)
    int operator()(int n)
    {
      if(n==0) {
        return 1;
      } else {
        return n*(*this)(n-1);  // return n*operator()(n-1); という書き方も可能
      }
    }
  } frac;

  cout<<frac(4)<<endl; // 4の階乗の24を表示
}

#include <iostream>
using namespace std;

struct AddSqr { // 外側の構造体
  struct Sqr { // 内側の構造体
    // 引数の2乗を返す関数
    static int func(int n) { return n*n; };
  };

  // a^2+b^2を返す関数
  static int func(int a, int b) { return Sqr::func(a)+Sqr::func(b); };
};

int main()
{
  cout<<AddSqr::func(3,4)<<endl; // 3^2+4^2の計算結果(25)を表示
  cout<<Sqr::func(3)<<endl; // エラー
  cout<<AddSqr::Sqr::func(3)<<endl; // こうすれば内側の構造体のメンバ関数を呼ぶ事もできる
}

#include <iostream>
using namespace std;

int main()
{
  // ローカル関数AddSqrの定義
  struct {
    // ローカル関数AddSqr内のローカル関数、Sqrの定義
    struct {
      int operator()(int n)
      {
        return n*n;
      };
    } Sqr;
    
    int operator()(int a, int b)
    {
      return Sqr(a)+Sqr(b);
    };
  } AddSqr;
  
  cout<<AddSqr(3,4)<<endl; // 3^2+4^2の計算結果(25)を表示
}

#include <iostream>
using namespace std;

int global=123; // グローバル変数

int main() {
  // ローカル関数ReadGlobalの定義
  struct {
    int operator()()
    {
      return global; // ローカル関数内で、グローバル変数globalにアクセス
    };
  } ReadGlobal;

  cout<<ReadGlobal()<<endl; // 123を表示
}

#include <iostream>
using namespace std;

int main() {
  int        LocalAuto  =123; // ローカル変数(auto)
  static int LocalStatic=456; // ローカル変数(static)

  // ローカル関数ReadLocalAutoの定義
  struct {
    int operator()()
    {
      return LocalAuto; // main関数のローカル変数にアクセス(エラー)
    };
  } ReadLocalAuto;

  // ローカル関数ReadLocalStaticの定義
  struct {
    int operator()()
    {
      return LocalStatic; // main関数のローカル変数にアクセス(成功)
    };
  } ReadLocalStatic;

  cout<<ReadLocalAuto()  <<endl; // エラー
  cout<<ReadLocalStatic()<<endl; // 456を表示
}

#include <iostream>
using namespace std;

int main() {
  // ローカル関数ReadLocalAutoの定義
  struct {
    // 関数とそのローカル関数で共有したいauto変数は、ローカル関数を定義するための構造体のメンバにする。
    // 関数オブジェクトのインスタンス(ReadLocalAuto)がauto変数なので、その(非static)メンバ変数はauto変数になる。
    int LocalAuto;

    // ローカル関数の定義本体
    int operator()()
    {
      return LocalAuto;
    };
  } ReadLocalAuto;

    // 必要ならば、確保した変数への参照を宣言しておくと、普通のauto変数っぽくアクセスできる。
    int &LocalAuto=ReadLocalAuto.LocalAuto;

  // これ以降は、LocalAutoを普通のauto変数として、ReadLocalAutoをLocalAutoを読むためのローカル関数として扱える。
  LocalAuto=123; // 実際にはReadLocalAuto.LocalAutoへの代入。
  cout<<ReadLocalAuto()<<endl; // 123が表示される。
}

program sample(input,output);

  { グローバル手続きtestの定義。pascalではコメントは中括弧でくくる }
  { 手続き(procedure)は、C++でいうところのvoid型の関数 }
  procedure test;

    { testの中で、ローカル手続きp1を定義 }
    procedure p1(a,b : integer);

      { p1の中で、ローカル手続きp2を定義 }
      procedure p2(a,b : integer);
      begin
        writeln('p2:',a,',',b);
        p1(b,a); { p1の呼び出し。外側のローカル手続きを呼んでいる }
      end;

    { 手続きp1の本体 }
    begin
      writeln('p1:',a,',',b);
      if a>0 then p2(a-1,b); { p2の呼び出し }
    end;

  { 手続きtestの本体 }
  begin
    p1(3,5); { testの呼び出し }
  end;

{ プログラム本体 }
begin
  test;
end.

program sample(input,output);

  { グローバル手続きtestを定義 }
  procedure test;

    { testの中で、ローカル手続きp1を定義 }
    procedure p1;
    var i : integer; { p1のローカル変数。p2からもアクセス可能 }

      { p1の中で、ローカル手続きp2を定義 }
      procedure p2;
      begin
        i:=i+1; { 外側の関数のローカル変数にアクセス }
      end;

    { 手続きp1の本体 }
    begin
      i:=3;
      p2; { p2の呼び出し。iが1増える}
      writeln(i); { 4を表示 }
    end;

  { 手続きtestの本体 }
  begin
    p1; { p1の呼び出し }
  end;

{ プログラム本体 }
begin
  test; { testの呼び出し }
end.

void setup() 
{
  // 階乗を計算するローカル関数fracの定義
  struct {
    int operator()(int n)
    {
      if(n==0) {
        return 1;
      } else {
        return n*(*this)(n-1);
      }
    };
  } frac;
  
  Serial.begin(9600);
  while(!Serial);
  Serial.println(frac(4)); // 4の階乗(24)を表示
}

void loop() 
{
}