I have coded a lock-free and thread-safe ring queue with C++20, and it works so far. The only thing is not perfect that it has to have two enque() methods, one accepts a const reference to a lvalue as a argument, and the other accpects a reference to a rvalue, so as to move a rvalue into the queue instead of constructing again.
The before version of codes is following and merely a skeleton, to be simplified:
template <typename T>
class RingQue_t {
public:
explicit RingQue_t( size_t capacity );
~RingQue_t();
bool deque( T& dest_ ) { return true; };
// If we offer a const ref, the compiler will select this one
bool enque( const T& src_ ) {
// a lot of same codes goes here for a same logic...
new( _buff + _tail ) T( src_ );
};
// If we offer a rvalue ref, the compiler will select this one
bool enque( T& src_ ) {
// a lot of same codes goes here for a same logic...
new( _buff + _tail ) T( std::move( src_ ) );
};
protected:
T* _buff = nullptr;
};
I'm trying to merge these two methods into one, and had read some docs and examples about std::forward, but I still can NOT use it correctly.
This is my expecting:
template <typename T>
class RingQue_t {
public:
template<typename U>
bool enque( U&& src_ ) {
// new( _buff + _tail ) T( src_ );
// new( _buff + _tail ) T( std::move( src_ ) );
// new( _buff + _tail ) T( std::forward<T>( src_ ) );
std::allocator<T> allc;
allc.construct( _buff + _tail, std::forward<T>( src_ ) );
return true;
};
};
// testing
const std::string s0 { "s0" };
RingQue_t<std::string> str_que( 16 );
str_que.enque( std::string { "s1" } ); // works
str_que.enque( s0 ); // can not pass the compiling.
All solutions in comments had been tried, none works. I always receive a error msg:
binding reference of type ‘std::remove_referencestd::__cxx11::basic_string<char >::type&’ {aka ‘std::__cxx11::basic_string&’} to ‘const std::__cxx11::basic_string’ discards qualifiers
What is the correct way to use std::forward?
