&gt; std::atomic bool type not guranteed to be lock-free?

Correct. `std::atomic` may be implemented using locks.

&gt; then it&#39;s not atomic or what?

`std::atomic` is atomic whether it has been implemented using locks, or without. `std::atomic_flag` is guaranteed to be implemented without using locks.

&gt; So what&#39;s the difference b/w two

The primary difference besides the lock-free guarantee is:

&gt; `std::atomic_flag` does not provide load or store operations.

---

&gt; and when should I use which?

Usually, you will want to use `std::atomic&lt;bool&gt;` when you need an atomic boolean variable. `std::atomic_flag` is a low level structure that can be used to implement custom atomic structures.

`std::atomic&lt;T&gt;` guarantees that accesses to the variable will be atomic. It however does not says how is the atomicity achieved. It can be using lock-free variable, or using a lock. The actual implementation depends on your target architecture and the type `T`.

`std::atomic_flag` on the other hand is guaranteed to be implemented using a lock-free technique.

I have a form with different selects like : 

    &lt;select [(ngModel)]=&quot;selected.isConnected&quot; (ngModelChange)=&quot;formChanged()&quot; name=&quot;etat&quot; id=&quot;etat&quot; class=&quot;form-control&quot;&gt;
    	&lt;option value=&quot;0&quot;&gt;Not connected&lt;/option&gt;
    	&lt;option value=&quot;1&quot;&gt;Connected&lt;/option&gt;
    &lt;/select&gt; 

My backend expect to receive an int in the &quot;isConnected&quot; attribute. Unfortunately as soon as I change the value of the select the attribute is cast to a string : 

    {
        isConnected : &quot;0&quot;, // 0 expected
    }

For standard `&lt;input&gt;` I could use `type=&quot;number&quot;` but for a `&lt;select&gt;` I&#39;m clueless.

Is there a way to force angular 2 to cast the data to int ?

  

Angular cast select value to int

Is there no elegant solution to redirect to a specific page after logging out in Laravel 5.3? 

The function being called is from the trait **AuthenticatesUsers**: 

    public function logout(Request $request)
    {
        $this-&gt;guard()-&gt;logout();

        $request-&gt;session()-&gt;flush();

        $request-&gt;session()-&gt;regenerate();

        return redirect(&#39;/&#39;);
    }

This is a default function from the core of laravel. So I have to override the whole function I cannot edit the core.
But isn&#39;t there a more simpler solution, cause it feel like overkill to manually logout, flush and regenerate again.

Worked the answers out in an article:
https://codeneverlied.com/how-to-set-logout-redirect-path-in-laravel-5-8-and-before/

How to set laravel 5.3 logout redirect path?

I wasn&#39;t aware of the `std::atomic` variables but was aware about the `std::mutex` (weird right!) provided by the standard; however one thing caught my eye: there are two seemingly-same (to me) atomic types provided by the standard, listed below:

1. [`std::atomic&lt;bool&gt;`](http://en.cppreference.com/w/cpp/atomic/atomic)

2. [`std::atomic_flag`](http://en.cppreference.com/w/cpp/atomic/atomic_flag)

The `std::atomic_flag` contains the following explanation:

&gt; `std::atomic_flag` is an atomic boolean type. Unlike all specializations of `std::atomic`, it is guaranteed to be lock-free. Unlike `std::atomic&lt;bool&gt;`, `std::atomic_flag` does not provide load or store operations.

which I fail to understand. Is `std::atomic&lt;bool&gt;` not guaranteed to be lock-free? Then it&#39;s not atomic or what?

So what&#39;s the difference between the two and when should I use which?

difference between standard&#39;s atomic bool and atomic flag

I wasn't aware of the <code>std::atomic</code> variables but was aware about the <code>std::mutex</code> (weird right!) provided by the standard; however one thing caught my eye: there are two seemingly-same (to me) atomic types provided by the standard, listed below:
<ol>
<li>
<a href="http://en.cppreference.com/w/cpp/atomic/atomic" target="_blank" rel="noopener noreferrer"><code>std::atomic&#x3C;bool></code></a>
</li>
<li>
<a href="http://en.cppreference.com/w/cpp/atomic/atomic_flag" target="_blank" rel="noopener noreferrer"><code>std::atomic_flag</code></a>
</li>
</ol>
The <code>std::atomic_flag</code> contains the following explanation:
> <code>std::atomic_flag</code> is an atomic boolean type. Unlike all specializations of <code>std::atomic</code>, it is guaranteed to be lock-free. Unlike <code>std::atomic&#x3C;bool></code>, <code>std::atomic_flag</code> does not provide load or store operations.
which I fail to understand. Is <code>std::atomic&#x3C;bool></code> not guaranteed to be lock-free? Then it's not atomic or what?
So what's the difference between the two and when should I use which?

This (note the **comma operator**):

    #include &lt;iostream&gt;
    int main() {
        int x;
        x = 2, 3;
        std::cout &lt;&lt; x &lt;&lt; &quot;\n&quot;;
        return 0;
    }

outputs **2**.

However, if you use `return` with the comma operator, this:

    #include &lt;iostream&gt;
    int f() { return 2, 3; }
    int main() {
        int x;
        x = f();
        std::cout &lt;&lt; x &lt;&lt; &quot;\n&quot;;
        return 0;
    }

outputs **3**.

Why is the comma operator behaving differently with `return`? 

Different behaviour of comma operator in C++ with return?

[P0137][1] introduces the function template  `std::launder` and makes many, many changes to the standard in the sections concerning unions, lifetime, and pointers.

What is the problem this paper is solving? What are the changes to the language that I have to be aware of? And what are we `launder`ing?


  [1]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0137r1.html

What is the purpose of std::launder?

In general, for `int num`, `num++` (or `++num`), as a read-modify-write operation, is **not atomic**. But I often see compilers, for example [GCC][1], generate the following code for it ([try here][2]):

```c
void f()
{
  int num = 0;
  num++;
}
```

```assembly
f():
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], 0
        add     DWORD PTR [rbp-4], 1
        nop
        pop     rbp
        ret
```

Since line 5, which corresponds to `num++` is one instruction, can we conclude that `num++` **is atomic** in this case?

And if so, **does it mean that so-generated `num++` can be used in concurrent (multi-threaded) scenarios without any danger of data races** (i.e. we don&#39;t need to make it, for example, `std::atomic&lt;int&gt;` and impose the associated costs, since it&#39;s atomic anyway)?

**UPDATE**

Notice that this question is *not* whether increment *is* atomic (it&#39;s not and that was and is the opening line of the question). It&#39;s whether it *can* be in particular scenarios, i.e. whether one-instruction nature can in certain cases be exploited to avoid the overhead of the `lock` prefix. And, as the accepted answer mentions in the section about uniprocessor machines, as well as [this answer][3], the conversation in its comments and others explain, **it can** (although not with C or C++).


  [1]: https://en.wikipedia.org/wiki/GNU_Compiler_Collection
  [2]: https://godbolt.org/g/UFKEvp
  [3]: https://stackoverflow.com/a/39414316/4973224

Can num++ be atomic for &#39;int num&#39;?

The c++17 specification deprecates the `construct` and `destroy` members of the `std::allocator` object. The working group provided rationale for deprecating other member functions [here](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0174r0.html#2.4), under the heading &quot;Deprecate the redundant members of std::allocator&quot;.

However they don&#39;t mention specifically why those two members are deprecated or what the recommendation is for replacing that functionality. I&#39;m assuming the implication is to use `std::allocator_traits::construct` instead.

I&#39;m a bit confused about whether implementing `construct` may actually still be necessary in some cases though because of [this comment about `std::allocator_traits::construct`](http://en.cppreference.com/w/cpp/memory/allocator_traits/construct)

&gt; Because this function provides the automatic fall back to placement new, the member function construct() is an optional Allocator requirement since C++11. 

For custom allocators (e.g. for page-aligned memory using `memalign`), will falling back to placement `new` always produce the correct behavior?

Why are are std::allocator&#39;s construct and destroy functions deprecated in c++17?

I was reading that in C++ using macros like

    #define max(a,b) (a &gt; b ? a : b)

can result in a &#39;double evaluation&#39;. Can someone give me an example of when a double evaluation occurs and why it&#39;s bad?

P.S.: Surprisingly I couldn&#39;t find any detailed explanation when googling for it except for an example in [Clojure][1] (which I can&#39;t understand).

  [1]: http://en.wikipedia.org/wiki/Clojure


What is double evaluation and why should it be avoided?

C++17 added [`std::hardware_destructive_interference_size` and `std::hardware_constructive_interference_size`][1]. First, I thought it is just a portable way to get the size of a L1 cache line but that is an oversimplification.

Questions:

* How are these constants related to the L1 cache line size?
* Is there a good example that demonstrates their use cases?
* Both are defined `static constexpr`. Is that not a problem if you build a binary and execute it on other machines with different cache line sizes? How can it protect against false sharing in that scenario when you are not certain on which machine your code will be running?

  [1]: http://en.cppreference.com/w/cpp/thread/hardware_destructive_interference_size

Understanding std::hardware_destructive_interference_size and std::hardware_constructive_interference_size

I&#39;m in the process of updating a library that has an API surface that was built in .NET 3.5. As a result, all methods are synchronous. I can&#39;t change the API (i.e., convert return values to Task) because that would require that all callers change. So I&#39;m left with how to best call async methods in a synchronous way. This is in the context of ASP.NET 4, ASP.NET Core, and .NET/.NET Core console applications.

I may not have been clear enough - the situation is that I have existing code that is not async aware, and I want to use new libraries such as System.Net.Http and the AWS SDK that support only async methods. So I need to bridge the gap, and be able to have code that can be called synchronously but then can call async methods elsewhere.

I&#39;ve done a lot of reading, and there are a number of times this has been asked and answered.

https://stackoverflow.com/questions/38865307/calling-async-method-from-non-async-method

https://stackoverflow.com/questions/14485115/synchronously-waiting-for-an-async-operation-and-why-does-wait-freeze-the-pro

https://stackoverflow.com/questions/19010337/calling-an-async-method-from-a-synchronous-method

https://stackoverflow.com/questions/5095183/how-would-i-run-an-async-taskt-method-synchronously

https://stackoverflow.com/questions/22628087/calling-async-method-synchronously

https://stackoverflow.com/questions/9343594/how-to-call-asynchronous-method-from-synchronous-method-in-c

The problem is that most of the answers are different! The most common approach I&#39;ve seen is use .Result, but this can deadlock. I&#39;ve tried all the following, and they work, but I&#39;m not sure which is the best approach to avoid deadlocks, have good performance, and plays nicely with the runtime (in terms of honoring task schedulers, task creation options, etc). Is there a definitive answer? What is the best approach?


    private static T taskSyncRunner&lt;T&gt;(Func&lt;Task&lt;T&gt;&gt; task)
        {
            T result;
            // approach 1
            result = Task.Run(async () =&gt; await task()).ConfigureAwait(false).GetAwaiter().GetResult();
    
            // approach 2
            result = Task.Run(task).ConfigureAwait(false).GetAwaiter().GetResult();
    
            // approach 3
            result = task().ConfigureAwait(false).GetAwaiter().GetResult();
    
            // approach 4
            result = Task.Run(task).Result;
    
            // approach 5
            result = Task.Run(task).GetAwaiter().GetResult();
    
    
            // approach 6
            var t = task();
            t.RunSynchronously();
            result = t.Result;
    
            // approach 7
            var t1 = task();
            Task.WaitAll(t1);
            result = t1.Result;
    
            // approach 8?
    
            return result;
        }



Calling async methods from non-async code

I&#39;m given to understand that both are the same. But I recently(a bit late to the party) came across [ android support annotations][1] . The note in the same reads 

&gt; However, it&#39;s possible for a UI thread to be different from the main
&gt; thread in the case of system apps with multiple views on different
&gt; threads

I&#39;m unable to understand the scene here. Can someone explain the same?

**EDIT:** I have gone through the developer documentation and the same is contradicting the support doc linked in this question. Kindly stop posting both are the same.

  [1]: https://developer.android.com/studio/write/annotations.html#thread-annotations



Difference between the main thread and UI thread

I am trying to implement multiprocessing in my code, and so, I thought that I would start my learning with some examples.  I used the first example found in this [documentation][1].


    from multiprocessing import Pool
    def f(x):
        return x*x
    
    if __name__ == &#39;__main__&#39;:
        with Pool(5) as p:
            print(p.map(f, [1, 2, 3]))

When I run the above code I get an `AttributeError: can&#39;t get attribute &#39;f&#39; on &lt;module &#39;__main__&#39; (built-in)&gt;`.  I do not know why I am getting this error.  I am also using Python 3.5 if that helps.

  [1]: https://docs.python.org/3/library/multiprocessing.html#introduction


Multiprocessing example giving AttributeError

What does the statement

    return {};
in C++11 indicate, and when to use it instead of (say) 

    return NULL;
or
    
    return nullptr;

What does &quot;return {}&quot; statement mean in C++11?

In the last weeks something is bugging my brain about `virtual` and `override`.
I&#39;ve learned that when you do inheritance with virtual function you have to add `virtual` to let the compiler know to search for the right function.
Afterwards I learned also that in c++ 11 there is a new keyword - `override`. Now I&#39;m a little confused; **Do i need to use both virtual and override keywords in my program, or it&#39;s better to use only one of them?**

To explain myself - code examples of what I mean:

    class Base
    {
    public:
    	virtual void print() const = 0;
    	virtual void printthat() const = 0;
    	virtual void printit() const = 0;
    };
    
    class inhert : public Base
    {
    public:
    	// only virtual keyword for overriding.
    	virtual void print() const {}
    
    	// only override keyword for overriding.
    	void printthat() const override {}
    
    	// using both virtual and override keywords for overriding.
    	virtual void printit() const override {}
    };


What is the best method?

Should I use virtual, override, or both keywords?

As I understood in C++11 `decltype(expression)` is used to deduce the exact same type of the given expression. But when the expression is put into parentheses itself, then the deduces type is *lvalue reference* to the expression type. For example:

    int x;
    decltype(x) y = x;

is equivalent to `int y = x;` but,

    int x;
    decltype((x)) y = x;

is equivalent to `int&amp; y = x;`.

Respectively

     decltype(auto) f1()
     {
       int x = 0;
       return x; // decltype(x) is int, so f1 returns int
     }

but

     decltype(auto) f2()
     {
       int x = 0;
       return (x); // decltype((x)) is int&amp;, so f2 returns int&amp;
     }

What is the rationale for this behavior to be chose by the standard committee?

**Afterwords:**

Now I observed that at least in the case of **GCC 6.2** implementation when the expression in the parentheses is more complex for example `decltype((x + x))` the deduced type is `T`, but not `T&amp;`. This is even more confusing. I don&#39;t know whether this behavior is standard.

What is the rationale behind decltype behavior?

&gt; This (made-up) question was initially formulated as a puzzle, concealing 
&gt; some of the details that might help seeing the problem faster. Scroll down
&gt; for the simpler [MCVE](https://stackoverflow.com/help/mcve) version.

---

# Original (a-la puzzle) version 

I have this piece of code that outputs `0`:

    #include &lt;iostream&gt;
    #include &lt;regex&gt;
    
    using namespace std;
    
    regex sig_regex(&quot;[0-9]+&quot;);
    bool oldmode = false;
    
    template&lt;class T&gt;
    struct B
    {
        T bitset;
    
        explicit B(T flags) : bitset(flags) {}
    
        bool foo(T n, string s)
        {
            return bitset &lt; 32                   // The mouth is not full of teeth
                   &amp;&amp; 63 &gt; (~n &amp; 255) == oldmode // Fooness holds
                   &amp;&amp; regex_match(s, sig_regex); // Signature matches
        }
    };
    
    template&lt;class T&gt;
    struct D : B&lt;T&gt;
    {
        D(T flags) : B&lt;T&gt;(flags) {}
    
    };
    
    int main()
    {
        D&lt;uint64_t&gt; d(128 | 16 | 1);
        cout &lt;&lt; d.foo(7, &quot;123&quot;) &lt;&lt; endl;
    }

However, when I move the function `foo()` from `B` to `D` it starts outputting `1` ([proof is on Coliru][1]).

Why does this happen?

---

# MCVE version

[**Live on Coliru**][2]

    #include &lt;iostream&gt;
    #include &lt;bitset&gt;
    
    using namespace std;
    
    template&lt;class T&gt;
    struct B
    {
        T bitset{0};
    
        bool foo(int x)
        {
            return bitset &lt; 32 &amp;&amp; 63 &gt; (x + 1) == x % 2;
        }
    };
    
    template&lt;class T&gt;
    struct D : B&lt;T&gt;
    {
        bool bar(int x) // This is identical to B&lt;T&gt;::foo()
        {
            return bitset &lt; 32 &amp;&amp; 63 &gt; (x + 1) == x % 2;
        }
    };
    
    int main()
    {
        D&lt;uint64_t&gt; d;
        cout &lt;&lt; d.foo(1) &lt;&lt; endl; // outputs 1
        cout &lt;&lt; d.bar(1) &lt;&lt; endl; // outputs 0; So how is bar() different from foo()?
    }


[1]: http://coliru.stacked-crooked.com/a/0b2464c54204660d
[2]: http://coliru.stacked-crooked.com/a/c8844fa1b85e1785

Moving a member function from base class to derived class breaks the program for no obvious reason

Consider the following class:

    struct S { ~S() = delete; };

Shortly and for the purpose of the question: I cannot create instances of `S` like `S s{};` for I could not destroy them.  
As mentioned in the comments, I can still create an instance by doing `S *s = new S;`, but I cannot delete it as well.  
Therefore, the only use I can see for a deleted destructor is something like this:

    struct S {
        ~S() = delete;
        static void f() { }
    };

    int main() {
        S::f();
    }

That is, define a class that exposes only a bunch of static functions and forbid any attempt to create an instance of that class.

What are the other uses (if any) of a deleted destructor?

Uses of destructor = delete;

This warning leads to a serious problem cause I really can&#39;t call the delegate outside of the main thread using Xcode 9 beta 2. Strange thing is that this was working when I was using Xcode 8.3.3.

Also I thought it would only be good practice to call delegates from main thread only, isn&#39;t it? So why is this causing the app to crash now?

-[UIApplication delegate] must be called from main thread only

I wrote a simple multithreading programs as follows:

    static bool finished = false;
    
    int func()
    {
    	size_t i = 0;
    	while (!finished)
            ++i;
        return i;
    }
    
    int main()
    {
        auto result=std::async(std::launch::async, func);
        std::this_thread::sleep_for(std::chrono::seconds(1));
        finished=true;
        std::cout&lt;&lt;&quot;result =&quot;&lt;&lt;result.get();
        std::cout&lt;&lt;&quot;\nmain thread id=&quot;&lt;&lt;std::this_thread::get_id()&lt;&lt;std::endl;
    }
It behaves normally in debug mode in *Visual studio* or `-O0` in *gc*c and print out the result after `1` seconds. But it stuck and does not print anything in ***Release*** mode or `-O1 -O2 -O3`.

Multithreading program stuck in optimized mode but runs normally in -O0

If a data structure has multiple elements in it, the atomic version of it cannot (always) be lock-free.
I was told that this is true for larger types because the CPU can not atomically change the data without using some sort of lock.  

for example:

    #include &lt;iostream&gt;
    #include &lt;atomic&gt;

    struct foo {
        double a;
        double b;
    };

    std::atomic&lt;foo&gt; var;

    int main()
    {
        std::cout &lt;&lt; var.is_lock_free() &lt;&lt; std::endl;
        std::cout &lt;&lt; sizeof(foo) &lt;&lt; std::endl;
        std::cout &lt;&lt; sizeof(var) &lt;&lt; std::endl;
    }

the output (Linux/gcc) is:

    0
    16
    16

Since the atomic and `foo` are the same size, I don&#39;t think a lock is stored in the atomic.

My question is:  
If an atomic variable uses a lock, where is it stored and what does that mean for multiple instances of that variable ?


Where is the lock for a std::atomic?

I am a newbie to operating systems and every answer I&#39;ve found on Stackoverflow is so complicated that I am unable to understand. Can someone provide an explanation for what is an 
&gt; atomic operation

For a newbie?


**My understanding:** My understanding is that `atomic operation` means it executes fully with **no interruption**? Ie, it is a **blocking** operation with no scope of interruption?

Content Type	Original Author	Original Content on Stackoverflow
Question	hg_git	View Question on Stackoverflow
Solution 1 - C++	eerorika	View Answer on Stackoverflow
Solution 2 - C++	michalsrb	View Answer on Stackoverflow

difference between standard's atomic bool and atomic flag

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

How to set laravel 5.3 logout redirect path?

Angular cast select value to int

Attributions