小编Bay*_*ita的帖子

让我举一个具体的例子来说明我的意思.

我有两个C++标准草案:N4296现在很老了,最近的修订版N4750.我感兴趣的是一些小节,例如[unord.hash].版本N4296需要从std::hash提供两个嵌套类型argument_type和result_type,但这一要求不再存在于N4750.

如何找到修订版本,删除此要求的动机及其动机？

我有几个关于std::assignable_from行为的问题。Cppreference建议采用以下实现方式：

template< class LHS, class RHS >
concept assignable_from =
  std::is_lvalue_reference_v<LHS> &&
  std::common_reference_with<
    const std::remove_reference_t<LHS>&,
    const std::remove_reference_t<RHS>&> &&
  requires(LHS lhs, RHS&& rhs) {
    { lhs = std::forward<RHS>(rhs) } -> std::same_as<LHS>;
  };

问题是第二个要求的目的是什么，即

std::common_reference_with<
    const std::remove_reference_t<LHS>&,
    const std::remove_reference_t<RHS>&>

谁能详细说明这个要求并提供一些例子吗？

如果上下文很重要，我会尝试从这篇文章中了解 C++20 概念。我的问题与其中的一个具体示例有关：

template <typename D, std::integral T>
requires std::assignable_from<D, T>
void assign_the_thing(D& dest, T&& x)
{
    dest = std::forward<T>(x);
}

但是，无论如何，我怀疑这是否是正确的使用方法assignable_from。

我有几个与 C++ 中的重载解析相关的问题。考虑这个例子：

extern "C" int printf (const char*, ...);                                       
                                                                                
struct X {};                                                                    
                                                                                
template <typename T>                                                           
struct A                                                                        
{                                                                               
    A() = default;                                                              
                                                                                
    template <typename U>                                                       
    A(A<U>&&)                                                                   
    {printf("%s \n", __PRETTY_FUNCTION__);}                                     
};                                                                              
                                                                                
template <typename T>                                                           
struct B : A<T>                                                                 
{                                                                               
    B() = default;                                                              
                                                                                
    template <typename U>                                                       
    operator A<U>()                                                             
    {printf("%s \n", __PRETTY_FUNCTION__); return {};}                          
};                                                                              
                                                                                
int main ()                                                                     
{                                                                               
    A<X> a1 (B<int>{});                                                         
} 

如果我用 编译它g++ -std=c++11 a.cpp，A的构造函数将被调用：

A<T>::A(A<U>&&) [with U = int; T = X] 

如果我用 编译程序g++ -std=c++17 …