Quiero heredar el constructor de copia de la clase base usandousing palabra clave:

#include <iostream>

struct A
{
    A() = default;

    A(const A  &) { std::cerr << __PRETTY_FUNCTION__ << std::endl; }
    A(      A &&) { std::cerr << __PRETTY_FUNCTION__ << std::endl; }

    A& operator=(const A  &) { std::cerr << __PRETTY_FUNCTION__ << std::endl; return *this; }
    A& operator=(      A &&) { std::cerr << __PRETTY_FUNCTION__ << std::endl; return *this; }
};

struct B : A
{
    using A::A;
    using A::operator=;

    B& operator=(const B  &) { std::cerr << __PRETTY_FUNCTION__ << std::endl; return *this; }
    B& operator=(      B &&) { std::cerr << __PRETTY_FUNCTION__ << std::endl; return *this; }
};

int main()
{
    A a;
    B b;
    b = a; // OK
    B b1(          a ); // compile error
    B b2(std::move(a)); // compile error
    return 0;
}

Heredar el operador de asignación utilizandousing la palabra clave funciona bien, pero heredar los constructores de copiar y mover provoca un error de compilación:un constructor heredado no es candidato para la inicialización de una expresión del mismo tipo o derivada.

http://coliru.stacked-crooked.com/a/fe84b429c391c894:

main.cpp:16:14: note:   an inherited constructor is not a candidate for initialization from an expression of the same or derived type
main.cpp:8:5: note: candidate: A::A(A&&)
     A(      A &&) { std::cerr << __PRETTY_FUNCTION__ << std::endl; }
     ^
main.cpp:16:14: note:   inherited here
     using A::A;

¿Por qué puedo heredar el operador de asignación pero no puedo heredar el constructor de copia? Cual es la diferencia? Podría entender si no pudiera heredar los operadores de asignación también. Pero heredar operadores de asignación, por el contrario, se considera correcto. Eso es un poco extraño para mí.

La historia

Lo que quiero es similar a lo que se pide enesta pregunta: solo quiero agregar nuevos métodos a la clase existente sin modificarla (es una clase de otra biblioteca).

http://coliru.stacked-crooked.com/a/149a6194717cd465:

#include <iostream>

struct A // not my class
{
};

struct B : A
{
    using A::A;
    using A::operator=;

    void foo() { std::cerr << "fuu" << std::endl; }
};

A NotMyFunc()
{
    return {};
}

int main()
{
    B b(NotMyFunc());
    b.foo();
    return 0;
}

Pero no quiero volver a implementar copiar y mover constructores.