Question

When I learn delegate of C#, my book said that delegate same with function pointer in C, but more safer. After I read that line, I think : Ah, so C Compiler will not check prototype where the function pointer points to. And I’m totally wrong.

int add(int a, int b){ return a + b; }
float add_f(float a, float b){ return a + b; }

int (*f)(int,int);
f = add; // no compile-error
f = add_f; //compile-error

So, Please tell me why, and give me some examples to prove that C function pointer is unsafe when compare to delegate in C#, please.

Thanks 🙂

Answer 1

In C++, function pointers are type-safe. You have to do something spectacularly stupid to break them (generally involving casting, unions, memcpy, or similar; it can’t happen by accident).

In C, though, function types aren’t nearly as strict. You can do things like this:

int add(int a, int b){ return a + b; }
int add_f(float a, float b){ return a + b; }

int (*f)(); // empty argument list does NOT mean zero arguments.
            // for zero arguments, say int (*)(void)
f = &add;
f = &add_f;

http://ideone.com/Y6mCc

---

I was asked for an example of spectacularly stupid. Here goes:

#include <iostream>

int add(int a, int b){ return a + b; }
int add_f(float a, float b){ return a + b; }

union {
    int (*f1)(int, int);
    int (*f2)(float, float);
} fp;

int main(void)
{
    fp.f1 = &add;
    std::cout << "Expected (1): " << add(1, 3) << std::endl;
    std::cout << "Actual   (1): " << (fp.f1)(1, 3) << std::endl;

    std::cout << "Expected (2): " << add(1.0f, 3.0f) << std::endl;
    std::cout << "Actual   (2): " << (fp.f2)(1.0f, 3.0f) << std::endl;

    fp.f2 = &add_f;
    std::cout << "Expected (3): " << add_f(1.0f, 3.0f) << std::endl;
    std::cout << "Actual   (3): " << (fp.f2)(1.0f, 3.0f) << std::endl;

    std::cout << "Expected (4): " << add_f(1, 3) << std::endl;
    std::cout << "Actual   (4): " << (fp.f1)(1, 3) << std::endl;

    return 0;
}

Note that this foolishness is equally possible in C# with Marshal.Copy.