Russian Qt Forum

C++ (Qt)
struct My
{
    void method () && {}
    void method () & {}
};
 

C++ (Qt)
struct My
{
    void rvalueMethod () && {}
    void lvalueMethod () & {}
};
 

C++ (Qt)
::std::make_shared< My >()->lvalueMethod(); // OK
::std::make_shared< My >()->rvalueMethod(); // Error
 

C++ (Qt)
#include <memory>
#include <iostream>
 
using namespace std;
 
struct A
{
    void lvalueMethod() &
    { cout << "lvalueMethod" << endl; }
 
    void rvalueMethod() &&
    { cout << "rvalueMethod" << endl; }
};
 
int main()
{
    make_shared<A>()->lvalueMethod();
    move(*make_shared<A>().operator->()).rvalueMethod();
 
    return 0;
}

C++ (Qt)
template < typename _Value >
class Wraper
{
    _Value m_value;
public:
    _Value * operator -> () & { return &m_value; }
    // ??? operator -> () && { return ???; }
};
 

C++ (Qt)
    Wraper< My >()->rvalueMethod();
 

C++ (Qt)
int * a = &3; // Error
 

C++ (Qt)
QList<int> lst = this->GeList();
 

C++ (Qt)
QList<int> lst;
this->GeList(lst); 
 

C++ (Qt)
std::string &&str = std::string("Hello");
 

C++ (Qt)
#include <iostream>
 
template < typename value >
class Wraper
{
    // _Value m_value;  <-- UB
    value m_value; 
public:
    Wraper():m_value(10){}
 
    value* lvalueMethod() &  { return &m_value; }
    value* rvalueMethod() && { return &m_value; }
};
 
int main()
{
    auto r = *Wraper<int>().rvalueMethod();
    std::cout << r << '\n';
}
 

C++ (Qt)
struct My
{
    void rvalueMethod () && {}
    void lvalueMethod () & {}
};
 
template < typename _Value >
class Wraper
{
    _Value m_value;
public:
    _Value * operator -> () & { return &m_value; }
    // ??? operator -> () && { return ???; }
};
 
void foo ()
{
    Wraper< My >()->rvalueMethod();
}
 

C++ (Qt)
#include <iostream>
#include <memory>
#include <string>
 
struct payload
{
    std::string m_value = "hello";
 
    std::string& lvalueMethod()&  { return m_value;            }
    std::string&& rvalueMethod()&& { return std::forward< std::string&& >(m_value); }
};
 
template<typename value> struct wrapper
{
    value m_value = {}; 
 
    value&  operator*()&  { return m_value; }
    value&& operator*()&& { return std::forward< value&& >(m_value); }
};
 
int main()
{
    std::string&& val = (*wrapper<payload>()).rvalueMethod(); // OK
 
    std::cout << "val = " << std::endl;
}
 

C++ (Qt)
(*&wrapper<payload>()).rvalueMethod();
 

C++ (Qt)
// Потокобезопасный неявно распределенный вектор целочисленных значений
using ThreadSafeImplisitVector = Instance< Instance< ::std::vector< int >, Implicit >, ThreadSafe >;
ThreadSafeImplisitVector featured_vector;
// применять обычным способом
for ( int i =0; i < 100; ++i )
    featured_vector[i] = i;
 

C++ (Qt)
template < typename _Arg >
decltype(auto) foo ( _Arg && arg )
{
    return ::std::move( arg );
}
 
template < typename _Arg >
decltype(auto) bar ( _Arg && arg )
{
    return ::std::forward< _Arg >( arg );
}
 

C++ (Qt)
Data value;
foo( value ); // rvalue
bar( value ); // lvalue
 
foo( Data() ); // rvalue
bar( Data() ); // rvalue
 

C++ (Qt)
template<typename value> struct wrapper;
 

C++ (Qt)
struct Test
{
    void foo () && { ::std::cout << "Hello rvalue foo method." << ::std::endl; }
    void bar () && { ::std::cout << "Hello rvalue bar method." << ::std::endl; }
};
 

C++ (Qt)
template<class T> struct wrapper
{
    T m_value;
 
    void exec () &&
    {
        ::std::move( m_value ).foo();
        ::std::move( m_value ).bar();
        // 100500 times using of ::std::move( m_value )
    }
};
 

C++ (Qt)
template<class T> struct wrapper
{
    T m_value;
 
    void exec () &&
    {
        ::std::forward< T && >( m_value ).foo();
        ::std::forward< T && >( m_value ).bar();
    }
};
 

C++ (Qt)
template<class T> struct wrapper
{
    T m_value;
 
    void exec () &
    {
        ::std::forward< T & >( m_value ).foo();
        ::std::forward< T & >( m_value ).bar();
    }
    void exec () const &&
    {
        ::std::forward< T const && >( m_value ).foo();
        ::std::forward< T const && >( m_value ).bar();
    }
    // ...
};
 

C++ (Qt)
template<class T> struct wrapper
{
    T m_value;
 
    void exec () &
    {
        ::std::forward< T & >( m_value ).foo();
        ::std::forward< T && >( m_value ).bar();
    }
    void exec () const &&
    {
        ::std::forward< T const && >( m_value ).foo();
        ::std::forward< T const && >( m_value ).bar();
    }
};
 

C++ (Qt)
template<class T> struct wrapper
{
    T m_value;
 
    void exec () &
    {
        static_cast< T & >( m_value ).foo();
        static_cast< T && >( m_value ).bar();
    }
    void exec () const &&
    {
        static_cast< T const && >( m_value ).foo();
        static_cast< T const && >( m_value ).bar();
    }
};

C++ (Qt)
wrapper< Test >().m_value; // rvalue
 

C++ (Qt)
Test().foo(); // Ok
Test test;
test.foo(); // Error
static_cast< Test && >( test ).foo(); // Ok
 

C++ (Qt)
::std::move( value ).foo(); // что и куда перемещаем? что имеется в виду?
container.append( ::std::move( value ) ); // содержимое value перемешается в контейнер и, возможно, сам value некорректен.
 

C++ (Qt)
Test().m_value;
static_cast< Test && >( test ).m_value;
::std::move( test ).m_value;
 

C++ (Qt)
Test func ();
func().bar(); // Oк
Test test;
test.bar(); // Error