The idea is simple, you define a base class that has an interface with the functionality you need, and then inherit from it. Since the type erased class uses only that interface, the actual type underneath is forgotten and erased. Alternatively, if the only needed interface can be expressed as free functions you can store … Read more
As documented in tcp::socket reference: Following the move, the moved-from object is in the same state as if constructed using the basic_stream_socket(io_service&) constructor. The above means that you can move the original socket object from server to session as many times as you need.
An answer to your first question: The virtual destructor in your dll is called – the information about its location is embedded in your object (in the vtable). In the case of memory deallocation it depends how disciplined the users of your IBase are. If they know they have to call Release() and consider that … Read more
You have to use the same mutex to guard the queue as you use in the condition variable. This should be all you need: void consume() { while( !bStop ) { boost::scoped_lock lock( mutexQ); // Process data while( messageQ.empty() ) // while – to guard agains spurious wakeups { condQ.wait( lock ); } string s … Read more
I was experiencing the same issue. As, the error itself suggests – Failed to write core dump. Core dumps have been disabled. To enable core dumping, try ulimit -c unlimited before starting Java again ulimit gets and sets user limits. For more info on ulimit do – man ulimit So, open a terminal and run … Read more
template<class T>struct sink{typedef void type;}; template<class T>using sink_t=typename sink<T>::type; template<typename T, typename=void>struct my_test:std::false_type{}; template<typename T>struct my_test<T, sink_t<decltype( put code here. Note that it must “fail early”, ie in the signature of a function, not in the body )> >:std::true_type {}; The above generates a test if the “put code here” can be evaluated. To determine … Read more
Because you did not specify how you have built, and on what platform, I’ll explain the whole story. Both on Linux and Windows, Boost.Thread library is built in MT mode. On Windows, by default, you get -mt suffix for it. On Linux, by default in 1.42, you get no suffix. The reason you get no … Read more
The experimental GCC version 4.7 disables Boost.Threads. See: https://svn.boost.org/trac/boost/ticket/6165 Edit: It should be noted that as of the release version of GCC 4.7, and Boost higher than 1.48 (Boost_1_48_0 is still not working), threads works again.
Boost irange should really be the answer (ThxPaul Brannan) I’m adding my answer to provide a compelling example of very valid use-cases that are not served well by manual looping: #include <boost/range/adaptors.hpp> #include <boost/range/algorithm.hpp> #include <boost/range/irange.hpp> using namespace boost::adaptors; static int mod7(int v) { return v % 7; } int main() { std::vector<int> v; boost::copy( … Read more
Just don’t define the class: template <typename Type> class Foo; template <> class Foo<int> { }; int main(int argc, char *argv[]) { Foo<int> f; // Fine, Foo<int> exists Foo<char> fc; // Error, incomplete type return 0; } Why does this work? Simply because there isn’t any generic template. Declared, yes, but not defined.