You would do:

    template &lt;typename ...Params&gt;
    void f(Params&amp;&amp;... params)
    {
        y(std::forward&lt;Params&gt;(params)...);
    }

The `...` pretty much says &quot;take what&#39;s on the left, and for each template parameter, unpack it accordingly.&quot; 

Is it possible to determine if Google Chrome is in incognito mode via a script?

**Edit:** *I actually meant is it possible via user-script, but the answers assume JavaScript is running on a web page. I&#39;ve re-asked the question [here][1] in regards to user scripts.* 

  [1]: https://stackoverflow.com/questions/2916876/is-it-possible-to-determine-if-chrome-is-in-incognito-mode-via-user-script


Can you determine if Chrome is in incognito mode via a script?

I want to order a List of objects in C# by many fields, not just by one. For example, let&#39;s suppose I have a class called X with two Attributes, A and B, and I have the following objects, in that order:

object1 =&gt; A = &quot;a&quot;, B = &quot;h&quot;  
object2 =&gt; A = &quot;a&quot;, B = &quot;c&quot;  
object3 =&gt; A = &quot;b&quot;, B = &quot;x&quot;  
object4 =&gt; A = &quot;b&quot;, B = &quot;b&quot;  

and I want to order the list by A attribute first, and when they are equals, by B element, so the order would be:

&quot;a&quot; &quot;c&quot;  
&quot;a&quot; &quot;h&quot;  
&quot;b&quot; &quot;b&quot;  
&quot;b&quot; &quot;x&quot;  

As far as I know, the OrderBy method order by one parameter.

**Question**: How can I order a C# List by more than one field?

Order a List (C#) by many fields?

I was just writing a generic object factory and using the boost preprocessor meta-library to make a variadic template (using 2010 and it doesn&#39;t support them). My function uses rval references and `std::forward` to do perfect forwarding and it got me thinking...when C++0X comes out and I had a standard compiler I would do this with real variadic templates.  How though, would I call `std::forward` on the arguments?

    template &lt;typename ...Params&gt;
    void f(Params... params) // how do I say these are rvalue reference?
    {
        y(std::forward(...params)); //? - I doubt this would work.
    }

Only way I can think of would require manual unpacking of ...params and I&#39;m not quite there yet either. Is there a quicker syntax that would work?


How would one call std::forward on all arguments in a variadic function?

I was just writing a generic object factory and using the boost preprocessor meta-library to make a variadic template (using 2010 and it doesn't support them). My function uses rval references and <code>std::forward</code> to do perfect forwarding and it got me thinking...when C++0X comes out and I had a standard compiler I would do this with real variadic templates. How though, would I call <code>std::forward</code> on the arguments?
<pre><code class="hljs language-arduino">template &#x3C;typename ...Params>
void f(Params... params) // how do I say these are rvalue reference?
{
 y(std::forward(...params)); //? - I doubt this would work.
}
</code></pre>
Only way I can think of would require manual unpacking of ...params and I'm not quite there yet either. Is there a quicker syntax that would work?

I am pioneering unit testing efforts at my company, and need need to choose a mocking framework to use. I have never used a mocking framework before. We have already chosen Google Test, so using Google Mock would be nice. However, my initial impressions after looking at &lt;a href=&quot;http://code.google.com/p/googlemock/wiki/ForDummies&quot;&gt;Google Mock&#39;s tutorial&lt;/a&gt; are:

 - The need for re-declaring each method in the mocking class with a MOCK_METHODn macro seems unnecessary and seems to go against the DRY principle.
 - Their matchers (eg, the &#39;_&#39; in EXPECT_CALL(turtle, Forward(_));) and the order of matching seem almost too powerful. Like, it would be easy to say something you don&#39;t mean, and miss bugs that way.

I have high confidence in google&#39;s developers, and low confidence in my own ability to judge mocking frameworks, never having used them before. So my question is: **Are these valid concerns?** 

Or is there no better way to define a mock object, and are the matchers intuitive to use in practice? I would appreciate answers from anyone who has used Google Mock before, and comparisons to other C++ frameworks would be helpful.

Is Google Mock a good mocking framework?

Is there any way to capture by value, and make the captured value non-const?  I have a library functor that I would like to capture &amp; call a method that is non-const but should be.

The following doesn&#39;t compile but making foo::operator() const fixes it.

    struct foo
    {
      bool operator () ( const bool &amp; a )
      {
        return a;
      }
    };


    int _tmain(int argc, _TCHAR* argv[])
    {
      foo afoo;

      auto bar = [=] () -&gt; bool
        {
          afoo(true);
        };

      return 0;
    }

C++0x lambda capture by value always const?

I have a fairly good understanding of the dereferencing operator, the address of operator, and pointers in general.

I however get confused when I see stuff such as this:

    int* returnA() {
        int *j = &amp;a;
        return j;
    }

    int* returnB() {
        return &amp;b;
    }

    int&amp; returnC() {
        return c;
    }

    int&amp; returnC2() {
        int *d = &amp;c;
        return *d;
    }

 1. In `returnA()` I&#39;m asking to return a pointer; just to clarify this works because `j` is a pointer?
 2. In `returnB()` I&#39;m asking to return a pointer; since a pointer points to an address, the reason why `returnB()` works is because I&#39;m returning `&amp;b`? 
 3. In `returnC()` I&#39;m asking for an address of `int` to be returned. When I return `c` is the `&amp;` operator automatically &quot;appended&quot; `c`?
 4. In `returnC2()` I&#39;m asking again for an address of `int` to be returned. Does `*d` work because pointers point to an address?

Assume a, b, c are initialized as integers as Global.

Can someone validate if I am correct with all four of my questions?


C++ Returning Pointers/References

It seems the main advice concerning C++0x&#39;s rvalues is to add move constructors and move operators to your classes, until compilers default-implement them.

But waiting is a losing strategy if you use VC10, because automatic generation probably won&#39;t be here until VC10 SP1, or in worst case, VC11. Likely, the wait for this will be measured in years.

Here lies my problem. Writing all this duplicate code is not fun. And it&#39;s unpleasant to look at. But this is a burden well received, for those classes deemed slow. Not so for the hundreds, if not thousands, of smaller classes.

::sighs:: C++0x was supposed to let me write *less* code, not more!

And then I had a thought. Shared by many, I would guess.

Why not just pass everything by value? Won&#39;t std::move + copy elision make this nearly optimal?

## Example 1 - Typical Pre-0x constructor ##

    OurClass::OurClass(const SomeClass&amp; obj) : obj(obj) {}
 
    SomeClass o;
    OurClass(o);            // single copy
    OurClass(std::move(o)); // single copy
    OurClass(SomeClass());  // single copy

***Cons:*** A wasted copy for rvalues.


## Example 2 - Recommended C++0x? ##
 
    OurClass::OurClass(const SomeClass&amp; obj) : obj(obj) {}
    OurClass::OurClass(SomeClass&amp;&amp; obj) : obj(std::move(obj)) {}

    SomeClass o;
    OurClass(o);            // single copy
    OurClass(std::move(o)); // zero copies, one move
    OurClass(SomeClass());  // zero copies, one move

***Pros:*** Presumably the fastest.   
***Cons:*** Lots of code!


## Example 3 - Pass-by-value + std::move ##

    OurClass::OurClass(SomeClass obj) : obj(std::move(obj)) {}
 
    SomeClass o;
    OurClass(o);            // single copy, one move
    OurClass(std::move(o)); // zero copies, two moves
    OurClass(SomeClass());  // zero copies, one move

***Pros:*** No additional code.   
***Cons:*** A wasted move in cases 1 &amp; 2. Performance will suffer greatly if `SomeClass` has no move constructor.
***

What do you think? Is this correct? Is the incurred move a generally acceptable loss when compared to the benefit of code reduction?

Overload on reference, versus sole pass-by-value + std::move?

I want to output an integer to a `std::stringstream` with the equivalent format of `printf`&#39;s `%02d`. Is there an easier way to achieve this than:

    std::stringstream stream;
    stream.setfill(&#39;0&#39;);
    stream.setw(2);
    stream &lt;&lt; value;

Is it possible to stream some sort of format flags to the `stringstream`, something like (pseudocode):

    stream &lt;&lt; flags(&quot;%02d&quot;) &lt;&lt; value;

Equivalent of %02d with std::stringstream?

I am so frustrated right now after several hours trying to find where shared_ptr is located. None of the examples I see show complete code to include the headers for `shared_ptr` (and working). Simply stating `std`, `tr1` and `&lt;memory&gt;` is not helping at all! I have downloaded boosts and all but still it doesn&#39;t show up!  Can someone help me by telling exactly where to find it?

Thanks for letting me vent my frustrations!

EDIT:
I see my title has been changed. Sorry about that.
So... it was also because it was not clear to me that shared_ptr is &quot;C++ version dependant&quot; --&gt; that&#39;s why I did not state my environment --&gt; therefore probably why it was so difficult for me to find it.

I am working on MSVS2008.

EDIT 2:
I don&#39;t know why,  but I was including [memory] and [boost/tr1/memory.hpp] and [boost/tr1/tr1/memory] while looking everywhere for the shared_ptr.. of course, i couldn&#39;t.

Thanks for all the responses.

Where is shared_ptr?

There is [a list][1] for GCC; is there a similar list for Visual Studio 2010?


  [1]: http://gcc.gnu.org/projects/cxx0x.html

What C++11 features does Visual Studio 2010 support?

I read on the internet many tutorials that explained how to use lambdas with the standard library (such as `std::find`), and they all were very interesting, but I couldn&#39;t find any that explained how I can use a lambda for my own functions.

For example:

    int main()
    {
    	int test = 5;
    	LambdaTest([&amp;](int a) { test += a; });
    
    	return EXIT_SUCCESS;
    }

How should I declare `LambdaTest`? What&#39;s the type of its first argument? And then, how can I call the anonymous function passing to it - for example - &quot;10&quot; as its argument?

How to declare a function that accepts a lambda?

I was experimenting with C++0x variadic templates when I stumbled upon this issue:

    template &lt; typename ...Args &gt;
    struct identities
    {
        typedef Args type; //compile error: &quot;parameter packs not expanded with &#39;...&#39;
    };

    //The following code just shows an example of potential use, but has no relation
    //with what I am actually trying to achieve.
    template &lt; typename T &gt;
    struct convert_in_tuple
    {
        typedef std::tuple&lt; typename T::type... &gt; type;
    };

    typedef convert_in_tuple&lt; identities&lt; int, float &gt; &gt;::type int_float_tuple;

GCC 4.5.0 gives me an error when I try to typedef the template parameters pack.

Basically, I would like to &quot;store&quot; the parameters pack in a typedef, without unpacking it. Is it possible? If not, is there some reason why this is not allowed?

Is it possible to &quot;store&quot; a template parameter pack without expanding it?

While browsing through gcc&#39;s current implementation of new C++11 headers, I stumbled upon &quot;......&quot; token. You can check, that the following code [compiles fine][1] [via godbolt.org].

    template &lt;typename T&gt;
    struct X
    { /* ... */ };

    template &lt;typename T, typename ... U&gt;
    struct X&lt;T(U......)&gt; // this line is the important one
    { /* ... */ };

So, what is the meaning of this token?

edit: Looks like SO trimmed &quot;......&quot; in question title to &quot;...&quot;, I did really mean &quot;......&quot; . :)

  [1]: https://godbolt.org/z/4GfbYYb75

What is the meaning of &quot;... ...&quot; token? i.e. double ellipsis operator on parameter pack

This is a follow-up to my previous question on [pretty-printing STL containers](https://stackoverflow.com/questions/4850473/pretty-print-c-stl-containers), for which we managed to develop a very elegant and fully general solution.

---

In this next step, I would like to include pretty-printing for `std::tuple&lt;Args...&gt;`, using variadic templates (so this is strictly C++11). For `std::pair&lt;S,T&gt;`, I simply say

    std::ostream &amp; operator&lt;&lt;(std::ostream &amp; o, const std::pair&lt;S,T&gt; &amp; p)
    {
      return o &lt;&lt; &quot;(&quot; &lt;&lt; p.first &lt;&lt; &quot;, &quot; &lt;&lt; p.second &lt;&lt; &quot;)&quot;;
    }

What is the analogous construction for printing a tuple?

I&#39;ve tried various bits of template argument stack unpacking, passing indices around and using SFINAE to discover when I&#39;m at the last element, but with no success. I shan&#39;t burden you with my broken code; the problem description is hopefully straight-forward enough. Essentially, I&#39;d like the following behaviour:

    auto a = std::make_tuple(5, &quot;Hello&quot;, -0.1);
    std::cout &lt;&lt; a &lt;&lt; std::endl; // prints: (5, &quot;Hello&quot;, -0.1)

Bonus points for including the same level of generality (char/wchar_t, pair delimiters) as the the previous question!

Pretty-print std::tuple

[This question][1] on the [object generator pattern][2] got me thinking about ways to automate it.

Essentially, I want to automate the creation of functions like `std::make_pair`, `std::bind1st` and `std::mem_fun` so that instead of having to write a different function for each template class type, you could write a single variadic template template function that handles all cases at once. Usage of this function would be like:

    make&lt;std::pair&gt;(1, 2);         // equivalent to std::make_pair(1, 2)
    make&lt;std::binder2nd&gt;(&amp;foo, 3); // equivalent to std::bind2nd(&amp;foo, 3);

Is it possible to write this function `make`? I have tried this, but it doesn&#39;t work in GCC 4.5 or 4.6:

    template &lt;template &lt;typename...&gt; class TemplateClass, typename... Args&gt;
    TemplateClass&lt;Args...&gt; make(Args&amp;&amp;... args)
    {
        return TemplateClass&lt;Args...&gt;(std::forward&lt;Args&gt;(args)...);
    }

If I try to call (e.g) `make&lt;std::pair&gt;(1, 2)` I just get

    error: no matching function for call to &#39;make(int, int)&#39;

Have I got the syntax wrong anywhere here?  
Or is this right and GCC is wrong?  
Or is this just fundamentally impossible in C++0x?

[edit]

Proposal [N2555][3] seems to suggest that this is allowed and [GCC claims to have implemented it in GCC4.4][4].


  [1]: https://stackoverflow.com/questions/6485791/c-instantiate-a-templated-class-according-to-an-argument/6485843#6485843
  [2]: http://en.wikibooks.org/wiki/More_C++_Idioms/Object_Generator
  [3]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf
  [4]: http://gcc.gnu.org/projects/cxx0x.html

Variadic template templates and perfect forwarding

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

In perfect forwarding, `std::forward` is used to convert the named rvalue references `t1` and `t2` to unnamed rvalue references. What is the purpose of doing that? How would that affect the called function `inner` if we leave `t1` &amp; `t2` as lvalues?
    
    template &lt;typename T1, typename T2&gt;
    void outer(T1&amp;&amp; t1, T2&amp;&amp; t2) 
    {
        inner(std::forward&lt;T1&gt;(t1), std::forward&lt;T2&gt;(t2));
    }


What are the main purposes of using std::forward and which problems it solves?

So, after watching [this wonderful lecture][1] on rvalue references, I thought that every class would benefit of such a &quot;move constructor&quot;, `template&lt;class T&gt; MyClass(T&amp;&amp; other)` ***edit*** and of course a &quot;move assignment operator&quot;, `template&lt;class T&gt; MyClass&amp; operator=(T&amp;&amp; other)` as Philipp points out in his answer, if it has dynamically allocated members, or generally stores pointers. Just like you *should* have a copy-ctor, assignment operator and destructor if the points mentioned before apply.
Thoughts?

  [1]: http://channel9.msdn.com/shows/Going+Deep/C9-Lectures-Introduction-to-STL-with-Stephan-T-Lavavej/

Rule-of-Three becomes Rule-of-Five with C++11?

I guess not, but I would like to confirm. Is there any use for `const Foo&amp;&amp;`, where `Foo` is a class type?

Do rvalue references to const have any use?

I&#39;m trying to understand rvalue references and move semantics of C++11.

What is the difference between these examples, and which of them is going to do no vector copy?

## First example ##
    std::vector&lt;int&gt; return_vector(void)
    {
        std::vector&lt;int&gt; tmp {1,2,3,4,5};
        return tmp;
    }
    
    std::vector&lt;int&gt; &amp;&amp;rval_ref = return_vector();

## Second example ##
    std::vector&lt;int&gt;&amp;&amp; return_vector(void)
    {
        std::vector&lt;int&gt; tmp {1,2,3,4,5};
        return std::move(tmp);
    }
    
    std::vector&lt;int&gt; &amp;&amp;rval_ref = return_vector();

## Third example ##
    std::vector&lt;int&gt; return_vector(void)
    {
        std::vector&lt;int&gt; tmp {1,2,3,4,5};
        return std::move(tmp);
    }
    
    std::vector&lt;int&gt; &amp;&amp;rval_ref = return_vector();


C++11 rvalues and move semantics confusion (return statement)

I&#39;ve been looking into some of the new features of C++11 and one I&#39;ve noticed is the double ampersand in declaring variables, like `T&amp;&amp; var`.

For a start, what is this beast called? I wish Google would allow us to search for punctuation like this.

What exactly does it _mean?_

At first glance, it appears to be a double reference (like the C-style double pointers `T** var`), but I&#39;m having a hard time thinking of a use case for that.


What does T&amp;&amp; (double ampersand) mean in C++11?

&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?

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

Content Type	Original Author	Original Content on Stackoverflow
Question	Edward Strange	View Question on Stackoverflow
Solution 1 - C++	GManNickG	View Answer on Stackoverflow

How would one call std::forward on all arguments in a variadic function?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Order a List (C#) by many fields?

Can you determine if Chrome is in incognito mode via a script?

Attributions