template<class TData, class... Args>
    Derived(TData&& rrDerivedData, Args&&... args)
      : Base     (std::forward<Args >(args)...),
        m_strData(std::forward<TData>(rrDerivedData))
    {
    }

    template<class... Args>
    Data(std::string&& rrData, Args&&... args)
      : Base     (std::forward<Args >(args  )...),
        m_strData(std::move          (rrData)   )
    {
    }

#include <iostream>
#include <stdlib.h> 
#include <string>


class Base
{
  public:
    Base()
      : m_n(0)
    {
    }

    Base(int n, const std::string& strName, const std::string& strId)
      : m_n      (n      ),
        m_strName(strName),
        m_strId  (strId  )
    {
    }
    
    Base(const std::string& strName, const std::string& strId)
      : m_n      (0      ),
        m_strName(strName),
        m_strId  (strId  )
    {
    }

  public:
    int         m_n;
    std::string m_strName;
    std::string m_strId;
};


class Data : public Base
{
  public:
    Data()
    {
    }


    template<class TData, class... Args>
    Data(TData&& rrData, Args&&... args)
      : Base     (std::forward<Args >(args  )...),
        m_strData(std::forward<TData>(rrData)   )
    {
    }

  public:
    std::string m_strData; // before constructor
  public:
    template<class... Args>
    Data(decltype(m_strData)&& rrData, Args&&... args)
      : Base     (std::forward<Args >(args  )...),
        m_strData(std::move          (rrData)   )
    {
    }
    
};
     


int main(int argc, char* argv[])
{
    Data d1("data");
    Data d2("data", 1, "name", "id");
    Data d3("data", "name", "id");

    Base b;
    Data d4("data", b);

    Base b2(2, "b2", "test");
    Data d5("data", b2);

    Base b3(2, "b2", "test");
    Data d6("data", std::move(b3));
    std::cout << "b3.m_strName = " << b3.m_strName << std::endl;

    Data d7("data", d6);
    Data d8(d7);

    std::cout << "\n                            the end" << std::endl;
    return 0;
}

A reference type that is declared using & is called an lvalue reference, and a reference type that is declared using && is called an rvalue reference or a forwarding reference.
Lvalue references and rvalue references and forwarding references are distinct types. Except where explicitly noted, they are semantically equivalent and commonly referred to as references.

template<class Y>
void bar( Y&& y );

bar takes an lvalue or rvalue reference to everything: const, volatile, both, and neither.*
bar accepts all Y objects.
bar’s parameter is for forwarding its argument onward.

a reference that can be used everywhere; or
a reference that can be used for everything; or
something similar

BFE>И там же приводятся решения проблемы.

struct B1 {
    B1(int){};
};
struct D1 : B1 {
    using B1::B1;
};
 


int main()
{
  D1 X(1);
}

BFE>Вообще-то универсальная ссылка это ни один из перечисленных типов, но то, что их все объединяет в единой сущности.

This statement about && is either untrue or misleading, at least insofar as the feature is used; for example, this states normatively that bar’s parameter is an rvalue reference. We think this illustrates the confusion surrounding the && punning.

BFE>Ну и? Ссылка ссылается на любые типы, используется для любых объектов и форвардит аргументы (куда) подальше. Разумеется это универсальная ссылка. Другое дело, что не всякий тип с двумя арсенидами является универсальной ссылкой и это надо понимать. Понимает ли это Sutter — я . Вполне допускаю, что это я чего-то не понимаю, но его аргументация выглядит подозрительно.

In the body of bar, the parameter y is sometimes const, and sometimes volatile, and sometimes both, and sometimes nei-ther. If bar were actually going to directly use its parameter, this would be madness—it would care whether its parameter, which to the function is a local variable, was const or not, volatile or not, and so on. But it doesn’t care, because its purpose is not to use the parameter directly, but to be “neutral passthrough” code that is agnostic to what it’s being given and faithfully pass it along to other code that will use the parameter and may care about the argument’s const-ness, volatile-less, and rvalue-ness.

So the rub is that it is a name that just rolls off the tongue and is misleading because “universal references” aren’t universal in the sense of how pervasively they should be used. Furthermore, they aren’t even really references per se, but rather a set of rules for using references in a particular way in a particular context with some language support for that use, and that use is forwarding.

BFE>>И там же приводятся решения проблемы.

class B : public A
{
  public:
    template<class... Args>
    B(int nN, Args&&... args)
      : A   (std::forward<Args >(args  )...),
        m_nN(nN                            )
    {
    }
  private:
    int m_nN;
};

  B b(1,2,"asdf",4);

class B : public A
{
  public:
    template<class... Args>
    B(int nN, int nM, Args&&... args)
      : A   (std::forward<Args >(args  )...),
        m_nN(nN                            ),
        m_nM(nM                            )
    {
    }
  private:
    int m_nN;
    int m_nM;
};

  B b(1,2,"asdf",4);

struct Base {
  Base(Foo);
  Base(Xyz);
  Base(const Base&); // cctor - пользовательский или определённый компилятором
};

struct Derived : Base {
  template<class T> Derived(const T& arg) : Base(arg) { ... }
};

Foo f;
Xyz x;

Base b;
Derived d1(f), d2(x),
        d3(b); // ой! получили срезку

struct foo {};
struct xyz {};

struct base {
    base(foo) { cout << "base(foo)\n"; }
    base(xyz) { cout << "base(xyz)\n"; }
    base(const base&) { cout << "base(base) - cctor\n"; }
};

struct derived : base {
    // (1)
    template<class... Args>
    derived(Args&&... args) : base(forward<Args>(args)...) {
        cout << __PRETTY_FUNCTION__ << endl;
    }

    // (2)
    template<class Arg>
    derived(Arg&& arg) : base(arg) {
        cout << __PRETTY_FUNCTION__ << endl;
    }

    // (3)
    template<class Arg>
    derived(const Arg& arg) : base(arg) {
        cout << __PRETTY_FUNCTION__ << endl;
    }

    derived(const derived& d) : base(d) { cout << "derived cctor\n"; }

    derived(derived&& d) : base(d) { cout << "derived mctor\n"; }
    
    derived(xyz x) : base(x) { cout << "derived(xyz)\n"; }
};

int main() {
    derived d1((foo())); // шаблонный
    cout << "-----" << endl;
    derived d2((xyz())); // конкретный
    cout << "-----" << endl;
    derived d3(d1);      // возможны варианты!!!
    cout << "-----" << endl;
    return 0;
}

К>struct foo {};
К>struct xyz {};

К>struct base {
К>    base(foo) { cout << "base(foo)\n"; }
К>    base(xyz) { cout << "base(xyz)\n"; }
К>    base(const base&) { cout << "base(base) - cctor\n"; }
К>};

К>struct derived : base {
К>    // (1)
К>    template<class... Args>
К>    derived(Args&&... args) : base(forward<Args>(args)...) {
К>        cout << __PRETTY_FUNCTION__ << endl;
К>    }

К>    // (2)
К>    template<class Arg>
К>    derived(Arg&& arg) : base(arg) {
К>        cout << __PRETTY_FUNCTION__ << endl;
К>    }

К>    // (3)
К>    template<class Arg>
К>    derived(const Arg& arg) : base(arg) {
К>        cout << __PRETTY_FUNCTION__ << endl;
К>    }

К>    derived(const derived& d) : base(d) { cout << "derived cctor\n"; }

К>    derived(derived&& d) : base(d) { cout << "derived mctor\n"; }
    
К>    derived(xyz x) : base(x) { cout << "derived(xyz)\n"; }
К>};

К>int main() {
К>    derived d1((foo())); // шаблонный
К>    cout << "-----" << endl;
К>    derived d2((xyz())); // конкретный
К>    cout << "-----" << endl;
К>    derived d3(d1);      // возможны варианты!!!
К>    cout << "-----" << endl;
К>    return 0;
К>}
К>

derived(derived& arg)
derived(const derived& d)
derived(derived&& arg)

BFE>>>И там же приводятся решения проблемы.

Scott’s advice is to instead write one function, the one taking the universal reference, and internally dispatch to one of two helpers. One sensible way to dispatch might be to use the std::is_lvalue_reference trait, like so:

template<typename T>
void foo_impl( T && t, std::true_type )
  {/* LVALUES HERE */}

template<typename T>
void foo_impl( T && t, std::false_type )
  {/* RVALUES HERE */}

template<typename T>
void foo( T && t )
{
    foo_impl( std::forward<T>(t),
              std::is_lvalue_reference<T>() );
}