What should expericenced Unix programmer to be aware of using Microsoft Tools?

I come from UNIX world, I'm quite familiar with Linux, Solaris, Cygwin and MinGW development. Recently I ported one of my big projects (cppcms) to support MSVC, including building static and dynamic libraries with CMake.

And I get all the time absolutely weird issues:

1. I had CMake build issues because Windows programming lacks naming convention for import and static libraries.

2. Now I discovered that I should use different versions of ICU (debug/release builds) according to the actual build I do (Debug/RelWithDebInfo -- should use Debug ICU, Release release ICU) and so I should change actual conventions for searching libraries according to debug/release mode only under MSVC. Otherwise application just would not start giving a error on missing DLL.

   I don't have any such issues under Mingw or Cygwin with GCC, Open Solaris with Sun Studio or Linux with gcc or intel compilers.

3. And I still have numerous wired issues and wired bugs and very strange behavior -- even some trivial things do not work under MSVC builds, when everything works absolutely fine under Solaris/Linux/Cygwin/Mingw using GCC from 3.4 up to 4.4, Sun Studio and Intel compi开发者_开发技巧lers). But not under MSVC.

   To be honest, I have no idea how to deal with Last one! Because it looks like for me more like environment issues.

I know that the question is not really well defined. I think I'm quite experienced developer and I know how to write portable and good C++ code. But using Microsoft native tools drives me crazy with issues I just don't know how to solve.

Question: What should experienced Unix programmer with quite good base in Win32 API should know when it starts using Genuine Microsoft Tools?

P.S.: Can someone explain why "Release With Debug Info" requires Debug version of MSVC runtime? And why there two versions of runtime exist at all?

P.P.S.: Please note I don't have issues with Win32 API, in fact Windows GCC build works absolutely fine.

Clarifications:

I'm looking for pitfalls that programmer that come from Unix world would may fall into.

For example, when moving from Linux to Solaris: make sure you compile code with -mt or -pthreads when using multi threaded programs, linking with -lpthread is not enough.

P.S.: Can someone explain why "Release With Debug Info" requires Debug version of MSVC runtime?

It doesn't.

And why there two versions of runtime exist at all?

Because the debug version does more error checking.

And I still have numerous wired issues and wired bugs and very strange behavior -- even some trivial things do not work under MSVC builds,

* What am I doing wrong?

Not telling us what "wired issues and wired bugs and very strange behavior" you get.

* Where should I start?

By telling us the specific errors and problems you encounter.

* What do I miss?

Reading the documentation and learning the tools.

If your question is "What do I read to become a good Windows programmer?" then my answer is: Everything from Jeff Richter, as a start.

There is no magic bullet which will automatically make you an experienced Windows developer. Windows is a very different land compared to Unix. There are lots of quirks, weird behavior, and stuff which is just plain different. The only way to get out with your sanity intact is to tackle the transition one small problem at a time. Concentrate on a specific problem and try to understand the problem. Don't just "get it to work", but really understand what is happening. A good book about Windows programming will help.

There are huge amounts of Windows knowledge and experience accumulated in the SO community, but the only way to access it is to ask concrete questions about specific problems.

The release and debug versions of DLL's use different ways of allocating memory, that is why it is not advisable to mix release and debug versions. If you allocate something in a debug mode DLL and pass it back to the application which was compiled in release mode you may get into trouble.

In the case of your naming issues you may want to have different directories where you place your static / dll's. You can do do this in visual studio by using the configuration manager, not sure how it is under the express version.

I think you need to try and actually understand the new toolset rather than just try and squish it into your current understanding of your existing tools. For that, the best way, IMHO, is for you to try and start to use Visual Studio as Microsoft intended and then once you can build a simple project in the IDE you can move to building it using your preferred make system but do so with an understanding of how the IDE is using its make system to set things up for that build (which WILL work).

So, for example, for part 1 of your question you want to create a simple static library project and a simple dll project and look at the linker options tabs. Jump to the 'Command line' view and you'll see that a DLL uses the /OUT linker option to set the name and location of the dll file and the /LIB linker option to set the name and location of the import library. With a static library only the /OUT option is used and it indicates the name of the static lib. It's true that if you're building a static lib and a DLL from the same source and you have both the /LIB for the dll set to MyCrossPlatformCode.lib and /OUT set to MyCrossPlatformCode.dll then you may have problems if you also build a static lib with an /OUT switch of MyCrossPlatformCode.lib... Simply don't do that; either build the static libs to a different output directory (which is what OpenSSL does), or, better (IMHO), mangle the names somewhat so that you have MyCrossPlatformCode.lib/.dll and MyCrossPlatformCode_static.lib (which is what STLPort does).

Note that you might also want to mangle in (or account for) building with different versions of the Microsoft tool chain (so you might end up with stlport_vc8_x64d_static.5.1, perhaps).

An alternative approach, if you really can't face the thought of understanding your toolset, is that you could take a look at some of the popular open source systems that build quite fine on Windows and Unix systems; OpenSSL and STLPort for a start, perhaps.