C++ - Reddit

made the application misbehave. That includes every possible issue, not just C++ exceptions being thrown. And that is very powerful.

I simply have this standard SE aware main in each and every of my WIN apps. That is **not** very complicated and has a lot of benefits.

Please do understand SE is inbuilt in Windows and in the CL compiler and there are SE intrinsics too. Including the [keywords added](https://docs.microsoft.com/en-us/windows/win32/debug/abnormaltermination) to both C and C++.

### 1.2.2. SEH friendly, standard Windows C++, you can do too

Now you know how that mechanism and design works. You can do that too in your C++ Windows, SEH friendly code.

```cpp
namespace my {
inline namespace constants {
enum error_type {
error_ctype,
error_syntax
};
} // my namespace constants

// my::error does not inherit from std::exception
struct error final
{
error () = default ;
const char * msg_ {"unknown"};
const char * what () const noexcept { return msg_ ;
explicit error( constants::error_type ex_ ) noexcept : err_(ex_)
{ /* here make the message by the code */ }
constants::error_type code() const { return err_ ; }

#ifndef MY_RAISE
#ifdef _DEBUG
#define MY_RAISE(x) _invoke_watson(_CRT_WIDE(#x), __FUNCTIONW__, __FILEW__, __LINE__, 0)
#else // _DEBUG
#define MY_RAISE(x) _invoke_watson(nullptr, nullptr, nullptr, 0, 0)
#endif // _DEBUG
#endif // ! DBJ_RAISE

// we raise the SEH from here
// and through calling _invoke_watson
[[noreturn]] void raise() const {
DBJ_RAISE(*this) ;
}

} ; // eof error
```
We will always use the `MY_THROW` macro
```cpp
#if _HAS_EXCEPTIONS == 0
MY_THROW(x) x.raise() ;
#else
MY_THROW(x) throw x ;
#endif
```
Lastly, there is always a function that does the raise, and does not return. A level of indirection to improve the change-ability of the design always exist:
```cpp
[[noreturn]] inline void __cdecl
error_throw (const constants::error_type code_)
{
MY_THROW( error(code_) ) ;
}
} // eof my ns
```
To enjoy the SEH benefits, your Windows main should always be "SEH enabled"
```cpp
// The "Standard" main()
// build without /EHsc or any other /EH
// or use the /kernel switch
extern "C" int main (int argc, char ** argv)
{
__try
{
__try {
my::error_throw( constants::error_type::error_syntax ) ;
}
__finally {
// will be always visited
}
}
__except ( 1 /* 1 == EXCEPTION_EXECUTE_HANDLER */ )
{
// your code here
}
return 0 ;
}
```
That will always work c++ exception or no C++ exceptions. In case you want C++ exceptions you can not mix that in the same function, so you just call some entry point into your standard C++ app from the `main()` above.

If you build with `/EHsc` your app will be: c++ exceptions **and** SEH enabled. If built without, you will be intrinsic SEH enabled. SEH intrinsics are in `<excpt.h>`

> In Windows C/C++, SEH is always there

### 1.2.3. COM, C++ and /kernel builds

["Compiler COM Support"](https://docs.microsoft.com/en-us/cpp/cpp/compiler-com-support?redirectedfrom=MSDN&view=vs-2019) was designed, implemented and tested to also use C++ exceptions. Not SEH.[MSFT COM](https://en.wikipedia.org/wiki/Component_Object_Model) predates C++ standardizations. Just like SEH does.

In 2020 Q4, if and when attempting C++ `/kernel` or no `/EH` builds, C++ exceptions are replaced with SEH.

You need to know right now [things are happening in there "by accident"](https://github.com/MicrosoftDocs/cpp-docs/issues/2494#issuecomment-701200395). Pleas do not rely on `<comdef.h>` `/kernel` or not `/EH` combination until further notice.

"Compiler COM Support" and SEH is accidental combination that works 2020 Q4.

MSFT ["Compiler COM Support"](https://docs.microsoft.com/en-us/cpp/cpp/compiler-com-support?redirectedfrom=MSDN&view=vs-2019) I do like, it is C++, it is simple and it "just works". But these days it is meeting the not-so-simple standard C++, and WG 21

Docs

AbnormalTermination macro - Win32 apps

Indicates whether the \_\_try block of a termination handler terminated normally. The function can be called only from within the \_\_finally block of a termination handler.

23 views11:23