typedef struct {
  int a;
  int *p;
}Tarray;

class TCtest 
{
public:
   TCtest(void)
   {
    initarray();
   }
   ~TCtest(void){}
   void initarray(void)
   { 
    const Tarray arr[]=
    {  
     {1,&a1},
     {2,&a2},
     {3,&a3},
    };
    ar=(Tarray*)arr;
   }
int a1,a2,a3;
Tarray * ar;
};

int main(void)
{
TCtest c1;
TCtest c2;
c1.a1 = 11;
c1.a2 = 22;
c1.a3 = 33;
c2.a1 = 44;
c2.a2 = 55;
c2.a3 = 66;
printf("A1=%d A2=%d A3=%d\r\n",*c1.ar[0].p,*c1.ar[1].p,*c1.ar[2].p);
printf("A1=%d A2=%d A3=%d\r\n",*c2.ar[0].p,*c2.ar[1].p,*c2.ar[2].p);
return(0);
}

Output:
A1=11 A2=22 A3=33
A1=44 A2=55 A3=66

S>class TCtest 
S>{
S>public:
S>   TCtest(void)
S>   {
S>    //initarray();
S>   }
S>   ~TCtest(void){}
     struct initarray{
S>   initarray(void)
S>   { 
S>    const static Tarray arr[]=
S>    {  
S>     {1,&a1},
S>     {2,&a2},
S>     {3,&a3},
S>    };
S>    ar=(Tarray*)arr;
S>   }
};
static initarray _init;
S>int a1,a2,a3;
S>static Tarray * ar;
S>};
в .cpp:
TCtest::initarray TCtest::_init;

#include <iostream>
#include <ostream>
using namespace std;

struct Pair
{
    int n;
    int *p;
};
struct Foo
{
    int a=11, b=22;
    Pair bar[2] = {{0,&a},{1,&b}};
};

int main()
{
    Foo foo;
    for(auto &&v : foo.bar)
        cout << "n=" << v.n << ",*p=" << *v.p << endl;
}

_>Круто

_>Выглядит, не как С++

Surprisingly, C++11 feels like a new language: The pieces just fit together better than they used to and I find a higher-level style of programming more natural than before and as efficient as ever.

EP>>    for(auto &&v : foo.bar)
EP>>        cout << "n=" << v.n << ",*p=" << *v.p << endl;
EP>>

    for(Pair &&v : foo.bar) //error: cannot bind 'Pair' lvalue to 'Pair&&'
        cout << "n=" << v.n << ",*p=" << *v.p << endl;

struct TArray
{
    int n;
    int** a;
};

class CTest
{
public:
    int y, z, x;
    struct XYZ { int* a[3]; } xyz;
    std::vector<int*> uvw;

    CTest()
    {
        xyz = {{&x,&y,&z}};
        uvw = {{&x,&y,&z}};
    }
    TArray arr() { return TArray{3, rand() ? xyz.a : &uvw.front() }; }
};

int main()
{
    CTest p,q;
    p.x = 1; p.y = 2; p.z = 3;
    q.x = 4; q.y = 5; q.z = 6;

    printf("%d %d\n", *p.arr().a[0], *q.arr().a[0]);
}

class CTest;
typedef int CTest::* CTestIntField;

struct CTestFields
{
  int n;
  CTestIntField* a;
};

class CTest
{
public:
  int y, z, x;

  static CTestFields const& fields()
  {
    static const CTestIntField a[] = { &CTest::x, &CTest::y, &CTest::z };
    static const CTestFields f = { ARRAY_SIZE(a), a };
    return f;
  }
};

int main()
{
  CTestFields const& f = CTest::fields();
  CTest p; p.x=1;
  CTest q; q.x=4;
  printf("%d %d", p.*f[0], q.*f[0]); // постфиксный оператор [] имеет приоритет перед инфиксным .* - скобки не нужны
}