🚀 go-pugleaf

In article <1992Oct30.051334.1016@frumious.uucp> uunet.ca!frumious!pat writes:
| sdm@cs.brown.edu (Scott Meyers) writes:
| |I've been wondering about a similar question.  Is there any danger of
| |allowing the "usual" conversions of pointers and references in parameter
| |types of function pointers?  Example:
| |
| |    void f( int (*)(const void*, const void*) );
| |
| |    int g(const char*, const char*);
| |
| |    f( g );                                       // error
| |    f (int (*)(const void*, const void*) g );     // fine
| |
| |If the usual T* ==> void* conversion were allowed for function pointer
| |parameters, no cast would be required when calling f with g.  Is there a
| |lurking danger here?
| 
| I think you have this the wrong way around.  The example above is
| dangerous.  If f() is
| 
|    void f( int (*h)(const void*, const void*) ) {
|       int x;
|       h( &x, &x );
|    }
| 
| you wind up converting an int* to a void* and then to a const char*.
| Such a conversion should require an explicit cast at some point.

This seems like a program error.  The caller is passing a function
expecting const char* arguments, but the callee is using it as if it is
expecting int* parameters.  I'm interested in the case where the caller and
the callee agree on the types of what's being passed:

    void f( int (*h)(const void*, const void*) ) {
        h("Foo", "Bar");
    }
    

Scott

-------------------------------------------------------------------------------
What do you say to a convicted felon in Providence?  "Hello, Mr. Mayor."