intrusive_ptr | Proposal for std : :intrusive_ptr

You might use variadic template:

I have a suspicion the real problem is with binding which is likely not correctly initialized. There's bound to be more compiler messages about that.

It could be because Boost Bind stopped putting the _1 placeholders in the global namespace by default. You might detect this by adding -DBOOST_BIND_GLOBAL_PLACEHOLDERS to the compiler flags. However, heed the advice from the code:

Starting with the example in the documentation makes for a simpler implementation.

Incrementing the reference count does not require any synchronization in a correct program, just atomicity.

We pretend that references are owned by threads. A thread may only use a referenced object if the reference counter is at least one, and is guaranteed not to drop to zero while the object is being used, which either means that the thread has incremented the reference counter during its use of the object, or there is another mechanism that ensures this condition is met.

Thus, we assume that the thread incrementing the reference count owns the reference that ensures that it may access the object's reference counter, so no other thread may decrement the reference counter to zero while it is trying to increment the counter. The only thread allowed to drop the initial reference is either the current thread (after incrementing the reference count), or another thread once the current thread has signaled that its shared use of the object (i.e. the "ownership" of the original reference) has ceased -- both of these are visible effects.

On the other hand, decrementing the reference counter requires acquire and release semantics, as the object may be destroyed afterwards.

The CPP Reference's page on std::memory_order says

Typical use for relaxed memory ordering is incrementing counters, such as the reference counters of std::shared_ptr, since this only requires atomicity, but not ordering or synchronization (note that decrementing the shared_ptr counters requires acquire-release synchronization with the destructor).

The one solution to your problem I know is to make sure there are no (implicitly) defined constructors or destructors for A in your header file. The minimal example would look like:

(header file)

Try to change CorbaType* result; to const CorbaType* result; on line 259 of rtt/rtt/transports/corba/CorbaConversion.hpp

It looks like you have an ABI mismatch issue. ABI is "Application Binary Interface", basically the specification for exactly how arguments make it onto the stack (or are put in registers) and various other things like that.

Try making sure your code is compiled with the -std=c++11 (or -std=gnu++11 if you use any GNU extensions) flag. It looks like that's how libkml was compiled. C++11 has a bunch of new features that require an ABI compatibility break with pre-C++11. C++14 and C++1z are less drastic changes, but they may also break ABI compatibility, I'm not sure. In this case though, the demangled symbol is clear, libkml wants at least C++11.

According to this page, ADL support was added in Visual Studio 2008.

With some difficulty, I was able to build EGCS 1.1, the first GCC version that claimed to support namespaces, released in 1997. I tested it by compiling and running the following program: