CODE:

#include 

typedef char (*PHH)[5];  //「配列を指すポインタ」の型指定子を作成

//--------------------------------------------------------------------
//「配列を指すポインタ」を返す関数
//--------------------------------------------------------------------
PHH test1(void)
{
    static char  ahh[3][5]={{"ABCD"},{"abcd"}};  

    return ahh;
}
//--------------------------------------------------------------------
// メイン関数
//--------------------------------------------------------------------
int main(void)
{
    int   i;
    char  *c;
    
    //----------------------------------------------------------------
    // ポインタを返す関数へのポインタ。関数の返すポインタは、
    // ５つの要素を持つ２次元配列を指す。ただし、２次元目のアドレスを指すらしい。
    //----------------------------------------------------------------
    char (*(*var)())[5];
    
    var=test1;        // 関数のアドレスを代入

    //----------------------------------------------------------------
    // 関数 test1 を実行し、関数値を c に代入
    // 下の場合、要素数が 0 なので、ahh[0][0]のアドレスになる。
    //----------------------------------------------------------------
    c=(*var)()[0];
    
    for(i=0; i<5 ; i++){
        printf("%p = %c \n", c+i, *(c+i));
    }
    printf("------------------------------------\n");

    //----------------------------------------------------------------
    // 要素数が 1 増えると 5バイト先のアドレスを指す、
    // つまり、ahh[1][0] のアドレスを表すことになる。それを c に代入 
    //----------------------------------------------------------------
    c=(*var)()[1];

    for(i=0; i<5 ; i++){
        printf("%p = %c \n", c+i, *(c+i));
    }
    printf("------------------------------------\n");

    //----------------------------------------------------------------
    // 要素数を 2 にして 10バイト先のアドレスをいじくってみる。、 
    //----------------------------------------------------------------
    c=(*var)()[2];
    
    *((*var)()[2])  ='X';        // アドレスを表すので * を付けて代入 
    *((*var)()[2]+1)='Y';        // アドレスを +1 した所に代入
    *(c+2)='Z';                  // c を使っての代入
    
    for(i=0; i<5 ; i++){
        printf("%p = %c \n", c+i, *(c+i));
    }
    return 0;
}

CODE:

#include 

typedef char *(*PPHH)[5];  // 「ポインタ配列を指すポインタ」の型指定子

//-------------------------------------------------------------------------
//「ポインタ配列を指すポインタ」を返す関数 
//-------------------------------------------------------------------------
PPHH test1(void)
{
    //------------------------------------
    // ポインタの２次元配列をつくる
    //------------------------------------
    static char *phh[2][5]={
                {{"1ABC"},{"2ABC"},{"3ABC"},{"4ABC"},{"5ABC"}},
                {{"6ABC"},{"7ABC"},{"8ABC"},{"9ABC"},{"0ABC"}}
            };

    return phh;
}
//-------------------------------------------------------------------------
// メイン関数
//-------------------------------------------------------------------------
int main(void)
{

    char  *(*(*var)())[5];    // 例の奴
    char  **c;                // C は ダブルポインタ
    int   i;

    var=test1;        // 関数のアドレスを代入

    //----------------------------------------------------------------------
    // c は「ポインタの２次元配列」が指す「２次元配列の２次元目」を指す 
    //----------------------------------------------------------------------
    c=(*var)()[0];
    for(i=0; i<5 ; i++){
        printf("%p = %c \n", *(c+0)+i, *(*(c+0)+i) );
    }
    printf("------------------------------------\n");

    c=(*var)()[1];
    for(i=0; i<5 ; i++){
        printf("%p = %c \n", *(c+0)+i, *(*(c+0)+i) );
    }
    return 0;
}

CODE:

#include 

typedef int  (*PHH)[3];  // 「int型の３つの要素を持つ配列」を指すポインタの型指定子

int main(void)
{
    int  (*var(int (*)[3]))[3];      // 関数 var の使用宣言
    // int (*var(PHH))[3];           // 作成した型指定子を使えばシンプル
    // PHH var(PHH);                 // 本当はこれだけだったりして

    int  a[2][3]={{1,2,3},{4,5,6}};  // これまたしょうもない２次元配列を作る 
    int  i, j;

    for(j=0 ; j<2 ; j++){
       for(i=0 ; i<3 ; i++){
           printf("%d ", var(a)[j][i]);
       }                        // 関数 var(a) は、配列のポインタを返すので
       printf("\n");            // そのまま配列名代わりとして使える
    }                           // つまり、関数実行後は  a[j][i] になる
    return 0;
}
//----------------------------------------------------------------
// 使用宣言されているので、main関数の後に定義できる
//----------------------------------------------------------------
PHH var(int (*ph)[3])
{
    return ph;  // めんどくさいので、受け取った配列のポインタをそのまま返す
}

CODE:

#include 

int  main(void)
{
    // ここでは２次元配列を作る必要はなかったが、記述量を減らすために使用
    int a[2][3]={{0xA1,0xA2,0xA3},{0xA4,0xA5,0xA6}};
    int b[2][3]={{0xB1,0xB2,0xB3},{0xB4,0xB5,0xB6}};
    int c[2][3]={{0xC1,0xC2,0xC3},{0xC4,0xC5,0xC6}};
    int d[2][3]={{0xD1,0xD2,0xD3},{0xD4,0xD5,0xD6}};

    int *pph1[2];      // ポインタ配列の宣言
    int *pph2[2];
    int *pph3[2];
    int *pph4[2];

    int x, y, i, j;    // もろもろの変数を宣言
    int **var[2][2];   //「２重ポインタの２次元配列」を宣言

    pph1[0]=a[0];      // ポインタ配列に２次元目のポインタを代入
    pph1[1]=a[1];      // ２次元配列を作ってなかったら８個の変数や１次元配列
    pph2[0]=b[0];      // を作って代入しなければならなかった。
    pph2[1]=b[1];
    pph3[0]=c[0];
    pph3[1]=c[1];
	pph4[0]=d[0];
    pph4[1]=d[1];

    var[0][0]=pph1;   //「２重ポインタの２次元配列」に、
    var[0][1]=pph2;   //「ポインタ配列名（ポインタ配列へのポインタ）」を代入 
    var[1][0]=pph3;   //「ポインタ配列名」は、２重ポインタと、
    var[1][1]=pph4;   // まったく同じものなので、そのまま代入できる
    
    for(y=0 ; y<2 ; y++){
       for(x=0 ; x<2 ; x++){
          for(j=0; j<2 ; j++){
             for(i=0 ; i<3 ; i++){
                printf("%2X ", var[y][x][j][i]);
             }              // var[y][x] は pph1～pph4 へのポインタなので
          }                 // [j][i]は、pph1[j][i]～pph4[j][i]になる
          printf("\n");
       }
    }
    return 0;
}

CODE:

#include 

int main(void)
{
    int  a=1111, b=2222, c=3333, d=4444, e=5555, f=6666;
    int  *phh1[1][3];     //「ポインタの２次元配列」を作る
    int  *phh2[1][3];     // もう一つ作る
    int  *(*var[2])[3];   // 例の奴
    int  n, x, y;

    phh1[0][0]=&a;   // 「ポインタの２次元配列」にアドレスを入れていく
    phh1[0][1]=&b;
    phh1[0][2]=&c;
    phh2[0][0]=&d;
    phh2[0][1]=&e;
    phh2[0][2]=&f;

    var[0]=phh1;     // 例の配列に「ポインタの２次元配列」への
    var[1]=phh2;     // ポインタ（配列名）を入れていく

    for(n=0 ; n<2 ; n++){
       for(x=0 ; x<1 ; x++){
          for(y=0; y<3 ; y++){
             printf("%d ", *(var[n][x][y]) );
             printf("\n");
           }                // var[n] は、phh1～phh2へのポインタ
       }                    // [x][y] は、phh1[x][y]～phh2[x][y] になる
    }                       // phh1[x][y]～phh2[x][y]は、a～fへのポインタ
    return 0;               // var[n][x][y]全体が a～f へのポインタなので
}                           // ポインタに * を付ければ、a～f の内容を表す