Question: I have a textbox and a button with an onClick event connected to it, and when the button is clicked once I want to change the text of the button and clear the textbox. How can i accomplish this?

Answer: 
Some environments support this more or less directly.

For instance, if you enable [structured exception handling](http://msdn.microsoft.com/en-us/library/windows/desktop/ms680657(v=vs.85).aspx) and C++ exceptions through the [`/EH`](http://msdn.microsoft.com/en-us/library/1deeycx5(VS.71).aspx) compiler switch, you can have C++ exceptions implemented over Microsoft's structured exception handling ("exceptions" for C). Provided these options are set when compiling all your code (the C++ at each end and the C in the middle) stack unwinding will "work".

**However, this is almost always a Bad Idea (TM).** Why, you ask? Consider that the piece of C code in the middle is:

```
WaitForSingleObject(mutex, ...);
invoke_cxx_callback(...);
ReleaseMutex(mutex);

```

And that the `invoke_cxx_callback()` (....drum roll...) invokes your C++ code that throws an exception. You will leak a mutex lock. Ouch.

You see, the thing is that most C code is not written to handle C++-style stack unwinding at any moment in a function's execution. Moreover, it lacks destructors, so it doesn't have [RAII](http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization) to protect itself from exceptions.

[Kenny TM](https://stackoverflow.com/a/9252210/313063) has a solution for C++11 and Boost-based projects. [xxbbcc](https://stackoverflow.com/a/9252216/313063) has a more general, albeit more tedious solution for the general case.
You can probably pass a structure across the C interface that gets filled out with error information in case of an exception and then when that is received on the client side, check it and throw an exception inside the client, based on data from the structure. If you only need minimal information to recreate your exception, you can probably just use a 32-bit/64-bit integer as an error code. For example:

```
typedef int ErrorCode;

...

void CMyCaller::CallsClient ()
{
    CheckResult ( CFunction ( ... ) );
}

void CheckResult ( ErrorCode nResult )
{
    // If you have more information (for example in a structure) then you can
    // use that to decide what kind of exception to throw.)
    if ( nResult < 0 )
        throw ( nResult );
}

...

// Client component's C interface

ErrorCode CFunction ( ... )
{
    ErrorCode nResult = 0;

    try
    {
        ...
    }
    catch ( CSomeException oX )
    {
        nResult = -100;
    }
    catch ( ... )
    {
        nResult = -1;
    }

    return ( nResult );
}

```

If you need more information than a single int32/int64 then you can allocate a structure before the call and pass its address to the C function which will, in turn, catch exceptions internally and if they happen, throws an exception on its own side.