auto f = [](auto x){ return func(normalize(x)); };

class SomeCompilerGeneratedClassName {
public:
    template<typename T>
    auto operator()(T x) const{ return func(normalize(x)); }
    …
};

auto f = [](auto&& x){ return func(normalize(std::forward<???>(x))); };

template<typename T>
T&& forward(remove_reference_t<T>& param){
    return static_cast<T&&>(param);
}

Widget&& forward(Widget& param){
    return static_cast<Widget&&>(param);
}

Widget&& && forward(Widget& param){
    return static_cast<Widget&& &&>(param);
}

Widget&& forward(Widget& param){
    return static_cast<Widget&&>(param);
}

auto f =[](auto&& param){return func(normalize(std::forward<decltype(param)>(param)));};

auto f =[](auto&&... params){return func(normalize(std::forward<decltype(params)>(params)...));};

class Widget { // some useful type
public:
    …
    bool isValidated() const;
    bool isProcessed() const;
    bool isArchived() const;
private:
    …
};
auto pw = std::make_unique<Widget>(); // create Widget
… // configure *pw
auto func = [pw = std::move(pw)]{ return pw->isValidated()&& pw->isArchived(); };

auto func = [pw = std::make_unique<Widget>()]{ return pw->isValidated()&& pw->isArchived(); };

class IsValAndArch { 
public:
    using DataType = std::unique_ptr<Widget>;
    explicit IsValAndArch(DataType&& ptr):pw(std::move(ptr)) {}
    bool operator() const{ return pw->isValidated() && pw->isArchived(); }
private:
    DataType pw;
};
auto func = IsValAndArch(std::make_unique<Widget>());

std::vector<double> data; // object to be moved into closure
… // populate data
auto func = [data = std::move(data)]{ /* uses of data */ };// C++14 init capture

std::vector<double> data; // as above
… // as above
auto func =std::bind([](const std::vector<double>& data){ /* uses of data */ },std::move(data));

using FilterContainer = std::vector<std::function<bool(int)>>;
FilterContainer filters;

filters.emplace_back([](int value) { return value % 5 == 0; });

void addDivisorFilter(){
    auto calc1 = computeSomeValue1();
    auto calc2 = computeSomeValue2();
    auto divisor = computeDivisor(calc1, calc2);
    filters.emplace_back([&](int value) { return value % divisor == 0; }); // danger
}

filters.emplace_back([&divisor](int value){ return value % divisor == 0; });

template<typename C>
void workWithContainer(const C& container){
    auto calc1 = computeSomeValue1(); // as above
    auto calc2 = computeSomeValue2(); // as above
    auto divisor = computeDivisor(calc1, calc2);
    using ContElemT = typename C::value_type;
    using std::begin;
    using std::end;
    if (std::all_of(begin(container), end(container),
                    [&](const ContElemT& value){ return value % divisor == 0; }
                    )
    ){
        …
    } else {
        …
    }
}

if (std::all_of(begin(container), end(container),
    [&](const auto& value){ return value % divisor == 0; }))

filters.emplace_back([=](int value) { return value % divisor == 0; });

class Widget {
public:
    … // ctors, etc.
    void addFilter() const; // add an entry to filters
private:
    int divisor; // used in Widget's filter
};

void Widget::addFilter() const{
    filters.emplace_back([=](int value) { return value % divisor == 0; });
}

void Widget::addFilter() const{
    filters.emplace_back([](int value) { return value % divisor == 0; });
}

void Widget::addFilter() const{
    filters.emplace_back(
        [divisor](int value){ return value % divisor == 0; }
    );
}

void Widget::addFilter() const{
    filters.emplace_back([=](int value) { return value % divisor == 0; });
}

void Widget::addFilter() const{
    auto currentObjectPtr = this;
    filters.emplace_back(
        [currentObjectPtr](int value){ return value % currentObjectPtr->divisor == 0; }
    );
}

using FilterContainer = std::vector<std::function<bool(int)>>;
FilterContainer filters; 
void doSomeWork(){
    auto pw = std::make_unique<Widget>();
    pw->addFilter(); // add filter that uses Widget::divisor
    …
} // destroy Widget; filters now holds dangling pointer!

void Widget::addFilter() const{
    auto divisorCopy = divisor; // copy data member
    filters.emplace_back(
        [divisorCopy](int value) // capture the copy
        { return value % divisorCopy == 0; } // use the copy
    );
}

void Widget::addFilter() const{
    filters.emplace_back(
        [divisor = divisor](int value) // copy divisor to closure
        { return value % divisor == 0; } // use the copy
    );
}

void addDivisorFilter(){
    static auto calc1 = computeSomeValue1(); // now static
    static auto calc2 = computeSomeValue2(); // now static
    static auto divisor = // now static
    computeDivisor(calc1, calc2);
    filters.emplace_back(
        [=](int value) // captures nothing!
        { return value % divisor == 0; } // refers to above static
    );
    ++divisor; // modify divisor
}

{
    int x; // x is local variable
    …
    auto c1 = [x](int y) { return x * y > 55; }; // c1 is copy of the closure produced by the lambda
    auto c2 = c1; // c2 is copy of c1
    auto c3 = c2; // c3 is copy of c2
    …
}

template<typename T>
void fwd(T&& param){
    f(std::forward<T>(param)); // forward it to f
}

template<typename... Ts>
void fwd(Ts&&... params){
    f(std::forward<Ts>(params)...); // forward them to f
}

f( expression ); // if this does one thing,
fwd( expression ); // but this does something else

void f(const std::vector<int>& v);

f({ 1, 2, 3 }); // fine, "{1, 2, 3}" implicitly converted to std::vector<int>
fwd({ 1, 2, 3 }); // error! doesn't compile

auto il = { 1, 2, 3 }; // il's type deduced to be std::initializer_list<int>
fwd(il); // fine, perfect-forwards il to f

class Widget {
public:
    static const std::size_t MinVals = 28; // MinVals' declaration
    …
};
… // no def for MinVals
std::vector<int> widgetData;
widgetData.reserve(Widget::MinVals); // use of MinVals

void f(std::size_t val);

f(Widget::MinVals); // fine, treated as "f(28)"
fwd(Widget::MinVals); // error! shouldn't link

const std::size_t Widget::MinVals; // in Widget's .cpp file

void f(int (*pf)(int)); // pf = "processing function"

void f(int pf(int)); // declares same f as above

int processVal(int value);
int processVal(int value, int priority);

f(processVal); // fine

fwd(processVal); // error! which processVal?

template<typename T>
T workOnVal(T param) { … }
fwd(workOnVal); // error! which workOnVal instantiation?

using ProcessFuncType = int (*)(int);
ProcessFuncType processValPtr = processVal;
fwd(processValPtr); // fine
fwd(static_cast<ProcessFuncType>(workOnVal)); // also fine

struct IPv4Header {
    std::uint32_t version:4,IHL:4,DSCP:6,ECN:2,totalLength:16;
    …
};

void f(std::size_t sz); // function to call
IPv4Header h;
… 
f(h.totalLength); // fine

fwd(h.totalLength); // error!

// copy bitfield value; see Item 6 for info on init. form
auto length = static_cast<std::uint16_t>(h.totalLength);
fwd(length); // forward the copy

std::vector<Widget> vw1;
// put data into vw1
…
// move vw1 into vw2. Runs in constant time. Only ptrs in vw1 and vw2 are modified
auto vw2 = std::move(vw1);

std::array<Widget, 10000> aw1;
// put data into aw1
…
// move aw1 into aw2. Runs in
// linear time. All elements in
// aw1 are moved into aw2
auto aw2 = std::move(aw1);

template<typename T>
void func(T&& param);

Widget widgetFactory(); // function returning rvalue
Widget w; // a variable (an lvalue)
func(w); // call func with lvalue; T deduced to be Widget&
func(widgetFactory()); // call func with rvalue; T deduced to be Widget

int x;
…
auto& & rx = x; // error! can't declare reference to reference

template<typename T>
void func(T&& param);
func(w); // invoke func with lvalue;T deduced as Widget&

void func(Widget& && param);

void func(Widget& param);

template<typename T>
void f(T&& fParam){
    … // do some work
    someFunc(std::forward<T>(fParam)); // forward fParam to someFunc
}

template<typename T>
T&& forward(typename remove_reference<T>::type& param){
    return static_cast<T&&>(param);
}

template<typename T>
T&& forward(remove_reference_t<T>& param){
    return static_cast<T&&>(param);
}

Widget widgetFactory(); // function returning rvalue
Widget w; // a variable (an lvalue)

auto&& w1 = w;

Widget& && w1 = w;

Widget& w1 = w;

auto&& w2 = widgetFactory();

template<typename T>
class Widget {
public:
    typedef T&& RvalueRefToT;
    …
};

Widget<int&> w;

typedef int& && RvalueRefToT;

typedef int& RvalueRefToT;

class Person {
public:
    explicit Person(std::string n): name(std::move(n)) {} // Item 41 for use of std::move
    explicit Person(int idx):name(nameFromIdx(idx)){}
    …
private:
    std::string name;
};

std::multiset<std::string> names; // global data structure
template<typename T>
void logAndAdd(T&& name){
    auto now = std::chrono::system_clock::now();
    log(now, "logAndAdd");
    names.emplace(std::forward<T>(name));
}

template<typename T>
void logAndAdd(T&& name){
    logAndAddImpl(std::forward<T>(name),
    std::is_integral<T>()); // not quite correct
}

template<typename T>
void logAndAdd(T&& name){
    logAndAddImpl(
        std::forward<T>(name),
        std::is_integral<typename std::remove_reference<T>::type>()
    );
}

template<typename T>
void logAndAddImpl(T&& name, std::false_type){
    auto now = std::chrono::system_clock::now();
    log(now, "logAndAdd");
    names.emplace(std::forward<T>(name));
}

std::string nameFromIdx(int idx);
void logAndAddImpl(int idx, std::true_type){
    logAndAdd(nameFromIdx(idx));
}

class Person {
public:
    template<typename T,typename = typename std::enable_if<condition>::type>
    explicit Person(T&& n);
    …
}

!std::is_same<Person,T>::value

Person p("Nancy");
auto cloneOfP(p); // initialize from lvalue

!std::is_same<Person, typename std::decay<T>::type>::value

class Person {
public:
    template<
        typename T,
        typename = typename std::enable_if<
            !std::is_same<Person,typename std::decay<T>::type>::value
        >::type
    >
    explicit Person(T&& n);
    …
};

class SpecialPerson: public Person {
public:
    SpecialPerson(const SpecialPerson& rhs):Person(rhs){ … }
    SpecialPerson(SpecialPerson&& rhs):Person(std::move(rhs)){ … }
    …
};

class Person {
public:
    template<
        typename T,
        typename = typename std::enable_if<
            !std::is_base_of<Person,typename std::decay<T>::type>::value
        >::type
    >
    explicit Person(T&& n);
    …
};

class Person {
public:
    template<
        typename T,
        typename = std::enable_if_t<
            !std::is_base_of<Person,std::decay_t<T> >::value
        >
    >
    explicit Person(T&& n);
    …
};

class Person {
public:
    template<
        typename T,
        typename = std::enable_if_t<
            !std::is_base_of<Person, std::decay_t<T>>::value &&
            !std::is_integral<std::remove_reference_t<T>>::value
        >
    >
    explicit Person(T&& n):name(std::forward<T>(n)){ … }
    explicit Person(int idx):name(nameFromIdx(idx)){ … }
    … // copy and move ctors, etc.
private:
    std::string name;
};

Person p(u"Konrad Zuse"); // "Konrad Zuse" consists of characters of type const char16_t

class Person {
public:
    template<
        typename T,
        typename = std::enable_if_t<
            !std::is_base_of<Person, std::decay_t<T>>::value &&
            !std::is_integral<std::remove_reference_t<T>>::value
        >
    >
    explicit Person(T&& n):name(std::forward<T>(n)){
        static_assert(
            std::is_constructible<std::string, T>::value,
            "Parameter n can't be used to construct a std::string"
        );
        … // the usual ctor work goes here
    }
    … // remainder of Person class (as before)
};

std::multiset<std::string> names; // global data structure
void logAndAdd(const std::string& name){
    auto now = std::chrono::system_clock::now();
    log(now, "logAndAdd"); // make log entry
    names.emplace(name);
}

std::string petName("Darla");
logAndAdd(petName); // pass lvalue std::string
logAndAdd(std::string("Persephone")); // pass rvalue std::string
logAndAdd("Patty Dog"); // pass string literal

template<typename T>
void logAndAdd(T&& name){
    auto now = std::chrono::system_clock::now();
    log(now, "logAndAdd");
    names.emplace(std::forward<T>(name));
}
std::string petName("Darla"); // as before
logAndAdd(petName); // as before, copy lvalue into multiset
logAndAdd(std::string("Persephone")); // move rvalue instead of copying it
logAndAdd("Patty Dog"); // create std::string in multiset instead

std::string nameFromIdx(int idx); // return name corresponding to idx
void logAndAdd(int idx){
    auto now = std::chrono::system_clock::now();
    log(now, "logAndAdd");
    names.emplace(nameFromIdx(idx));
}

short nameIdx;
… // give nameIdx a value
logAndAdd(nameIdx); // error!

class Person {
public:
    template<typename T>
    explicit Person(T&& n):name(std::forward<T>(n)) {}
    explicit Person(int idx):name(nameFromIdx(idx)) {}
    …
private:
    std::string name;
};

class Person {
public:
    template<typename T> 
    explicit Person(T&& n):name(std::forward<T>(n)) {}
    explicit Person(int idx); // int ctor
    Person(const Person& rhs); // copy ctor(compiler-generated)
    Person(Person&& rhs); // move ctor(compiler-generated)
};

Person p("Nancy");
auto cloneOfP(p); // create new Person from p;this won't compile!

class Person {
public:
    explicit Person(Person& n):name(std::forward<Person&>(n)) {}
    explicit Person(int idx);
}

auto cloneOfP(p);

const Person cp("Nancy"); // object is now const
auto cloneOfP(cp); // calls copy constructor!

class SpecialPerson: public Person {
public:
    SpecialPerson(const SpecialPerson& rhs):Person(rhs){ … }
    SpecialPerson(SpecialPerson&& rhs):Person(std::move(rhs)){ … }
};

class Widget {
    Widget(Widget&& rhs); // rhs definitely refers to an object eligible for moving
    ...
}

class Widget {
public:
    Widget(Widget&& rhs):name(std::move(rhs.name)),p(std::move(rhs.p)){ … }
    …
private:
    std::string name;
    std::shared_ptr<SomeDataStructure> p;
};

class Widget {
public:
    template<typename T>
    void setName(T&& newName){ // name is a universal reference
        name = std::forward<T>(newName); 
    }
…
};

class Widget {
public:
    template<typename T>
    void setName(T&& newName) // universal reference
    { name = std::move(newName); } // compiles, but is bad, bad, bad!
    … 
private:
    std::string name;
    std::shared_ptr<SomeDataStructure> p;
};
std::string getWidgetName(); // factory function
Widget w;
auto n = getWidgetName(); // n is local variable
w.setName(n); // moves n into w!
… // n's value now unknown

class Widget {
public:
    void setName(const std::string& newName){ 
        name = newName;
    }
void setName(std::string&& newName){ 
    name = std::move(newName); 
    }
    …
};

w.setName("Adela Novak");

template<class T, class... Args>
shared_ptr<T> make_shared(Args&&... args);
template<class T, class... Args>
unique_ptr<T> make_unique(Args&&... args);

template<typename T>
void setSignText(T&& text){ // univ reference
    sign.setText(text); // use text, but don't modify it
    auto now = std::chrono::system_clock::now();// get current time
    signHistory.add(now,std::forward<T>(text)); // conditionally cast text to rvalue
}

Matrix operator+(Matrix&& lhs, const Matrix& rhs){
    lhs += rhs;
    return std::move(lhs); // move lhs into return value
}

Matrix operator+(Matrix&& lhs, const Matrix& rhs){
    lhs += rhs;
    return lhs; // copy lhs into return value
}

template<typename T>
Fraction reduceAndCopy(T&& frac){
    frac.reduce();
    return std::forward<T>(frac); // move rvalue into return value, copy lvalue
}

Widget makeWidget(){
    Widget w; // local variable
    … // configure w
    return std::move(w); // move w into return value
}