How to write portable code in c++?

Question

What are the things that I should keep in mind to write portable code? Since I\'m a c++ beginner, I want to practice it since beginning.

Thanks.

Answer 1

If you can, compile all your code with at least two different compilers.

Answer 2

The unwary programmer is likely to walk into a whole lot of traps, that we can attempt to categorize. But let me tell you first: as an absolute it's impossible.

The problem is that even standard-conforming code might not be portable because of a particular compiler issue.

Now here are the main categories that I can think off the top of my head.

Compiler extensions

Like for example the use of variables arrays:

void func(int const n)
{
  int array[n];
}

This is not standard, but many compilers support it nonetheless because it's just practical.

Standard libraries extensions

Many standard libraries implementations provide a std::hash_map which never was specified. If you use it in your code, it's not portable.

The modern trend is to stash this stuff into the std::tr1 namespace so that programmers are aware that this is an extension.

Also be aware that many define typedef or macros that are not generic (for example PRETTY_FUNCTION). No macro is specified by the standard, and very few typedef are.

Platform specific

For example, the size and alignment of int or double is not specified in the standard. If you do bit-twiddling and expect it to have 32 bits, you'll be screwed on 64 bits platforms even without changing your compiler.

Platform API

Our programs are meant to be compiled, and they are often meant to interact with the computer they run on:

• for access to the hardware
• for access to the filesystem
• for access to the screen

You need to find cross-platform portable APIs, or roll your own. Check some libraries in the list below.

Libraries

Most well-written libraries are largely portable, just make sure that they support:

• the compilers you are interested in
• the platforms you are interested in

Good libraries involve:

• Apache (the collection of libraries)
• Boost
• Qt (for graphic)
• ICU (for Unicode handling)

The others you need to review... and that takes time.

I don't think there is a perfect answer there. But since perfect portability is not possible you need to decide which compilers and platform you wish to support.

For the platform, you should begin with Windows and one Linux flavor. For the compilers, pick any two (with Comeau if you can afford it).

Answer 3

Some guidelines:

1. Keep the business end of the code and the GUI separate.
2. Avoid the use of compiler specific crutches (#pragma, etc.)
3. Use conventional expressions that won't change behavior with compiler/platform instead of cute bit manipulation tricks.
4. If it touches hardware it belongs in a device driver.
5. Use data type headers like types.h (uint32_t, etc.).
6. Use an operating system abstraction layer so you are not calling operating system calls directly.

Sometimes you have to trade off efficiency and performance to gain portability. For example, if your code requires accessing fields out of a buffer you can always cast a packed struct to the buffer pointer. But that is horribly non-portable. So instead you need to use named pointers calculated with offsets -- sometimes with boundary alignment handling code. Not pretty, but portable. Fortunately you can hide a lot of that stuff with judicious use of class interfaces.

Not all code needs to be written that way. If you design your application in a very modular way with well defined boundaries of responsibility then 90-95% of the code can be portable without pain. Then just isolate the 5-10% in a very localized area that would need to be customized for a new platform.

Answer 4

For learning, try to avoid books that concentrate on one implementation. In some cases, the introduction or an early chapter will give you some instructions on how to get or use a language implementation; if it mentions more than one implementation you're probably OK.

Get a reference book that's platform-independent. Stroustrup's The C++ Programming Language is a fine reference, although it's not a good book for a beginner to try to learn from. Don't rely on references for a given implementation. MSDN is useful, for example, but its main focus is how to write Windows programs using Visual C++, not how to write programs that will compile and run anywhere.

To write anything really useful, you're going to have to get into nonportable code. Try to get in the habit of separating the user interface code from everything else, since that's where you'll have the least compatibility. The less code you have to change between platforms, the more portable your code is.

Answer 5

• learn to use the standard library
• read books (eg. this one)
• when you're experienced, learn to use boost

Answer 6

OS-independent code is surprisingly hard to do in C++. Consider this trivial example:

#include <iostream>
int main(int argc, char** argv) {
  std::cout << argv[0] << std::endl;
}

That is perfectly valid C++, still it's nonportable because it won't accept Unicode command line arguments on Windows. The correct version for Windows would be:

#include <iostream>
int wmain(int argc, wchar_t** argv) {
  std::wcout << argv[0] << std::endl;
}

Of course that is again nonportable, working only on Windows and being nonstandard. So in fact you cannot even write a portable main() function in C++ without resorting to conditional compilation.