const int c1=(char*)1-(char*)0;
enum { c2=(char*)1-(char*)0 };
constexpr int c3=(char*)1-(char*)0;

The following solution:

class C {
public:
static constexpr const void* noop = reinterpret_cast<const void*>(0x1);
};
Although, it compiles and works fine in GCC isn't valid C++ (e.g., it doesn't compile with either clang or VC++2013) because according to the standard § 5.19/2 Constant Expressions [expr.const] the result of a reinterpret_cast can't be a constant expression.

_>const int c1=(char*)1-(char*)0;
_>enum { c2=(char*)1-(char*)0 };
_>constexpr int c3=(char*)1-(char*)0;
_>

char* p1 = (char*)0;
char* p2 = 0;
assert(p1 == p2);

1. стандарт всегда прав
2. если стандарт не прав смотри путкт 1

_>const int c1=(char*)1-(char*)0;
_>enum { c2=(char*)1-(char*)0 };
_>constexpr int c3=(char*)1-(char*)0;
_>

char x;
char y;

constexpr int d = &y - &x;

char x[] = "12345";

constexpr int d = &x[3] - &x[1];

struct foo {
  char x;
  int y;
  char z;
};

foo f;

constexpr int d = &f.z - &f.x;

get_offset<&Type::field>();

_>get_offset<&Type::field>();
_>

#include <iostream>

struct A {
    int m_a{};
};

struct B : public A {
    int m_b{};
};

struct C {
    int m_c{};
};

struct D : C, A {
    int m_d{};
};

int main()
{
    using FieldPtr = int A::*;

    B b;
    b.m_a = 1;
    D d;
    d.m_a = 2;

    FieldPtr p1 = &A::m_a;

    std::cout << "B: " << b.*p1 << ", offsetof: " << offsetof(B, m_a) << std::endl;
    std::cout << "D: " << d.*p1 << ", offsetof: " << offsetof(D, m_a) << std::endl;
}

template<class M,class T> int get_ofs(M T::* p) { return (int)(char*)&(((T*)0)->*p); }

#include <iostream>
template<class T>struct get_base_type;
template<class M,class T> struct get_base_type<M T::*> { typedef T base; typedef M value; };
template<class T,T t>struct get_id;
#define DECL_ID(mp,v) template<> struct get_id<decltype(&mp),&mp> { \
    enum { id=v }; \
    typedef decltype(&mp) type; \
    typedef get_base_type<type>::base base; \
    typedef get_base_type<type>::value value; \
};
#define GET_ID(mp) (get_id<decltype(&mp),&mp>::id)

struct A {
    int x,y; double z;
};

DECL_ID(A::x,1)
DECL_ID(A::y,2)
DECL_ID(A::z,3)

int main(int argc, char const *argv[]) {
    std::cout
        <<"A::x="<<GET_ID(A::x)<<"\n"
        <<"A::y="<<GET_ID(A::y)<<"\n"
        <<"A::z="<<GET_ID(A::z)<<"\n"
    ;return 0;
}