portability

So, a friend of mine asked how my python programming was coming; I said I was learning a lot and that it was coming along nicely. Then my friend, a math-snob, asks me: "Can you swap the value of 2 variables without using a third variable as a temporary placeholder?" Sylvain Leroux The canonical way to swap two variables in Python is a, b = b, a Please note than this is valid whatever the "type" of a or b is (numeric, string, tuple, object, ...). Of course, it works too if both variables reference values of different types. As many imperative languages, Python evaluates assignments right to

Is there something like the ANSI C operator _Pragma in Visual C++? For example, I'm trying to define the following macro: #ifdef _OPENMP #define PRAGMA_IF_OPENMP(x) _Pragma (#x) #else // #ifdef _OPENMP #define PRAGMA_IF_OPENMP(x) #endif // #ifdef _OPENMP So I can circumvent compiler warnings for unknown #pragma omp ... in older GCC compilers. Is there a similar means available in VisualC++? Yes, but it's two underscores: __pragma I'm not sure about how the omp pragma works, however, here's an example using VC++'s optimize pragma: #define PRAGMA_OPTIMIZE_OFF __pragma(optimize("", off)) // These

I'm interested to know which parts of the python standard library are absolutely guaranteed to be available, and which parts might not be installed, dependent on distribution. I've seen this question but it doesn't quite provide the answer I'm looking for. I'm aware that these modules aren't always available and that the math module always is . How about other modules? Are there any modules besides math that are guaranteed to be available? Edit: the sys module is also always available . If you are talking about the standard Python implementation (CPython), then the http://docs.python.org/3

I've come across many comments on various questions regarding bitfields asserting that bitfields are non-portable, but I've never been able to find a source explaining precisely why. At face value, I would have presumed all bitfields merely compile to variations of the same bitshifting code, but evidently there must be more too it than that or there would not be such vehement dislike for them. So my question is what is it that makes bitfields non-portable? Bit fields are non-portable in the same sense as integers are non-portable. You can use integers to write a portable program, but you

On the MSVC++ compiler, one can use the __int8 , __int16 , __int32 and similar types for integers with specific sizes. This is extremely useful for applications which need to work with low-level data structures like custom file formats, hardware control data structures and the like. Is there a similar equivalent I can use on the GCC compiler? Jason Coco ISO standard C, starting with the C99 standard, adds the standard header <stdint.h> that defines these: uint8_t - unsigned 8 bit int8_t - signed 8 bit uint16_t - unsigned 16 bit int16_t - signed 16 bit uint32_t - unsigned 32 bit int32_t -

I often experience situations where I want to print with printf the value of an integer type of implementation-defined size (like ino_t or time_t ). Right now, I use a pattern like this for this: #include <inttypes.h> ino_t ino; /* variable of unknown size */ printf("%" PRIuMAX, (uintmax_t)ino); This approach works so far but it has a couple of disadvantages: I have to know whether the type I'm trying print is signed or unsigned. I have to use a type cast that possibly enlarges my code. Is there a better strategy? #include <inttypes.h> ino_t ino; /* variable of unknown size */ /* ... */ printf

I've recently been working on a system that needs to store and load large quantities of data, including single-precision floating-point values. I decided to standardise on network byte order for integers, and also decided to store floating point values in big-endian format, i.e.: |-- Byte 0 --| |-- Byte 1 -| Byte 2 Byte 3 # ####### # ####### ######## ######## Sign Exponent Mantissa 1b 8b, MSB first 23b, MSB first Ideally, I want to provide functions like htonl() and ntohl() , since I have already been using these for swabbing integers, and I also want to implement this in a way that has as