Each variable expressly named in the capture list is captured.  The default capture will only capture variables that are both (a) not expressly named in the capture list and (b) _used_ in the body of the lambda expression.  If a variable is not expressly named and you don&#39;t use the variable in the lambda expression, then the variable is not captured.  In your example, `my_huge_vector` is not captured.

Per C++11 &#167;5.1.2[expr.prim.lambda]/11:

&gt; If a _lambda-expression_ has an associated _capture-default_ and its _compound-statement_  _odr-uses_ `this` or a variable with automatic storage duration and the _odr-used_ entity is not explicitly captured, then the _odr-used_ entity is said to be implicitly captured.

Your lambda expression has an associated capture default:  by default, you capture variables by value using the `[=]`.  

If and only if a variable is used (in the One Definition Rule sense of the term &quot;used&quot;) is a variable implicitly captured.  Since you don&#39;t use `my_huge_vector` at all in the body (the &quot;compound statement&quot;) of the lambda expression, it is not implicitly captured.

To continue with &#167;5.1.2/14

&gt; An entity is captured by copy if 
&gt;
&gt; * it is implicitly captured and the _capture-default_ is `=` or if 
&gt; * it is explicitly captured with a capture that does not include an `&amp;`. 

Since your `my_huge_vector` is not implicitly captured and it is not explicitly captured, it is not captured at all, by copy or by reference.

No, `my_huge_vector` will not be captured. `[=]` means all **used** variables are captured in the lambda.

I am quite new to xcode and objective-c. I want to ask a very basic question.

I saw that when &quot;linking binary to libraries&quot; in project settings, there are differences about framework and libraries, imported from other projects in workspace.

First question, why is there a framework? And why is there a library? Cannot my library be a framework?

And then, from a *.h* file, how can I call classes from my imported static library?

I suppose there must be a prefix, but I couldn&#39;t find it.
Neither &lt;ProjName/Myclass.h&gt; nor &quot;ProjName/Myclass.h&quot; are working.

Please, be as specific as you can.

Thanks

Difference between framework and static library in xcode4, and how to call them

I have the following problem:  
We have an application that loads modules (add ons). These modules might need entries in the app.config (e.g. WCF configuration). Because the modules are loaded dynamically, I don&#39;t want to have these entries in the app.config file of my application.  
What I would like to do is the following:

- Create a new app.config in memory that incorporates the config sections from the modules
- Tell my application to use that new app.config

Note: I do not want to overwrite the default app.config!

It should work transparently, so that for example `ConfigurationManager.AppSettings` uses that new file.

During my evaluation of this problem, I came up with the same solution as is provided here: https://stackoverflow.com/questions/949696/reload-app-config-with-nunit.  
Unfortunately, it doesn&#39;t seem to do anything, because I still get the data from the normal app.config.

I used this code to test it:

    Console.WriteLine(ConfigurationManager.AppSettings[&quot;SettingA&quot;]);
    Console.WriteLine(Settings.Default.Setting);

    var combinedConfig = string.Format(CONFIG2, CONFIG);
    var tempFileName = Path.GetTempFileName();
    using (var writer = new StreamWriter(tempFileName))
    {
        writer.Write(combinedConfig);
    }

    using(AppConfig.Change(tempFileName))
    {
        Console.WriteLine(ConfigurationManager.AppSettings[&quot;SettingA&quot;]);
        Console.WriteLine(Settings.Default.Setting);
    }

It prints the same values twices, although `combinedConfig` contains other values than the normal app.config.



Change default app.config at runtime

When I use `[=]` to indicate that I would like all local variables to be captured by value in a lambda, will that result in *all* local variables in the function being copied, or just all local variables *that are used by the lambda*?

So, for example, if i I have:

    vector&lt;int&gt; my_huge_vector(100000);
    int my_measly_int;
    some_function([=](int i){ return my_measly_int + i; });

Will my_huge_vector be copied, even though I don&#39;t use it in the lambda?

Do c++11 lambdas capture variables they don&#39;t use?

When I use <code>[=]</code> to indicate that I would like all local variables to be captured by value in a lambda, will that result in all local variables in the function being copied, or just all local variables that are used by the lambda?
So, for example, if i I have:
<pre><code class="hljs language-arduino">vector&#x3C;int> my_huge_vector(100000);
int my_measly_int;
some_function([=](int i){ return my_measly_int + i; });
</code></pre>
Will my_huge_vector be copied, even though I don't use it in the lambda?

I&#39;m trying to find a convenient way to initialise &#39;pod&#39; C++ structs. Now, consider the following struct:

    struct FooBar {
      int foo;
      float bar;
    };
    // just to make all examples work in C and C++:
    typedef struct FooBar FooBar;

If I want to conveniently initialise this in C (!), I could simply write:

    /* A */ FooBar fb = { .foo = 12, .bar = 3.4 }; // illegal C++, legal C

Note that I want to explicitly avoid the following notation, because it strikes me as being made to break my neck if I change *anything* in the struct in the future:

    /* B */ FooBar fb = { 12, 3.4 }; // legal C++, legal C, bad style?

To achieve the same (or at least similar) in C++ as in the `/* A */` example, I would have to implement an annoying constructor:

    FooBar::FooBar(int foo, float bar) : foo(foo), bar(bar) {}
    // -&gt;
    /* C */ FooBar fb(12, 3.4);

Which feels redundant and unnecessary. Also, it is pretty much as bad as the `/* B */` example, as it does not explicitly state which value goes to which member.


So, my question is basically how I can achieve something similar to `/* A */` or better in C++?
Alternatively, I would be okay with an explanation why I should not want to do this (i.e. why my mental paradigm is bad).

**EDIT**

By *convenient*, I mean also *maintainable* and *non-redundant*.

Convenient C++ struct initialisation

I figured out that it&#39;s possible to initialize the member variables with a constructor argument of the same name as show in the example below.

    #include &lt;cstdio&gt;
    #include &lt;vector&gt;
    
    class Blah {
    	std::vector&lt;int&gt; vec;
    	
    public:
    	Blah(std::vector&lt;int&gt; vec): vec(vec)
    	{}
    	
    	void printVec() {
    		
    		for(unsigned int i=0; i&lt;vec.size(); i++)
    			printf(&quot;%i &quot;, vec.at(i));
    		
    		printf(&quot;\n&quot;);
    	}
    };
    
    int main() {
    	
    	std::vector&lt;int&gt; myVector(3);
    	
    	myVector.at(0) = 1;
    	myVector.at(1) = 2;
    	myVector.at(2) = 3;
    	
    	Blah blah(myVector);
    	
    	blah.printVec();
    	
    	return 0;
    }

g++ 4.4 with the arguments `-Wall -Wextra -pedantic` gives no warning and works correctly. It also works with clang++. I wonder what the C++ standard says about it? Is it legal and guaranteed to always work?

Initializing member variables using the same name for constructor arguments as for the member variables allowed by the C++ standard?

I&#39;m having trouble with this piece of code , after i took this class from the main.cpp file and splitted it in to .h and .cpp the compiler started complaining about the default parameters i was using in a void.

&lt;!-- language: cpp --&gt;

    /* PBASE.H */
        class pBase : public sf::Thread {
    private:
    	bool Running;
    
    public:
    	sf::Mutex Mutex;
    	WORD OriginalColor;
    	pBase(){
    		Launch();
    		Running = true;
    		OriginalColor = 0x7;
    	}
    	void progressBar(int , int);
    	bool key_pressed();
    	void setColor( int );
    	void setTitle( LPCWSTR );
    	bool test_connection(){
    		if(Running == false){
    			return 0;
    		}
    		else{
    			return 1;
    		}
    	return 0;
    	}
    	void Stop(){
    		Running = false;
    		if(Running == false) Wait();
    	}
    };

---

&lt;!-- language: cpp --&gt;

        /* PBASE.CPP */
        
        // ... other stuff above
        
        void pBase::setColor( int _color = -1){
        	if(_color == -1){
        		 SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ),FOREGROUND_INTENSITY | OriginalColor);
        		 return;
        	}
        	SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ),FOREGROUND_INTENSITY | _color);
    
    }


And the error , taken from VC2010


&gt; Error	4	error C2572: &#39;pBase::setColor&#39; : redefinition of default parameter : parameter 1


The compiler is complaining about my default parameters?

A fairly simple question... Compilers these days tend to do a significant amount of optimizations. Do they also remove unused functions from the final output? 

Do unused functions get optimized out?

&lt;sup&gt;(Note: `tuple` and `tie` can be taken from Boost or C++11.)&lt;/sup&gt;  
When writing small structs with only two elements, I sometimes tend to choose a `std::pair`, as all important stuff is already done for that datatype, like `operator&lt;` for strict-weak-ordering.  
The downsides though are the pretty much useless variable names. Even if I myself created that `typedef`, I won&#39;t remember 2 days later what `first` and what `second` exactly was, especially if they are both of the same type. This gets even worse for more than two members, as nesting `pair`s pretty much sucks.  
The other option for that is a `tuple`, either from Boost or C++11, but that doesn&#39;t really look any nicer and clearer. So I go back to writing the structs myself, including any needed comparision operators.  
Since especially the `operator&lt;` can be quite cumbersome, I thought of circumventing this whole mess by just relying on the operations defined for `tuple`:

Example of `operator&lt;`, e.g. for strict-weak-ordering:

    bool operator&lt;(MyStruct const&amp; lhs, MyStruct const&amp; rhs){
      return std::tie(lhs.one_member, lhs.another, lhs.yet_more) &lt;
             std::tie(rhs.one_member, rhs.another, rhs.yet_more);
    }
(`tie` makes a `tuple` of `T&amp;` references from the passed arguments.)  
***
**Edit**: The suggestion from @DeadMG to privately inherit from `tuple` isn&#39;t a bad one, but it got quite some drawbacks:

* If the operators are free-standing (possibly friends), I need to inherit publicly
* With casting, my functions / operators (`operator=` specifically) can be easily bypassed
* With the `tie` solution, I can leave out certain members if they don&#39;t matter for the ordering

Are there any drawbacks in this implementation that I need to consider?


Implementing comparison operators via &#39;tuple&#39; and &#39;tie&#39;, a good idea?

&lt;!--

This code may be run with:

class Object(object):
    def __init__(self, **kwargs):
        for name, value in kwargs.items():
            setattr(self, name, value)

    def __repr__(self):
        return &#39;Object(%s)&#39; % (&#39;, &#39;.join(
            &#39;%s=%r&#39; % kv for kv in self.__dict__.items()),)

--&gt;

I have a list of objects and I want to remove all objects that are empty except for one, using `filter` and a `lambda` expression.

For example if the input is:

&lt;!-- language: lang-python--&gt;

    [Object(name=&quot;&quot;), Object(name=&quot;fake_name&quot;), Object(name=&quot;&quot;)]

...then the output should be:

&lt;!-- language: lang-python--&gt;

    [Object(name=&quot;&quot;), Object(name=&quot;fake_name&quot;)]

Is there a way to add an assignment to a `lambda` expression? For example:

&lt;!-- language: lang-python--&gt;

    flag = True 
    input = [Object(name=&quot;&quot;), Object(name=&quot;fake_name&quot;), Object(name=&quot;&quot;)] 
    output = filter(
        (lambda o: [flag or bool(o.name), flag = flag and bool(o.name)][0]),
        input
    )


Assignment inside lambda expression in Python

    struct Test
    {
      static const int value = []() -&gt; int { return 0; } ();
    };
With gcc-4.6 I get something like, `error: function needs to be constexpr`. I have tried multiple combinations of putting `constexpr` at various places, but no luck.

Is `constexpr` supported for lambda functions as well (irrespective of `return` type specified or not) ? What is the correct syntax ?

Any work around possible ?

Is constexpr supported with lambda functions / expressions?

What is the right way to define a function that receives a `int-&gt;int` lambda parameter by reference?

    void f(std::function&lt; int(int) &gt;&amp; lambda);

or 

    void f(auto&amp; lambda);

I&#39;m not sure the last form is even legal syntax.


**Are there other ways to define a lambda parameter?**



c++0x: proper way to receive a lambda as parameter by reference

Can lambda&#39;s be defined as class members?

For example, would it be possible to rewrite the code sample below using a lambda instead of a function object?

    struct Foo {
        std::function&lt;void()&gt; bar;
    };


The reason I wonder is because the following lambda&#39;s can be passed as arguments:

    template&lt;typename Lambda&gt;
    void call_lambda(Lambda lambda) // what is the exact type here?
    { 
        lambda();
    }
    
    int test_foo() {
        call_lambda([]() { std::cout &lt;&lt; &quot;lambda calling&quot; &lt;&lt; std::endl; });
    }

I figured that if a lambda can be passed as a function argument then maybe they can also be stored as a member variable.

After more tinkering I found that this works (but it&#39;s kind of pointless):

    auto say_hello = [](){ std::cout &lt;&lt; &quot;Hello&quot;; };
    struct Foo {
        typedef decltype(say_hello) Bar;
        Bar bar;
        Foo() : bar(say_hello) {}
    };



C++11 lambda as member variable?

Is it possible to put a function in a data structure, without first giving it a name with `def`?

    # This is the behaviour I want. Prints &quot;hi&quot;.
    def myprint(msg):
        print msg
    f_list = [ myprint ]
    f_list[0](&#39;hi&#39;)
    # The word &quot;myprint&quot; is never used again. Why litter the namespace with it?

The body of a lambda function is severely limited, so I can&#39;t use them. 

Edit: For reference, this is more like the real-life code where I encountered the problem.

    def handle_message( msg ):
        print msg
    def handle_warning( msg ):
        global num_warnings, num_fatals
        num_warnings += 1
        if ( is_fatal( msg ) ):
            num_fatals += 1
    handlers = (
        ( re.compile( &#39;^&lt;\w+&gt; (.*)&#39; ), handle_message ),
        ( re.compile( &#39;^\*{3} (.*)&#39; ), handle_warning ),
    )
    # There are really 10 or so handlers, of similar length.
    # The regexps are uncomfortably separated from the handler bodies,
    # and the code is unnecessarily long.
    
    for line in open( &quot;log&quot; ):
        for ( regex, handler ) in handlers:
            m = regex.search( line )
            if ( m ): handler( m.group(1) )

Choose Python function to call based on a regex

Lets say we have the following code:

    std::vector&lt;int&gt; f()
    {
      std::vector&lt;int&gt; y;
      ...
      return y;
    } 
    
    std::vector&lt;int&gt; x = ...
    x = f();

It seems the compiler has two approaches here:

(a) NRVO: Destruct x, then construct f() in place of x.  
(b) Move: Construct f() in temp space, move f() into x, destruct f().

Is the compiler free to use either approach, according to the standard?


Move or Named Return Value Optimization (NRVO)?

[This answer of @R. Martinho Fernandes][1] shows, that the safe-bool idiom is apperently deprecated in C++11, as it can be replaced by a simple

    explicit operator bool() const;
according to the standard quote in the answer `&#167;4 [conv] p3`:
&gt;An expression e can be implicitly converted to a type `T` if and only if the declaration `T t=e;` is well-formed, for some invented temporary variable `t` (&#167;8.5). Certain language constructs require that an expression be converted to a Boolean value. An expression `e` appearing in such a context is said to be **contextually converted** to `bool` and **is well-formed if and only if the declaration `bool t(e);` is well-formed**, for some invented temporary variable t (&#167;8.5).

The highlighted part clearly shows the &quot;implicit explicit cast&quot; (called &quot;contextual conversion&quot; in the standard) as @R. Martinho put it.

The &quot;certain language constructs&quot; that require that &quot;implicit explicit cast&quot; seem to be the following:

* `if`, `while`, `for` (`&#167;6.4 [stmt.select] p4`)
* binary logical operators `&amp;&amp;` and `||` (`&#167;5.14 [expr.log.and/or] p1` for both)
* the logical negation operator `!` (`&#167;5.3.1 [expr.unary.op] p9`)
* conditional operator `?:` (`&#167;5.14 [expr.cond] p1`)
* `static_assert` (`&#167;7 [dcl.dcl] p4`)
* `noexcept` (`&#167;15.4 [except.spec] p2`)

Is our assumption in the title correct? I hope we didn&#39;t overlook any potential drawbacks.

  [1]: https://stackoverflow.com/questions/6242296/conversion-function-for-error-checking-considered-good/6242355#6242355

Is the safe-bool idiom obsolete in C++11?

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

C++11 introduced a standardized memory model, but what exactly does that mean? And how is it going to affect C++ programming?

[This article][1] (by **Gavin Clarke** who quotes **[Herb Sutter][2]**) says that,

&gt; The memory model means that C++ code
&gt; now has a standardized library to call
&gt; regardless of who made the compiler
&gt; and on what platform it&#39;s running.
&gt; There&#39;s a standard way to control how
&gt; different threads talk to the
&gt; processor&#39;s memory.
&gt;
&gt; &quot;When you are talking about splitting
&gt; [code] across different cores that&#39;s
&gt; in the standard, we are talking about
&gt; the memory model. We are going to
&gt; optimize it without breaking the
&gt; following assumptions people are going
&gt; to make in the code,&quot; **Sutter** said.

Well, I can *memorize* this and similar paragraphs available online (as I&#39;ve had my own memory model since birth :P) and can even post as an answer to questions asked by others, but to be honest, I don&#39;t exactly understand this.

C++ programmers used to develop multi-threaded applications even before, so how does it matter if it&#39;s POSIX threads, or Windows threads, or C++11 threads? What are the benefits? I want to understand the low-level details.

I also get this feeling that the C++11 memory model is somehow related to C++11 multi-threading support, as I often see these two together. If it is, how exactly? Why should they be related?

As I don&#39;t know how the internals of multi-threading work, and what memory model means in general, please help me understand these concepts. :-)

  [1]: http://www.theregister.co.uk/2011/06/11/herb_sutter_next_c_plus_plus/page2.html
  [2]: https://en.wikipedia.org/wiki/Herb_Sutter


Content Type	Original Author	Original Content on Stackoverflow
Question	HighCommander4	View Question on Stackoverflow
Solution 1 - C++	James McNellis	View Answer on Stackoverflow
Solution 2 - C++	Thomas Minor	View Answer on Stackoverflow

Do c++11 lambdas capture variables they don't use?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Change default app.config at runtime

Difference between framework and static library in xcode4, and how to call them

Attributions