Safely casting pointer types, purpose of static_cast, etc.

There have been some recent threads about casting pointers to and from
void* that have me rethinking some of my usual practices. I have a
couple of questions.

1. What is the purpose of C++'s static_cast<>? In other words, is
there any real difference between statements like (with non-pointer
types):

  double a = 3.4;
  int b = (int)a; // <--- this
  int c = static_cast<int>(a); // <---

2. What about static cast with void*'s and pointers to class types, is
there any difference here, and also, are these conversions all safe:

  Object *a = new Object;
  void *b = a;
  Object *c = (Object *)b;
  Object *d = static_cast<Object *>(b);

In that code is there any difference between the conversion when
initializing c and d? And, are c/d guaranteed to be valid pointers to
the same object a points to?

3. If c/d are not guaranteed to be valid pointers, what is the correct
way to do that conversion in a situation where a void* must be used as
an intermediate variable to hold a pointer to an object (e.g. when
passing through a layer of C code)? For example, when creating a
thread with pthread_create, a void* parameter can be passed to the
thread function. So, then, is the following code guaranteed to always
do what I want on any platform:

=== BEGIN EXAMPLE ===

class A {
public:
  void CreateThread ();
private:
  void * MyThreadProc_ ();
  static void * SThreadProc_ (void *);
};

// creates a thread
void A::CreateThread () {
  pthread_t tid;
  // 4th param is void* param to pass to SThreadProc_.
  pthread_create(&tid, NULL, &SThreadProc_, this);
}

// static thread function calls ((A*)va)->MyThreadProc_();
void * A::SThreadProc_ (void *va) {
  A *a = (A *)va; // <--- is this always safe?
  return a->MyThreadProc_();
}

=== END EXAMPLE ===

Thanks,

Jason