You must specify `flagId` to be captured. That is what the `[]` part is for. Right now it doesn&#39;t capture anything. You can capture ([more info][1]) by value or by reference. Something like:

    auto new_end = std::remove_if(m_FinalFlagsVec.begin(), m_FinalFlagsVec.end(),
            [&amp;flagId](Flag&amp; device)
        { return device.getId() == flagId; });

Which captures by reference. If you want to capture by const value, you can do this:

    auto new_end = std::remove_if(m_FinalFlagsVec.begin(), m_FinalFlagsVec.end(),
            [flagId](Flag&amp; device)
        { return device.getId() == flagId; });

Or by mutable value:

    auto new_end = std::remove_if(m_FinalFlagsVec.begin(), m_FinalFlagsVec.end(),
            [flagId](Flag&amp; device) mutable
        { return device.getId() == flagId; });

Sadly there is no straightforward way to capture by `const` reference until C++17. I personally would just declare a temporary `const` ref and capture that by ref:

    const auto&amp; tmp = flagId;
    auto new_end = std::remove_if(m_FinalFlagsVec.begin(), m_FinalFlagsVec.end(),
                [&amp;tmp](Flag&amp; device)
            { return device.getId() == tmp; }); //tmp is immutable

In C++17 and beyond we can capture by const-reference by using [`as_const`](https://en.cppreference.com/w/cpp/utility/as_const)

    auto new_end = std::remove_if(m_FinalFlagsVec.begin(), m_FinalFlagsVec.end(),
                [&amp;flagId = std::as_const(flagId)](Flag&amp; device)
            { return device.getId() == flagId; });


  [1]: http://en.cppreference.com/w/cpp/language/lambda#Lambda_capture

It won&#39;t let me comment because I don&#39;t have enough &quot;points&quot; but to reply to AndyG there is an easy way to capture by const reference now:
```
auto new_end = std::remove_if(m_FinalFlagsVec.begin(), m_FinalFlagsVec.end(),
        [&amp;flagId = as_const(flagId)](Flag&amp; device)
    { return device.getId() == flagId; });
```

I have to send mails using my web application. Given the below code showing `The SMTP server requires a secure connection or the client was not authenticated. The server response was:` 
&gt;5.7.57 SMTP; Client was not authenticated to send anonymous mail during MAIL FROM.

Help me to find a proper solution. Thank you.

**Code:**

    protected void btnsubmit_Click(object sender, EventArgs e)
     {
      
       Ticket_MailTableAdapters.tbl_TicketTableAdapter tc;
       tc = new Ticket_MailTableAdapters.tbl_TicketTableAdapter();
       DataTable dt = new DataTable();
       dt = tc.GetEmail(dpl_cate.SelectedValue);
       foreach (DataRow row in dt.Rows)
        {
        string eml = (row[&quot;Emp_Email&quot;].ToString());
        var fromAddress = &quot;emailAddress&quot;;
        var toAddress = eml;
        const string fromPassword = &quot;*****&quot;;
        string body = &quot;Welcome..&quot;;
     // smtp settings
        var smtp = new System.Net.Mail.SmtpClient();
           {
             smtp.Host = &quot;smtp.office365.com&quot;;
             smtp.Port = 587;
             smtp.EnableSsl = true;
             
             smtp.DeliveryMethod = System.Net.Mail.SmtpDeliveryMethod.Network;
             smtp.Credentials = new NetworkCredential(fromAddress, fromPassword);
             smtp.UseDefaultCredentials = false;
             smtp.Timeout = 600000;
           }
      // Passing values to smtp object
         smtp.Send(fromAddress, toAddress, subject, body);
         }
      } 
     }



5.7.57 SMTP - Client was not authenticated to send anonymous mail during MAIL FROM error

I press &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Enter&lt;/kbd&gt;, but not working, &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Enter&lt;/kbd&gt; start a new line, but not add semicolon at the end of previous line. Is there a shortcut?

How to add semicolon to the end of the line in visual studio code

I am trying  to follow [this example](https://stackoverflow.com/questions/4478636/stdremove-if-lambda-not-removing-anything-from-the-collection) to use a lambda with `remove_if`. Here is my attempt:

    int flagId = _ChildToRemove-&gt;getId();
	auto new_end = std::remove_if(m_FinalFlagsVec.begin(), m_FinalFlagsVec.end(), 
            [](Flag&amp; device) { 
                return device.getId() == flagId; 
            });
    
    m_FinalFlagsVec.erase(new_end, m_FinalFlagsVec.end());


but this fails to compile:

    error C3493: &#39;flagId&#39; cannot be implicitly captured because no default capture mode has been specified

How can I include the outside parameter, `flagId`,  in the lambda expression?

Error: variable &quot;cannot be implicitly captured because no default capture mode has been specified&quot;

I am trying to follow <a href="https://stackoverflow.com/questions/4478636/stdremove-if-lambda-not-removing-anything-from-the-collection" target="_blank" rel="noopener noreferrer">this example</a> to use a lambda with <code>remove_if</code>. Here is my attempt:
<pre><code class="hljs language-ini">int flagId = _ChildToRemove->getId();
auto new_end = std::remove_if(m_FinalFlagsVec.begin(), m_FinalFlagsVec.end(), 
 [](Flag&#x26; device) { 
 return device.getId() == flagId; 
 });

m_FinalFlagsVec.erase(new_end, m_FinalFlagsVec.end());
</code></pre>
but this fails to compile:
<pre><code class="hljs language-vbnet">error C3493: 'flagId' cannot be implicitly captured because no default capture mode has been specified
</code></pre>
How can I include the outside parameter, <code>flagId</code>, in the lambda expression?

I just stumbled upon something. At first I thought it might be a case of branch misprediction like it is [in this case][1], but I cannot explain why branch misprediction should cause this behaviour.

I implemented two versions of Bubble Sort in Java and did some performance testing:

    import java.util.Random;

    public class BubbleSortAnnomaly {

        public static void main(String... args) {
            final int ARRAY_SIZE = Integer.parseInt(args[0]);
            final int LIMIT = Integer.parseInt(args[1]);
            final int RUNS = Integer.parseInt(args[2]);

            int[] a = new int[ARRAY_SIZE];
            int[] b = new int[ARRAY_SIZE];
            Random r = new Random();
            for (int run = 0; RUNS &gt; run; ++run) {
                for (int i = 0; i &lt; ARRAY_SIZE; i++) {
                    a[i] = r.nextInt(LIMIT);
                    b[i] = a[i];
                }

                System.out.print(&quot;Sorting with sortA: &quot;);
                long start = System.nanoTime();
                int swaps = bubbleSortA(a);

                System.out.println(  (System.nanoTime() - start) + &quot; ns. &quot;
                                   + &quot;It used &quot; + swaps + &quot; swaps.&quot;);

                System.out.print(&quot;Sorting with sortB: &quot;);
                start = System.nanoTime();
                swaps = bubbleSortB(b);

                System.out.println(  (System.nanoTime() - start) + &quot; ns. &quot;
                                   + &quot;It used &quot; + swaps + &quot; swaps.&quot;);
            }
        }

        public static int bubbleSortA(int[] a) {
            int counter = 0;
            for (int i = a.length - 1; i &gt;= 0; --i) {
                for (int j = 0; j &lt; i; ++j) {
                    if (a[j] &gt; a[j + 1]) {
                        swap(a, j, j + 1);
                        ++counter;
                    }
                }
            }
            return (counter);
        }

        public static int bubbleSortB(int[] a) {
            int counter = 0;
            for (int i = a.length - 1; i &gt;= 0; --i) {
                for (int j = 0; j &lt; i; ++j) {
                    if (a[j] &gt;= a[j + 1]) {
                        swap(a, j, j + 1);
                        ++counter;
                    }
                }
            }
            return (counter);
        }

        private static void swap(int[] a, int j, int i) {
            int h = a[i];
            a[i] = a[j];
            a[j] = h;
        }
    }

As we can see, the only difference between those two sorting methods is the `&gt;` vs. `&gt;=`. When running the program with `java BubbleSortAnnomaly 50000 10 10`, one would obviously expect that `sortB` is slower than `sortA` because it has to execute more `swap(...)`s. But I got the following (or similar) output on three different machines:

    Sorting with sortA: 4.214 seconds. It used  564960211 swaps.
    Sorting with sortB: 2.278 seconds. It used 1249750569 swaps.
    Sorting with sortA: 4.199 seconds. It used  563355818 swaps.
    Sorting with sortB: 2.254 seconds. It used 1249750348 swaps.
    Sorting with sortA: 4.189 seconds. It used  560825110 swaps.
    Sorting with sortB: 2.264 seconds. It used 1249749572 swaps.
    Sorting with sortA: 4.17  seconds. It used  561924561 swaps.
    Sorting with sortB: 2.256 seconds. It used 1249749766 swaps.
    Sorting with sortA: 4.198 seconds. It used  562613693 swaps.
    Sorting with sortB: 2.266 seconds. It used 1249749880 swaps.
    Sorting with sortA: 4.19  seconds. It used  561658723 swaps.
    Sorting with sortB: 2.281 seconds. It used 1249751070 swaps.
    Sorting with sortA: 4.193 seconds. It used  564986461 swaps.
    Sorting with sortB: 2.266 seconds. It used 1249749681 swaps.
    Sorting with sortA: 4.203 seconds. It used  562526980 swaps.
    Sorting with sortB: 2.27  seconds. It used 1249749609 swaps.
    Sorting with sortA: 4.176 seconds. It used  561070571 swaps.
    Sorting with sortB: 2.241 seconds. It used 1249749831 swaps.
    Sorting with sortA: 4.191 seconds. It used  559883210 swaps.
    Sorting with sortB: 2.257 seconds. It used 1249749371 swaps.

When I set the parameter for `LIMIT` to, e.g., `50000` (`java BubbleSortAnnomaly 50000 50000 10`), I get the expected results:

    Sorting with sortA: 3.983 seconds. It used  625941897 swaps.
    Sorting with sortB: 4.658 seconds. It used  789391382 swaps.

I ported the program to C++ to determine whether this problem is Java-specific. Here is the C++ code.

    #include &lt;cstdlib&gt;
    #include &lt;iostream&gt;

    #include &lt;omp.h&gt;

    #ifndef ARRAY_SIZE
    #define ARRAY_SIZE 50000
    #endif

    #ifndef LIMIT
    #define LIMIT 10
    #endif

    #ifndef RUNS
    #define RUNS 10
    #endif

    void swap(int * a, int i, int j)
    {
        int h = a[i];
        a[i] = a[j];
        a[j] = h;
    }

    int bubbleSortA(int * a)
    {
        const int LAST = ARRAY_SIZE - 1;
        int counter = 0;
        for (int i = LAST; 0 &lt; i; --i)
        {
            for (int j = 0; j &lt; i; ++j)
            {
                int next = j + 1;
                if (a[j] &gt; a[next])
                {
                    swap(a, j, next);
                    ++counter;
                }
            }
        }
        return (counter);
    }

    int bubbleSortB(int * a)
    {
        const int LAST = ARRAY_SIZE - 1;
        int counter = 0;
        for (int i = LAST; 0 &lt; i; --i)
        {
            for (int j = 0; j &lt; i; ++j)
            {
                int next = j + 1;
                if (a[j] &gt;= a[next])
                {
                    swap(a, j, next);
                    ++counter;
                }
            }
        }
        return (counter);
    }

    int main()
    {
        int * a = (int *) malloc(ARRAY_SIZE * sizeof(int));
        int * b = (int *) malloc(ARRAY_SIZE * sizeof(int));

        for (int run = 0; RUNS &gt; run; ++run)
        {
            for (int idx = 0; ARRAY_SIZE &gt; idx; ++idx)
            {
                a[idx] = std::rand() % LIMIT;
                b[idx] = a[idx];
            }

            std::cout &lt;&lt; &quot;Sorting with sortA: &quot;;
            double start = omp_get_wtime();
            int swaps = bubbleSortA(a);

            std::cout &lt;&lt; (omp_get_wtime() - start) &lt;&lt; &quot; seconds. It used &quot; &lt;&lt; swaps
                      &lt;&lt; &quot; swaps.&quot; &lt;&lt; std::endl;

            std::cout &lt;&lt; &quot;Sorting with sortB: &quot;;
            start = omp_get_wtime();
            swaps = bubbleSortB(b);

            std::cout &lt;&lt; (omp_get_wtime() - start) &lt;&lt; &quot; seconds. It used &quot; &lt;&lt; swaps
                      &lt;&lt; &quot; swaps.&quot; &lt;&lt; std::endl;
        }

        free(a);
        free(b);

        return (0);
    }

This program shows the same behaviour. Can someone explain what exactly is going on here?

Executing `sortB` first and then `sortA` does not change the results.

  [1]: https://stackoverflow.com/questions/11227809/why-is-processing-a-sorted-array-faster-than-an-unsorted-array


&gt; vs. &gt;= in bubble sort causes significant performance difference

How to configure CLion IDE for Qt Framework?
Is this IDE compatible with Qt, or are there other IDEs compatible with Qt?

I just want to try to use something else than Qt Creator.

How to configure CLion IDE for Qt Framework?

I would like my C++ code to stop running if a certain condition is met, but I&#39;m not sure how to do that. So just at any point if an `if` statement is true terminate the code like this:

    if (x==1)
    {
        kill code;
    }


How to end C++ code

If I want to build a very simple array like:

    int myArray[3] = {1,2,3};


Should I use `std::array` instead?

    std::array&lt;int, 3&gt; a = {{1, 2, 3}};
What are the advantages of using `std::array` over usual ones? Is it more performant? Just easier to handle for copy/access?

std::array vs array performance

I recently asked a question on [Programmers][1] regarding reasons to use manual bit manipulation of primitive types over `std::bitset`.

From that discussion I have concluded that the main reason is its comparatively poorer performance, although I&#39;m not aware of any measured basis for this opinion. So next question is:

**what _is_ the performance hit, if any, likely to be incurred by using `std::bitset` over bit-manipulation of a primitive?**

The question is intentionally broad, because after looking online I haven&#39;t been able to find anything, so I&#39;ll take what I can get. Basically I&#39;m after a resource that provides some profiling of `std::bitset` vs &#39;pre-bitset&#39; alternatives to the same problems on some common machine architecture using GCC, Clang and/or VC++. There is a very comprehensive paper which attempts to answer this question for bit vectors:

http://www.cs.up.ac.za/cs/vpieterse/pub/PieterseEtAl_SAICSIT2010.pdf

Unfortunately, it either predates or considered out of scope `std::bitset`, so it focuses on vectors/dynamic array implementations instead.

I really just want to know whether `std::bitset` is _better_ than the alternatives for the use cases it is intended to solve. I already know that it is _easier_ and _clearer_ than bit-fiddling on an integer, but is it as _fast_?

  [1]: https://softwareengineering.stackexchange.com/questions/284160/is-there-any-advantage-to-c-style-bit-manipulation-over-stdbitset

What is the performance of std::bitset?

The two characters `)&quot;` terminate the raw string literal in the example below. &lt;br&gt;
The sequence `)&quot;` could appear in my text at some point, and I want the string to continue even if this sequence is found within it.

    R&quot;(  
        Some Text)&quot;  
    )&quot;;       // ^^
   

How can I include the sequence `)&quot;` within the string literal without terminating it?

Include )&quot; in raw string literal without terminating said literal

Given availability of `make_unique` and `make_shared`, as well as automatic deletion by `unique_ptr` and `shared_ptr` destructors, what are the situations (apart from supporting legacy code) for using `new` and `delete` in C++14?

Are new and delete still useful in C++14?

How can I pass a `std::unique_ptr` into a function? Lets say I have the following class:

    class A
    {
    public:
        A(int val)
        {
            _val = val;
        }

        int GetVal() { return _val; }
    private:
        int _val;
    };

The following does not compile:


    void MyFunc(unique_ptr&lt;A&gt; arg)
    {
        cout &lt;&lt; arg-&gt;GetVal() &lt;&lt; endl;
    }

    int main(int argc, char* argv[])
    {
        unique_ptr&lt;A&gt; ptr = unique_ptr&lt;A&gt;(new A(1234));
        MyFunc(ptr);

	    return 0;
    }

Why can I not pass a `std::unique_ptr` into a function? Surely this is the primary purpose of the construct? Or did the C++ committee intend for me to fall back to raw C-style pointers and pass it like this:
    
    MyFunc(&amp;(*ptr)); 

And most strangely of all, why is this an OK way of passing it? It seems horribly inconsistent:

    MyFunc(unique_ptr&lt;A&gt;(new A(1234)));



How can I pass std::unique_ptr into a function

Both can be used to apply a function to a range of elements.

On a high level:

 - `std::for_each` ignores the return value of the function, and
   guarantees order of execution.
 - `std::transform` assigns the return value to the iterator, and does
   not guarantee the order of execution.

When do you prefer using the one versus the other? Are there any subtle caveats?

What is the difference between std::transform and std::for_each?

My colleague and I had a bug that was due to our assumption that an empty stream calling `allMatch()` would return `false`. 

    if (myItems.allMatch(i -&gt; i.isValid()) { 
        //do something
    }

Of course, it is kind of our fault for assuming and not reading documentation. But what I don&#39;t understand is why the default `allMatch()` behavior for an empty stream returns `true`. What was the reasoning for this? Like the `anyMatch()` (which contrarily returns false), this operation is used in an imperative way that departs the monad and probably used in an `if` statement. Considering those facts, is there any reason why having `allMatch()` default to `true` on an empty stream be desirable for majority of uses?  

Why does Stream.allMatch() return true for an empty stream?

I&#39;m working on a multi-tasking network project and I&#39;m new on `Threading.Tasks`. I implemented a simple `Task.Factory.StartNew()` and I wonder how can I do it with `Task.Run()`?

Here is the basic code:

    Task.Factory.StartNew(new Action&lt;object&gt;(
    (x) =&gt;
    {
        // Do something with &#39;x&#39;
    }), rawData);

I looked into `System.Threading.Tasks.Task` in *Object Browser* and I couldn&#39;t find a `Action&lt;T&gt;` like parameter. There is only `Action` that takes `void` parameter and no *type*.

There are only 2 things similiar: `static Task Run(Action action)` and `static Task Run(Func&lt;Task&gt; function)` but can&#39;t post parameter(s) with both.

Yes, I know I can create a simple extension method for it but **my main question is can we write it on single line** with `Task.Run()`?

Task.Run with Parameter(s)?

I have a map with `Integer` keys and values. I need to transform it into a `String` with this specific format: `key1 - val1, key2 - val2, key3 - val3`. Now, I&#39;m using `forEach` to format each element, collect them into a List, and then do String.join();

    List&lt;String&gt; ships = new ArrayList&lt;&gt;(4);
	for (Map.Entry&lt;Integer, Integer&gt; entry : damagedMap.entrySet())
	{
	    ships.add(entry.getKey() + &quot; - &quot; + entry.getValue());
	}
	result = String.join(&quot;,&quot;, ships);

Is there any shorter way to do it? And it would be good to do it with lambda, because I need some practice using lambdas.

Using lambda to format Map into String

I have map `Map&lt;Type, Long&gt; countByType` and I want to have a list which has sorted (min to max) keys by their corresponding values. My try is:


    countByType.entrySet().stream().sorted().collect(Collectors.toList());

however this just gives me a list of entries, how can I get a list of types, without losing the order?

Java 8 stream map to list of keys sorted by values

While trying out the Visual Studio 2015 RC, I received a run-time error on previously working code.  Given the lambda  `(x =&gt; x.CustomerStatusID == CustomerStatuses.Active)` which was passed to a function as an `Expression&lt;&gt;`, the debugger shows a difference in the expression tree.  Formerly it compiled as this:

    .Lambda #Lambda1&lt;System.Func`2[Services.DataClasses.CustomerDC,System.Boolean]&gt;(Services.DataClasses.CustomerDC $x)
    {
        (System.Int32)$x.CustomerStatusID == 0
    }

But in C# 6.0 it now compiles as 

    .Lambda #Lambda1&lt;System.Func`2[Services.DataClasses.CustomerDC,System.Boolean]&gt;(Services.DataClasses.CustomerDC $x)
    {
        (System.Int32)$x.CustomerStatusID == (System.Int32).Constant&lt;Services.DataClasses.CustomerStatuses&gt;(Active)
    }

Although the fix to my tree-traversing code was straightforward and the additional detail is appreciated, does anyone know of any other gotchas floating around like this?  

Alternately, does anyone have a link to information on the specifics of how overload resolution was improved?  I cannot find any.

Content Type	Original Author	Original Content on Stackoverflow
Question	user63898	View Question on Stackoverflow
Solution 1 - C++	AndyG	View Answer on Stackoverflow
Solution 2 - C++	David Bien	View Answer on Stackoverflow

Error: variable "cannot be implicitly captured because no default capture mode has been specified"

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

How to add semicolon to the end of the line in visual studio code

5.7.57 SMTP - Client was not authenticated to send anonymous mail during MAIL FROM error

Attributions