Casting Function Pointer to Integer in C++

A C-style cast can fit an octogonal peg into a trapezoidal hole, so I would say that given your extremely specific target hardware and requirements, I would use that cast, possibly wrapped into a template for greater clarity.

Alternately, the double cast to void* and then int does have the advantage of making the code stand out like a sore thumb so your future maintainers know something's going on and can pay special attention.

EDIT for comment: It appears your compiler may have a bug. The following code compiles on g++ 4.5:

#include <iostream>

int f()
{
    return 0;
}

int main()
{
    int value = (int)&f;

    std::cout << value << std::endl;
}

EDIT2: You may also wish to consider using the intptr_t type instead of int. It's an integral type large enough to hold a pointer.

In C++ a pointer can be converted to a value of an integral type large enough to hold it. The conditionally-supported type std::intptr_t is defined such that you can convert a void* to intptr_t and back to get the original value. If void* has a size equal to or larger than function pointers on your platform then you can do the conversion in the following way.

#include <cstdint>
#include <cassert>

void foo() {}

int main() {
    void (*a)() = &foo;

    std::intptr_t b = reinterpret_cast<std::intptr_t>(a);

    void (*c)() = reinterpret_cast<void(*)()>(b);
    assert(a==c);
}

This is ansi compliant:

int MyFunc(void* p)
{
    return 1;
}

int main()
{
   int arr[2];
   int (*foo)(int*);

   arr[0] = (int)(MyFunc);

   foo = (int (*)(int*))(arr[0]);

   arr[1] = (*foo)(NULL);
}