Question: Consider the following code

```
template<typename T, int N>
struct A {
  typedef T value_type; // OK. save T to value_type
  static const int size = N; // OK. save N to size
};

```

Look, it is possible to save any template parameter if this parameter is a typename or an integer value. The thing is that *pointer to member* is an offset, i.e. integer.
Now I want to save any pointer to member in compile time:

```
struct Foo {
   int m; 
   int r;
};

template<int Foo::*ptr_to_member>
struct B {
   // Next statement DOES NOT WORK!
   static int Foo::* const saved_ptr_to_member = ptr_to_member; 
};

// Example of using
int main() {
    typedef B<&Foo::m> Bm;
    typedef B<&Foo::r> Br;
    Foo foo;
    std::cout << (foo.*(Bm::saved_ptr_to_member));
}

```

How to save pointer to member in **compile time**? I use VS2008.

**Note.** Compile time is critical. Please don't write run-time solution. I know it.

Answer: 
It would be nice to have more elaborate explanation of why 'compile-time is important' (helps suggesting alternatives). But to my notion everything you *need* to be done compile time with pointer-to-member, you actually *can* do. My variant is Thomas's suggestion blended with some C++ philosophy of sort. First lets define:

```
template <typename T, T v>
struct val
{};

```

this struct template can effectively serve as compile time value, and you don't need "static value = v;", to use it either at compile or run time. Consider:

```
template <int n>
struct Foo
{
  //something dependent on n
};

```

and

```
template <typename T>
struct Bar;

template <int n>
struct Bar <val <int, n> >
{
  //something dependent of n
};

```

Foo and Bar are functionally equivalent, every template meta-kadabra which can be done with Foo can also be done with Bar (just pass val instead of n). The same vay you can pack pointer to member into val<>:

```
val <typeof (&My::a), &My::a>

```

these compile time values now can be stored in type lists (like boost::mpl::something), compared, transformed, etc., everything compile time. And when you will finally want to use them as pointer-to-member at run time, just define one function template:

```
template <typename T, T value>
T
extract (val <T, value>)
{
   return value;
}

```

and use it:

```
typedef val <typeof (A::i), A::i> a_i;

A a;
std::cout << (a .* extract (a_i ()));

```

P.S.: there are some clumsy constructs about this solution, but it is all for sake of simplicity and explanation. For example rather ugly (a .\* extract (a\_i ())) may be simplified by wrapping it into something more pointer-to-member specific:

```
template <typename M, typename C>
typename mem_type <M>::value &
mem_apply (C &c)
{
   M m;
   return c .* extract (m);
}

```

where mem\_type is class template which extracts type of member referred by M. Then usage would be:

```
std::cout << mem_apply <a_i> (a);

```
You can't.

But you can use a [functionoid](http://www.parashift.com/c++-faq-lite/pointers-to-members.html#faq-33.10) instead. This *can* be a compile-time solution. And because the compiler can inline things, it's possibly even faster than a pointer to a member function. Example:

```
struct Foo {
   int m; 
   int r;
};

struct FooM {
   static int call(Foo const &foo) const { return foo.m; }
}

struct FooR {
   static int call(Foo const &foo) const { return foo.r; }
}

template<typename FooFun>
struct B {
   typedef FooFun foo_fun;
   int call_foo_fun(Foo const &foo) { return foo_fun::call(foo); }
};

// Example of using
int main() {
    typedef B<FooM> Bm;
    typedef B<FooR> Br;
    Foo foo;
    std::cout << Bm.call_foo_fun(foo);
}

```

Untested, but you get the idea.