Overview of Portability Issues

The Visual C++ language is designed to be as platform-independent as possible. When portability issues arise, it is generally because the code makes erroneous assumptions about the underlying hardware.

C/C++ is a relatively low-level language. For example, given the address of an object on the stack, you can use pointers to attempt to access other objects you believe are also on the stack, just above or below the first object. Adopting such an approach is a typical cause of errors when porting code from x86 to Alpha because the Alpha calling conventions do not use the stack the same way that x86 calling conventions do.

Such conflicts are possible because the power and flexibility of C and C++ can sometimes be used to exploit implicit knowledge of how the underlying hardware operates. Unfortunately, such programming practices can cause problems that are difficult to debug when porting to other architectures. The following guidelines can help you in writing portable code:

• To avoid alignment errors, turn structure packing off unless necessary; for example, when working with FAT file structures. If you must use structure packing, you should use the _ _unaligned keyword to avoid alignment fixups in memory. Fixing up alignment errors in memory can result in up to a 300% performance penalty.
  
  
• Do not recast data pointers to a larger size and then dereference them; this is another cause of alignment errors.
  
  
• Revise any code that attempts to use pointers to access arguments directly from the stack by using STDARG.H.
  
  
• Check your use of format (e.g., printf and scanf) specifiers. The sizes of some types might change from one platform to another.
  
  
• Use %Processor% in your makefiles instead of hard-coding or making assumptions about the processor architecture.