http://www.justsoftwaresolutions.co.uk/cplusplus/rvalue_references_and_perfect_forwarding.html

&gt; Why is this useful? Well, it means that a function template can pass its arguments through to another function whilst retaining the lvalue/rvalue nature of the function arguments by using std::forward. This is called &quot;perfect forwarding&quot;, avoids excessive copying, and avoids the template author having to write multiple overloads for lvalue and rvalue references.



Quoting [Session Announcement: Adventures in Perfect Forwarding][1]:

&gt; Perfecting forwarding is an important C++0x technique built atop
&gt; rvalue references.  It allows move semantics to be automatically
&gt; applied, even when the source and the destination of a move are
&gt; separated by intervening function calls.  Common examples include
&gt; constructors and setter functions that forward arguments they receive
&gt; to the data members of the class they are initializing or setting, as
&gt; well as standard library functions like make_shared, which
&gt; “perfect-forwards” its arguments to the class constructor of whatever
&gt; object the to-be-created shared_ptr is to point to.


  [1]: http://cppandbeyond.com/2011/04/25/session-announcement-adventures-in-perfect-forwarding/

I am trying to understand the difference between `LEFT JOIN` and `LEFT JOIN FETCH` in Hibernate.

Can anyone explain this?

Thanks

Difference between LEFT JOIN and LEFT JOIN FETCH in Hibernate?

I&#39;m in halfway trough an html parser and found html5 defined **explicitly** the rules of thumb for parsing *ill formed html*. *(And I used to infer them from DTDs, sigh)*

I love that fact, but I know well that html5 isn&#39;t finalized yet (also I wonder if it ever will) and that it isn&#39;t developed by the W3C, but by the WHATWG.

Searching for the spec I need I&#39;m presented with:

 * 8.2 section of the **W3C** *TR*  
http://www.w3.org/TR/html5/syntax.html#parsing

or

* 11.2 section of the **WHATWG** *web-apps/current-work*  
http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html

If it wasn&#39;t for the section numbers I would induce those are simply the same. But the different numbering makes me wonder. *Which version is, supposedly, the most authoritative?*

WHATWG seems to have more sections, and to have been *added to* since W3C uploaded its candidate recommendation.

Will W3C update to the WHATWG version?  
Or will they stick to their current candidate until it gets to the official recommendation status?

**Which html5 spec are we poor devils supposed to follow, when in doubt?**

HTML5: W3C vs WHATWG. Which gives the most authoritative spec?

&gt; **Possible Duplicate:**  
&gt; [Advantages of using forward](https://stackoverflow.com/questions/3582001/advantages-of-using-forward)  

&lt;!-- End of automatically inserted text --&gt;

Could someone please explain to me what perfect forwarding is about?

Perfect forwarding - what&#39;s it all about?

> Possible Duplicate: 
> <a href="https://stackoverflow.com/questions/3582001/advantages-of-using-forward" target="_blank" rel="noopener noreferrer">Advantages of using forward</a>

Could someone please explain to me what perfect forwarding is about?

&gt; **Possible Duplicates:**  
&gt; [pimpl: shared_ptr or unique_ptr](https://stackoverflow.com/questions/5576922/pimpl-shared-ptr-or-unique-ptr)  
&gt; [smart pointers (boost) explained](https://stackoverflow.com/questions/569775/smart-pointers-boost-explained)  

&lt;!-- End of automatically inserted text --&gt;

Could someone explain differences between shared_ptr and unique_ptr?

Differences between unique_ptr and shared_ptr

&gt; **Possible Duplicate:**  
&gt; [How much is too much with C++0x auto keyword](https://stackoverflow.com/questions/6434971/how-much-is-too-much-with-c0x-auto-keyword)  

&lt;!-- End of automatically inserted text --&gt;

Have we (as a community) had enough experience to determine when and/or whether auto is being abused?

What I am really looking for is a best practices guide on

* when to use auto
* when it should be avoided

Simple rules of thumb that can quickly be followed in 80% of cases.

As a context this question is sparked by my response [here](https://codereview.stackexchange.com/questions/3770/review-my-code-to-write-bittorrent-peer-protocol-messages/3781#3781)


The new keyword &quot;auto&quot;; When should it be used to declare a variable type?

How should I `typedef` a `template class` ? Something like:

    typedef std::vector myVector;  // &lt;--- compiler error
I know of 2 ways:

    (1) #define myVector std::vector // not so good
    (2) template&lt;typename T&gt;
        struct myVector { typedef std::vector&lt;T&gt; type; }; // verbose
Do we have anything better in C++0x ?


How to typedef a template class?

When we have,

    struct E { enum E_ { HELLO }; }; // &#39;E&#39; is inheritable
then why do we need,

    enum class E { HELLO };  // &#39;E&#39; is not inheritable
IMO 2nd version doesn&#39;t offer more features than the 1st. I don&#39;t think that `enum class` is introduced just to save 2 curly braces `{};`! Am I missing any important aspect ?

As a minor question, is there any difference between `enum class` and `enum struct` other than syntax (because both have `public` access specifier) ?

Do we really need &quot;enum class&quot; in C++11?

Currently, I can only do ranged based loops with this:

    for (auto&amp; value : values)

But sometimes I need an iterator to the value, instead of a reference (For whatever reason). Is there any method without having to go through the whole vector comparing values?

Need iterator when using ranged-based for loops

The term &quot;porcelain&quot; appears occasionally in the Git documentation.  What does it mean?

What does the term &quot;porcelain&quot; mean in Git?

I see many people talking about the term SUT, but do not understand why they use that term.

SUT is what you want to test?

**Where does this term come from and what does it mean?**

For example in this test, what is my SUT?

    [TestMethod]
    public void UsersAction_should_return_IndexAction()
    {
        const long id = 1;
    
        UsersViewModel viewModel = new UsersViewModel()
        {
            SelectedUsers = new long[] { 1, 2, 3, 4 }
        };
    
        ActionResult result = _controller.Users(id, viewModel);
    
        result.AssertActionRedirect().ToAction(&quot;Index&quot;);
    }

What is SUT and where did it come from?

I&#39;ve searched for the definition of an API in a programming language and I am still finding it hard to understand.

Could anyone advice me in simple, layman&#39;s terms:

1. What is an API?
2. How is it used?
3. When and where is it used? 


What exactly is the meaning of an API?

In software engineering we create indexes all the time (e.g., in databases) but I also hear a lot of people talk about inverted indices. Is there something fundamentally different between the two? They sound like the same thing.

What&#39;s the difference between an inverted index and a plain old index?

I&#39;ve done some research.
A byte is 8 bits and a word is the smallest unit that can be addressed on memory. The exact length of a word varies. What I don&#39;t understand is what&#39;s the point of having a byte? Why not say 8 bits?

I asked a prof this question and he said most machines these days are byte-addressable, but what would that make a word?

What&#39;s the difference between a word and byte?

Why is there no `std::make_unique` function template in the standard C++11 library? I find

    std::unique_ptr&lt;SomeUserDefinedType&gt; p(new SomeUserDefinedType(1, 2, 3));

a bit verbose. Wouldn&#39;t the following be much nicer?

    auto p = std::make_unique&lt;SomeUserDefinedType&gt;(1, 2, 3);

This hides the `new` nicely and only mentions the type once.

Anyway, here is my attempt at an implementation of `make_unique`:

    template&lt;typename T, typename... Args&gt;
    std::unique_ptr&lt;T&gt; make_unique(Args&amp;&amp;... args)
    {
    	return std::unique_ptr&lt;T&gt;(new T(std::forward&lt;Args&gt;(args)...));
    }

It took me quite a while to get the `std::forward` stuff to compile, but I&#39;m not sure if it&#39;s correct. Is it? What exactly does `std::forward&lt;Args&gt;(args)...` mean? What does the compiler make of that?

make_unique and perfect forwarding

I saw this here:
https://stackoverflow.com/questions/4390888/move-constructor-calling-base-class-move-constructor

Could someone explain:

 1. the difference between [`std::move`][1] and [`std::forward`][2], preferably with some code examples?
 2. How to think about it easily, and when to use which


  [1]: http://en.cppreference.com/w/cpp/utility/move
  [2]: http://en.cppreference.com/w/cpp/utility/forward

What&#39;s the difference between std::move and std::forward

I&#39;ve been watching Scott Meyers&#39; [talk on Universal References](http://channel9.msdn.com/Shows/Going+Deep/Cpp-and-Beyond-2012-Scott-Meyers-Universal-References-in-Cpp11) from the C++ and Beyond 2012 conference, and everything makes sense so far. However, an audience member asks a question at around 50 minutes in that I was also wondering about. Meyers says that he does not care about the answer because it is non-idiomatic and would silly his mind, but I&#39;m still interested.

The code presented is as follows:

    // Typical function bodies with overloading:
    void doWork(const Widget&amp; param)   // copy
    {
      // ops and exprs using param
    }
    void doWork(Widget&amp;&amp; param)        // move
    {
      // ops and exprs using std::move(param)
    }

    // Typical function implementations with universal reference:
    template &lt;typename T&gt;
    void doWork(T&amp;&amp; param)             // forward =&gt; copy and move
    {
      // ops and exprs using std::forward&lt;T&gt;(param)
    }

The point being that when we take an rvalue reference, we know we have an rvalue, so we should `std::move` it to preserve the fact that it&#39;s an rvalue. When we take a universal reference (`T&amp;&amp;`, where `T` is a deduced type), we want `std::forward` to preserve the fact that it may have been an lvalue or an rvalue.

So the question is: since `std::forward` preserves whether the value passed into the function was either an lvalue or an rvalue, and `std::move` simply casts its argument to an rvalue, could we just use `std::forward` everywhere? Would `std::forward` behave like `std::move` in all cases where we would use `std::move`, or are there some important differences in behaviour that are missed out by Meyers&#39; generalisation?

I&#39;m not suggesting that anybody should do it because, as Meyers correctly says, it&#39;s completely non-idiomatic, but is the following also a valid use of `std::move`:

    void doWork(Widget&amp;&amp; param)         // move
    {
      // ops and exprs using std::forward&lt;Widget&gt;(param)
    }

Can I typically/always use std::forward instead of std::move?

Consider a class `X` with `N` member variables, each of some *copiable* and *movable* type, and `N` corresponding setter functions. 
In C++98, the definition of `X` would likely look something like this:

    class X
    {
    public:
        void set_a(A const&amp; a) { _a = a; }
        void set_b(B const&amp; b) { _b = b; }
        ...
    private:
        A _a;
        B _b;
        ...
    };

Setter functions of class `X` above can bind both to lvalue and to rvalue arguments. Depending on the actual argument, this *might* result in the creation of a temporary and *will* eventually result in a copy assignment; due to this, *non-copiable* types are not supported by this design.

With C++11 we have move semantics, perfect forwarding, and universal references (Scott Meyers&#39;s terminology), which allow for a more efficient and generalized use of setter functions by rewriting them this way:

    class X
    {
    public:
        template&lt;typename T&gt;
        void set_a(T&amp;&amp; a) { _a = std::forward&lt;T&gt;(a); }

        template&lt;typename T&gt;
        void set_b(T&amp;&amp; b) { _b = std::forward&lt;T&gt;(b); }
        ...
    private:
        A _a;
        B _b;
        ...
    };

Universal references can bind to `const`/non-`const`, `volatile`/non-`volatile`, and to any convertible type in general, avoiding the creation of temporaries and passing values straight to `operator =`. *Non-copiable*, *movable* types are now supported. Possibly undesired bindings can be eliminated either through `static_assert` or through `std::enable_if`.

So my question is: as a *design guideline*, should all (let&#39;s say, most) setter functions in C++11 be written as function templates accepting universal references?

Apart from the more cumbersome syntax and the impossibility of using Intellisense-like helper tools when writing code in those setter functions, are there any relevant disadvantages with the hypothetical principle &quot;*write setter functions as function templates accepting universal references whenever possible*&quot;?

Should all/most setter functions in C++11 be written as function templates accepting universal references?

    template&lt;typename T&gt; void doSomething(T&amp;&amp; mStuff)
    {
        auto lambda([&amp;mStuff]{ doStuff(std::forward&lt;T&gt;(mStuff)); });
        lambda();
    }

Is it correct to capture the perfectly-forwarded `mStuff` variable with the `&amp;mStuff` syntax? 

Or is there a specific capture syntax for perfectly-forwarded variables?

EDIT: **What if the perfectly-forwarded variable is a parameter pack?**

Content Type	Original Author	Original Content on Stackoverflow
Question	smallB	View Question on Stackoverflow
Solution 1 - C++11	J. Steen	View Answer on Stackoverflow
Solution 2 - C++11	Gregory Pakosz	View Answer on Stackoverflow

Perfect forwarding - what's it all about?

C++11 Problem Overview

C++11 Solutions

Solution 1 - C++11

Solution 2 - C++11

HTML5: W3C vs WHATWG. Which gives the most authoritative spec?

Difference between LEFT JOIN and LEFT JOIN FETCH in Hibernate?

Attributions