portability

Is there any small library, that wrapps various processors' CAS-like operations into macros or functions, that are portable across multiple compilers? PS. The atomic.hpp library is inside boost::interprocess::detail namespace. The author refuses to make it a public, well maintained library. Lets reopen the question, and see if there are any other options? Intel Threading Building Blocks has a nice portable atomic<T> template which does what you want. But whether it is a small library or not can of course be debated.. OPA (Open Portable Atomics) could be a good fit for your needs. https://trac

Values of intermediate multiplication typically need twice the number of bits as inputs. // Example int foo(int a, int b, int carry, int rem) { int2x c; // Some type that is twice as wide at `int` c = (int2x)a * b + carry; return (int) (c % rem); } Considering the potential for padding, (which appears to limit sizeof() usefulness) and non-2`s complement integers (which limits bit dibbling), ... Does the following always create the needed type? If not, how to code at least a reasonable solution, even if not entirely portable? #include <limits.h> #include <stdint.h> #if LONG_MAX/2/INT_MAX - 2 ==

This seems a little backwards to me but it works: #include <iostream> namespace nTest { struct cTest {}; void fTest(cTest& x) { std::cout << "nTest::fTest(cTest&) called" << std::endl; } } int main(void) { nTest::cTest x; fTest(x); //Weird! fTest is resolved since its parameter belongs to nTest. return 0; } Normally, you would need nTest:: in order to access fTest, but its parameter which belongs to nTest appears to add nTest to the list of possible scopes in which to search for fTest. It seems odd to me that the parameter scope influences the function lookup. This compiles fine in GCC, but I

It's been an unpleasant surprise that '\n' is replaced with "\r\n" on Windows, I did not know that. (I am guessing it is also replaced on Mac...) Is there an easy way to ensure that Linux, Mac and Windows users can easily exchange text files? By easy way I mean: without writing the file in binary mode or testing and replacing the end-of-line chars myself (or with some third party program/code). This issue effects my C++ program doing the text file I/O. ybungalobill Sorry for partial overlap with other answers, but for the sake of completeness: Myth: endl is 'more portable` since it writes the

Just encountered decrement of end() iterator in my company source codes and it looks strange for me. As far as I remember this was working on some platforms, but not for the others. Maybe I'm wrong, however I couldn't find anything useful in standard about that. Standard only says that end() returns an iterator which is the past-the-end value, but is it guaranteed to be decrementable? How does code like that match the standard? std::list<int>::iterator it = --l.end(); Thanks in advance. I think this is the relevant clause: ISO/IEC 14882:2003 C++ Standard 23.1.1/12 – Sequences Table 68 lists