Russian Qt Forum

C++ (Qt)
class X
{
    void method () &;
    void method () const &;
    void method () volatile &;
    void method () const volatile &;
    void method () &&;
    void method () const &&;
    void method () volatile &&;
    void method () const volatile &&;
};
 

C++ (Qt)
class X
{
    void method () mutable, const &, volatile &&, const volatile; // как-нибудь так
    // или по-другому
};
 

C++ (Qt)
 
#define METHOD_PROTOTYPE( refer ) ...
 
#define METHOD \
    METHOD_PROTOTYPE( && ) \
    METHOD_PROTOTYPE( const && ) \
    METHOD_PROTOTYPE( volatile && ) \
    METHOD_PROTOTYPE( const volatile && ) \
    METHOD_PROTOTYPE( & ) \
    METHOD_PROTOTYPE( const & ) \
    METHOD_PROTOTYPE( volatile & ) \
    METHOD_PROTOTYPE( const volatile & ) \
 
class X
{
    METHOD
};
 

C++ (Qt)
template<class T>
T Lerp( const T & a, const T & b, double w ); 
 

C++ (Qt)
 
class Type
{
    // ...
    iterator begin ();
    const_iterator begin () const;
    // ...
};
 
// развернутая рефлексия для Wrapper, код достаточно страшный на вид)
 
class Wrapper
{
    Type m_type; // например, Wrapper содержит Type по значению
    // ...
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) & { /*additional code*/; return m_type.begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) const & { /*additional code*/; return m_type.begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) volatile & { /*additional code*/; return m_type.begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) const volatile & { /*additional code*/; return m_type.begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) && { /*additional code*/; return static_cast<Type && >( m_type ).begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) const && { /*additional code*/; return static_cast<Type && >( m_type ).begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) volatile && { /*additional code*/; return static_cast<Type && >( m_type ).begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) const volatile && { /*additional code*/; return static_cast<Type && >( m_type ).begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    // ...
};
 

C++ (Qt)
 
struct Type
{
    void method () && { ::std::cout << "Hello rvalue method " << ::std::endl; }
};
 
void main ()
{
    Type().method(); // ОК
 
    Type value;
    value.method(); // ERROR
    ::std::move( value ).method(); // OK
}
 

C++ (Qt)
 
class Type
{
    // ...
    iterator begin ();
    const_iterator begin () const;
    // ...
};
 
// развернутая рефлексия для Wrapper, код достаточно страшный на вид)
 
class Wrapper
{
    Type m_type; // например, Wrapper содержит Type по значению
    // ...
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) & { /*additional code*/; return static_cast< Type & >( m_type ).begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) const & { /*additional code*/; return static_cast< Type const & >( m_type ).begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) volatile & { /*additional code*/; return static_cast< Type volatile & >( m_type ).begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) const volatile & { /*additional code*/; return static_cast< Type const volatile & >( m_type ).begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) && { /*additional code*/; return static_cast<Type && >( m_type ).begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) const && { /*additional code*/; return static_cast<Type const && >( m_type ).begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) volatile && { /*additional code*/; return static_cast<Type volatile && >( m_type ).begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    template < typename ... _Arguments,  typename = ::std::enable_if_t< подходящий метод для _Type существует > >
    decltype(auto) begin ( _Arguments && ... arguments ) const volatile && { /*additional code*/; return static_cast<Type const volatile && >( m_type ).begin( ::std::forward< _Arguments && >( arguments ) ... ); }
 
    // ...
};
 

C++ (Qt)
void method() &&

C++ (Qt)
void method()

C++ (Qt)
template<class T>
T Lerp( const T & a, cont T & b, double w )
{
  return a * (1.0 - w) + b * w;
}
 

C++ (Qt)
template<class T>
T Lerp( const T & a, const T & b, double w );

C++ (Qt)
#include <QPoint>
#include <QVector3D>
#include <QDebug>
 
template <typename T>
concept Arithmetic =
    requires(T a, T b)
{
    a + b;
    a - b;
};
 
Arithmetic Lerp(const Arithmetic& a, const Arithmetic& b, double w)
{ return (b - a) * w; }
 
int main()
{
    qDebug() << Lerp(0, 10, 0.3);
    qDebug() << Lerp(QPoint{0, 0}, QPoint{10, 10}, 0.5);
    qDebug() << Lerp(QVector3D{0, 0, 0}, QVector3D{10, 10, 10}, 0.7);
 
    return 0;
}

template<Arithmetic T>
T Lerp(const T& a, const T& b, double w)

auto Arithmetic Lerp(const auto Arithmetic& a, const auto Arithmetic& b, double w)

C++ (Qt)
Arithmetic Lerp(const Arithmetic& a, const Arithmetic& b, double w);
 
template <Arithmetic T> T LerpT(const T& a, const T& b, double w);

C++ (Qt)
Arithmetic Lerp(const Arithmetic& a, const Arithmetic& b, double w)
{ return a + (b - a) * w; }
}

C++ (Qt)
#include <iostream>
 
struct S
{
    void f()& { std::cout << "lvalue\n"; }
};
 
int main()
{
    S s;
    s.f();            // prints "lvalue"
    std::move(s).f(); // error
    S().f();          // error
}

C++ (Qt)
struct Calculator
{
    using Values = ::std::vector< double >;
 
    Calculator ( Values values )
    {
        m_squared.reserve( values.size() );
        for ( const auto & value, values )
        {
                m_squared.push_back( value * value );
        }
    }
 
    Values squared () & { return m_squared; }; // get squared by coping
    Values squared () && { return ::std::move( m_squared ); }; // get squared by moving
 
private:
    Values m_squared;
};
 
void foo ()
{
    Calculator::Values v = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    Calculator calculator( v );
    auto squared_by_coping = calculator.squared(); // coping
    auto squared_by_moving = Calculator( v ).squared(); // moving
}
 

C++ (Qt)
class Logging
{
    using Pattern = ::std::string;
    using Key = ::std::string;
    using Value = ::std::string;
 
    Logging ( Pattern ) { /*формирование шаблона сообщения*/ }
    ~Logging () {} { /*вывод в файл/консоль/и т.п.*/ }
    Logging && arg ( Key key, Value value ) && { /*заполнение полей шаблона сообщения*/ };
};
 
void foo ()
{
    Logging( "Hello, ${username}!" ).arg( "username", "German" ); // так работает
 
    Logging log( "Hello, ${username}!" );
    log.arg( "username", "German" ); // а такое использование запрещено
}