It seems you have to include `&lt;filesystem&gt;` like this:

    #include &lt;experimental/filesystem&gt;

Don&#39;t forget to add `-lstdc++fs` as a GCC flag!

Here is the proof:
[Coliru](http://coliru.stacked-crooked.com/a/27d982408933ec9f)

If that doesn&#39;t work, then that probably means that you don&#39;t have `filesystem` in your configuration.

Also, as @MartinR. pointed out, the **`experimental` is no longer needed in GCC 8+**.

This question is same to [this posted][1] earlier. I want to concatenate three columns instead of concatenating two columns:

Here is the combining two columns:

    df = DataFrame({&#39;foo&#39;:[&#39;a&#39;,&#39;b&#39;,&#39;c&#39;], &#39;bar&#39;:[1, 2, 3], &#39;new&#39;:[&#39;apple&#39;, &#39;banana&#39;, &#39;pear&#39;]})

    df[&#39;combined&#39;]=df.apply(lambda x:&#39;%s_%s&#39; % (x[&#39;foo&#39;],x[&#39;bar&#39;]),axis=1)

    df
	    bar	foo	new	combined
    0	1	a	apple	a_1
    1	2	b	banana	b_2
    2	3	c	pear	c_3
    
 I want to combine three columns with this command but it is not working, any idea?

    df[&#39;combined&#39;]=df.apply(lambda x:&#39;%s_%s&#39; % (x[&#39;bar&#39;],x[&#39;foo&#39;],x[&#39;new&#39;]),axis=1)
 


  [1]: https://stackoverflow.com/questions/11858472/pandas-combine-string-and-int-columns

How to concatenate multiple column values into a single column in Pandas dataframe

In RxJava 1, there was CompositeSubscription, but that is not present in RxJava2, There is something CompositeDisposable in rxJava2. How do I use CompositeDisposable or Disposable in RxJava2?

How to use CompositeDisposable of RxJava 2?

Using, CentOs 7.1, gcc version 6.1.0 (GCC) 
I receive this error:

    fatal error: filesystem: No such file or directory

on this line

    #include &lt;filesystem&gt;

compiling with

    g++ main.cpp -o main -std=c++17

where is the problem?




fatal error: filesystem: No such file or directory

Using, CentOs 7.1, gcc version 6.1.0 (GCC)
I receive this error:
<pre><code class="hljs language-yaml">fatal error: filesystem: No such file or directory
</code></pre>
on this line
<pre><code class="hljs language-arduino">#include &#x3C;filesystem>
</code></pre>
compiling with
<pre><code class="hljs language-css">g++ main.cpp -o main -std=c++17
</code></pre>
where is the problem?

The code below is from the [Boost.Spirit x3 documentation](http://ciere.com/cppnow15/x3_docs/spirit/tutorials/roman_numerals.html#spirit.tutorials.roman_numerals.grammars). It uses an interesting C++ syntax that I&#39;ve never seen before, which is nearly impossible to describe in a search query without knowing the proper terminology. Is this shorthand for the forward declaration of a class? Where is this feature mentioned in the C++ standard?

    namespace parser
    {
        using x3::eps;
        using x3::lit;
        using x3::_val;
        using x3::_attr;
        using ascii::char_;
    
        auto set_zero = [&amp;](auto&amp; ctx){ _val(ctx) = 0; };
        auto add1000 = [&amp;](auto&amp; ctx){ _val(ctx) += 1000; };
        auto add = [&amp;](auto&amp; ctx){ _val(ctx) += _attr(ctx); };
    
        // What is this? This is the very first use of the identifier `roman`.
        x3::rule&lt;class roman, unsigned&gt; const roman = &quot;roman&quot;;
        //       ^^^^^^^^^^^

        auto const roman_def =
            eps                 [set_zero]
            &gt;&gt;
            (
                -(+lit(&#39;M&#39;)     [add1000])
                &gt;&gt;  -hundreds   [add]
                &gt;&gt;  -tens       [add]
                &gt;&gt;  -ones       [add]
            )
        ;
    
        BOOST_SPIRIT_DEFINE(roman);
    }



What is the name of this unusual C++ template feature used by Boost.Spirit?

From [[5.3.3/1]](http://eel.is/c++draft/expr.sizeof#1), I found that:

&gt; The&#160;sizeof&#160;operator shall not be applied to an expression that has function or incomplete type

From [[3.9/5]](http://eel.is/c++draft/basic.types#5) I found that:

&gt; Incompletely-defined object types and&#160;cv void&#160;are&#160;incomplete types

Anyway, for `sizeof` does not evaluate it&#39;s operands, I would have said that `sizeof(void())` was a legal expression (actually GCC compiles it and the result is 1).  
On the other side, from [here](http://eel.is/c++draft/expr.sizeof), `void` is not mentioned while discussing `sizeof`, neither when the types having size 1 are mentioned, nor in the list of the ones having an _implementation defined_ size.

The question is thus: is `sizeof(void())` a legal expression?  
Is it guaranteed to have size equal to 1?  
Or is it a legal expression resulting in an UB and that&#39;s all?


Is sizeof(void()) a legal expression?

The question really fits in the title: I am curious to know what is the technical reason for this difference, but also the rationale ?

    std::shared_ptr&lt;void&gt; sharedToVoid; // legal;
    std::unique_ptr&lt;void&gt; uniqueToVoid; // ill-formed;

Why is shared_ptr&lt;void&gt; legal, while unique_ptr&lt;void&gt; is ill-formed?

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

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?

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?

Can we restrict variadic template arguments to a certain type? I.e., achieve something like this (not real C++ of course):

    struct X {};

    auto foo(X... args)

Here my intention is to have a function which accepts a variable number of `X` parameters.

The closest we have is this:

    template &lt;class... Args&gt;
    auto foo(Args... args)

but this accepts any type of parameter.

Restrict variadic template arguments

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 noticed that a majority (if not all) functions in `&lt;algorithm&gt;` are getting one or more extra overloads. All of these extra overloads add a specific new parameter, for example, `std::for_each` goes from:

    template&lt; class InputIt, class UnaryFunction &gt;
    UnaryFunction for_each( InputIt first, InputIt last, UnaryFunction f );
to:

    template&lt; class ExecutionPolicy, class InputIt, class UnaryFunction2 &gt;
    void for_each( ExecutionPolicy&amp;&amp; policy, InputIt first, InputIt last, UnaryFunction2 f );

What effect does this extra `ExecutionPolicy` have on these functions?

What are the differences between:

* `std::execution::seq`
* `std::execution::par`
* `std::execution::par_unseq`

And when to use one or the other?

Content Type	Original Author	Original Content on Stackoverflow
Question	RobertAalto	View Question on Stackoverflow
Solution 1 - C++	Arnav Borborah	View Answer on Stackoverflow

fatal error: filesystem: No such file or directory

C++ Problem Overview

C++ Solutions

Solution 1 - C++

How to use CompositeDisposable of RxJava 2?

How to concatenate multiple column values into a single column in Pandas dataframe

Attributions