Let us stay simple and state I want and need to use a single definition for fundamental types with fixed dimensions. (let's forget about why do Microsoft and the C/C++ standards provides non-fixed size...)

How do you deal with the tons of the Windows data types, the VC compiler data types, and the C/C++ unfixed data types? Do you split into two parts your project, one where you code only with your own defined types (where you do not have any external library includes) and another where you have to deal with the Windows headers or other libraries?

Actually I pretty like to use the cstding fixed-size integers, but every-time a function or a structure except a Windows data type I always check for compatibility through C++-style casts (not C-style casts). It is useless to state how boring and annoying is this.

I was thinking to create an header where using tons of static_assert and check the compatibility of my types with Windows Data types and C/C++ types. But I am not sure about that, since I was to add it in the PCH after the Windows and the C/C++ standard library includes.

So, any advice how to make neat all this is accepted.

What do you do in a piece of code where you retrieve/pass parameters to/from Windows libraries? Actually I pass my types (or just <cstint> types) and then I static_cast them from/to windows data types. But this is really annoying.

// window.h

#include <windows.h>

class Window
{
    HDC windowDeviceContext;
    HWND windowHandle;
public:
    Window(const std::string& title, int width, int height);
    void SetSize(int width, int height);
    void SetTitle(const std::string& title);
    ...
};

Windows-specific code should always be strongly decoupled/isolated from the rest of your code-base. That's just good cross-platform practice!

Only very small amounts of your game should interact with Windows (or other low-level APIs) directly, and these parts of your game should be isolated behind some nice, easy-to-use interface. The rest of your game (99% of your code) should be all nice and standard and clean and portable :)

Yes, I still try to separate my own code with code that directly interact with 3rd party libraries (like win32 APIs). I was wondering if there are some dirty tricks (even preprocessor tricks) to feed my laziness and avoid explicit static_cast et similia.

Another question: is a good practice to "undef" 3rd party data types in the project parts you do not need them? I saw that in the UE source code.

Another question: is a good practice to "undef" 3rd party data types in the project parts you do not need them? I saw that in the UE source code.

I was wondering if there are some dirty tricks (even preprocessor tricks) to feed my laziness and avoid explicit static_cast et similia.

MyVec4 cast( const TheirVec4& v )
{
  static_assert( sizeof(MyVec4) == sizeof(TheirVec4) );
  static_assert( offsetof(MyVec4,x) == offsetof(TheirVec4,x) );
  static_assert( offsetof(MyVec4,y) == offsetof(TheirVec4,y) );
  static_assert( offsetof(MyVec4,z) == offsetof(TheirVec4,z) );
  static_assert( offsetof(MyVec4,w) == offsetof(TheirVec4,w) );
  return *(MyVec4*)&v;
}

BYTE windows = 42;
uint8_t portable = windows;//no cast, because BYTE is an unsigned 8bit integer!

Thank you, I was not aware about offsetof macro... So, I will try to create some sort of control checks where I put the Windows headers and since cl.exe do not allows multiple pre-compiled headers, I will split all the work into two projects (which was not the initial intention because I am actually working alone on it).