Question

I used the following code to invoke an invalid parameter handler if the user enters more than 4 characters.Actually it’s the gets_s() function which invokes the handler.

...
    char arr[5];
    _invalid_parameter_handler newHandler;
    newHandler = myInvalidParameterHandler;
    _set_invalid_parameter_handler(newHandler);

    gets_s(arr,4);
...
}
void myInvalidParameterHandler(const wchar_t* expression,const wchar_t* function, 
   const wchar_t* file, 
   unsigned int line, 
   uintptr_t pReserved)
{
...
}

Now, my question is how gets_s() calls/invokes the handler internally?I am asking this because I want to do something similar in my program.For eg. lets say I have a function declared like-

EDIT:

If when running the above code the user enters more than 4 characters then the handler is invoked.If I comment out the invalid handler related code then my program will crash.The same I want to achieve.
If some one uses my function he should get same behavior as I get when using gets_s.Please don’t suggest this is good or bad.I just want to learn it.gets_s doesn’t know which handler func I am gonna set.Similarly my function doesn’t know which invalid handler func the user will set.I think there might be some C runtime global variable of type _invalid_parameter_handler which the ‘_set_invalid_parameter_handler()’ func sets which gets_s uses.

Answer 1

In my opinion 1 and 3 are the same, and yes you could do it like that. Have all your functions call a function pointer in some global struct and you’re set.

• Set up a global object that contains a function pointer and some bookkeeping dat
• When a function detects something wrong it can call the handler

But don’t do it. It’s way better to return an error status than to automatically call a function when something “feels” wrong. Then you can check the return status and act on it, instead of some automatic handler taking over.

EDIT

From your comment I believe you don’t know about function pointers.

/* here is the handling function */
void handler(char *msg)
{
    fprintf(stderr, "%s\n", msg);
}

void (*err_handler)

void some_function_like_gets(void *arg)
{
    if (NULL == arg) {
        (*err_handler)("Oh noes! You passed a NULL pointer :(");
        return;
    }

}


int main()
{
    /* ... */

    /* setting up handler */
    err_handler = handler;

    /* calling function */
    some_function_like_gets(NULL);

    /* ... */    
}

EDIT 2

The sad part is that you downvoted this even though the MSDN page says:

[in] pNew The function pointer
to the new invalid parameter handler.