Its called a parameter pack and refers to zero or more template parameters:

http://en.cppreference.com/w/cpp/language/parameter_pack

    std::size_t ...Rs

is the parameter pack of type `std::size_t`. 
A variable of that type (e.g. `Rs... my_var`) can be unpacked with:

    my_var... 

This pattern is heavily used in forwarding an (unknown) amount of arguments:
    
    template &lt; typename... T &gt;
    Derived( T&amp;&amp;... args ) : Base( std::forward&lt; T &gt;( args )... )
    {
    }




I want to build a `HashSet&lt;u8&gt;` from a `Vec&lt;u8&gt;`. I&#39;d like to do this

1. in one line of code,
2. copying the data only once,
3. using only `2n` memory, 

but the only thing I can get to compile is this piece of .. junk, which I think copies the data twice and uses `3n` memory.

    fn vec_to_set(vec: Vec&lt;u8&gt;) -&gt; HashSet&lt;u8&gt; {
        let mut victim = vec.clone();
        let x: HashSet&lt;u8&gt; = victim.drain(..).collect();
        return x;
    }

I was hoping to write something simple, like this:

    fn vec_to_set(vec: Vec&lt;u8&gt;) -&gt; HashSet&lt;u8&gt; {
        return HashSet::from_iter(vec.iter());
    }

but that won&#39;t compile:

&lt;!-- language: none --&gt;

    error[E0308]: mismatched types
     --&gt; &lt;anon&gt;:5:12
      |
    5 |     return HashSet::from_iter(vec.iter());
      |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected u8, found &amp;u8
      |
      = note: expected type `std::collections::HashSet&lt;u8&gt;`
      = note:    found type `std::collections::HashSet&lt;&amp;u8, _&gt;`

.. and I don&#39;t really understand the error message, probably because I need to RTFM.

Build HashSet from a vector in Rust

&gt; :( Oops.
&gt; 500 Internal Server Error 
&gt; An error occurred while starting the application.

This message came out when I added database functionality to my asp.net core app and deployed it to iis. When I developed it in Visual Studio, everything went well. But after deploying, this error messages appeared. 

I tried to use `dotnet myapp.dll` to run my app in the deploy folder, and found out it worked well. It is likely that the problem is relation to iis. I tried to add `&lt;compilation debug=&quot;true&quot;&gt;..&lt;/compilation&gt;` to web.config, but it seems useless. What is problem are actually, or is there any other way to see the detailed error info to help find out what&#39;s happened?

asp.net core app deployed on iis meets 500 internal server error

It may seems a silly question, but when I try to look at this answer in SOF,

https://stackoverflow.com/questions/35334752/compile-time-generated-tables

I noted statements such as this:

    template&lt;
        typename IntType, std::size_t Cols, 
        IntType(*Step)(IntType),IntType Start, std::size_t ...Rs
    &gt; 
    constexpr auto make_integer_matrix(std::index_sequence&lt;Rs...&gt;)
    {
        return std::array&lt;std::array&lt;IntType,Cols&gt;,sizeof...(Rs)&gt; 
            {{make_integer_array&lt;IntType,Step,Start + (Rs * Cols),Cols&gt;()...}};
    }


more specifically : 

    std::size_t ...Rs
or
    
    std::index_sequence&lt;Rs...&gt;

what does ... means here?

# Edit 1

The question that reported as the original question related to this question is not correct: 

That question can not answer these two cases (as they are not functions with variable number of arguments)

    std::size_t ...Rs
    std::index_sequence&lt;Rs...&gt;

But this is a good explanation:

https://xenakios.wordpress.com/2014/01/16/c11-the-three-dots-that-is-variadic-templates-part/





what does this ... (three dots) means in c++

It may seems a silly question, but when I try to look at this answer in SOF,
<a href="https://stackoverflow.com/questions/35334752/compile-time-generated-tables" target="_blank" rel="noopener noreferrer">https://stackoverflow.com/questions/35334752/compile-time-generated-tables</a>
I noted statements such as this:
<pre><code class="hljs language-c">template&#x3C;
 typename IntType, std::size_t Cols, 
 IntType(*Step)(IntType),IntType Start, std::size_t ...Rs
> 
constexpr auto make_integer_matrix(std::index_sequence&#x3C;Rs...>)
{
 return std::array&#x3C;std::array&#x3C;IntType,Cols>,sizeof...(Rs)> 
 {{make_integer_array&#x3C;IntType,Step,Start + (Rs * Cols),Cols>()...}};
}
</code></pre>
more specifically :
<pre><code class="hljs language-c">std::size_t ...Rs
</code></pre>
or
<pre><code class="hljs language-c">std::index_sequence&#x3C;Rs...>
</code></pre>
what does ... means here?
<h3 id="edit-1"><a aria-hidden="true" tabindex="-1" href="#edit-1"></a>Edit 1</h3>
The question that reported as the original question related to this question is not correct:
That question can not answer these two cases (as they are not functions with variable number of arguments)
<pre><code class="hljs language-c">std::size_t ...Rs
std::index_sequence&#x3C;Rs...>
</code></pre>
But this is a good explanation:
<a href="https://xenakios.wordpress.com/2014/01/16/c11-the-three-dots-that-is-variadic-templates-part/" target="_blank" rel="noopener noreferrer">https://xenakios.wordpress.com/2014/01/16/c11-the-three-dots-that-is-variadic-templates-part/</a>

I&#39;m trying to call native machine-language code. Here&#39;s what I have so far (it gets a bus error):

    char prog[] = {&#39;\xc3&#39;}; // x86 ret instruction

    int main()
    {
        typedef double (*dfunc)();

        dfunc d = (dfunc)(&amp;prog[0]);
        (*d)();
        return 0;
    }

It does correctly call the function and it gets to the ret instruction.  But when it tries to execute the ret instruction, it has a SIGBUS error.  Is it because I&#39;m executing code on a page that is not cleared for execution or something like that?

So what am I doing wrong here? 

How to call machine code stored in char array?

This is an example to illustrate my question which involves some much more complicated code that I can&#39;t post here.

    #include &lt;stdio.h&gt;
    int main()
    {
        int a = 0;
        for (int i = 0; i &lt; 3; i++)
        {
            printf(&quot;Hello\n&quot;);
            a = a + 1000000000;
        }
    }

This program contains undefined behavior on my platform because `a` will overflow on the 3rd loop.

Does that make the **whole program** have undefined behavior, or only after the **overflow actually happens**? Could the compiler potentially work out that `a` **will** overflow so it can declare the whole loop undefined and not bother to run the printfs even though they all happen before the overflow?

&lt;sub&gt;(Tagged C and C++ even though are different because I&#39;d be interested in answers for both languages if they are different.)&lt;/sub&gt;


At what point in the loop does integer overflow become undefined behavior?

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?

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?

Difference between execution policies and when to use them

This question is motivated by me implementing cryptographic algorithms (e.g. SHA-1) in C/C++, writing portable platform-agnostic code, and thoroughly avoiding [undefined behavior](https://en.wikipedia.org/wiki/Undefined_behavior).

Suppose that a standardized crypto algorithm asks you to implement this:

    b = (a &lt;&lt; 31) &amp; 0xFFFFFFFF

where `a` and `b` are unsigned 32-bit integers. Notice that in the result, we discard any bits above the least significant 32 bits.

----

As a first naive approximation, we might assume that `int` is 32 bits wide on most platforms, so we would write:

    unsigned int a = (...);
    unsigned int b = a &lt;&lt; 31;

We know this code won&#39;t work everywhere because `int` is 16 bits wide on some systems, 64 bits on others, and possibly even 36 bits. But using `stdint.h`, we can improve this code with the `uint32_t` type:

    uint32_t a = (...);
    uint32_t b = a &lt;&lt; 31;

So we are done, right? That&#39;s what I thought for years. ... Not quite. Suppose that on a certain platform, we have:

    // stdint.h
    typedef unsigned short uint32_t;

The rule for performing arithmetic operations in C/C++ is that if the type (such as `short`) is narrower than `int`, then it gets widened to `int` if all values can fit, or `unsigned int` otherwise.

Let&#39;s say that the compiler defines `short` as 32 bits (signed) and `int` as 48 bits (signed). Then these lines of code:

    uint32_t a = (...);
    uint32_t b = a &lt;&lt; 31;

will effectively mean:

    unsigned short a = (...);
    unsigned short b = (unsigned short)((int)a &lt;&lt; 31);

Note that `a` is promoted to `int` because all of `ushort` (i.e. `uint32`) fits into `int` (i.e. `int48`).

But now we have a problem: **shifting non-zero bits left into the sign bit of a signed integer type is undefined behavior**. This problem happened because our `uint32` was promoted to `int48` - instead of being promoted to `uint48` (where left-shifting would be okay).

----

Here are my questions:

0. Is my reasoning correct, and is this a legitimate problem in theory?

0. Is this problem safe to ignore because on every platform the next integer type is double the width?

0. Is a good idea to correctly defend against this pathological situation by pre-masking the input like this?: `b = (a &amp; 1) &lt;&lt; 31;`. (This will necessarily be correct on every platform. But this could make a speed-critical crypto algorithm slower than necessary.)

Clarifications/edits:

* I&#39;ll accept answers for C or C++ or both. I want to know the answer for at least one of the languages.

* The pre-masking logic may hurt bit rotation. For example, GCC will compile `b = (a &lt;&lt; 31) | (a &gt;&gt; 1);` to a 32-bit bit-rotation instruction in assembly language. But if we pre-mask the left shift, it is possible that the new logic is not translated into bit rotation, which means now 4 operations are performed instead of 1.

Content Type	Original Author	Original Content on Stackoverflow
Question	mans	View Question on Stackoverflow
Solution 1 - C++	Trevir	View Answer on Stackoverflow

what does this ... (three dots) means in c++

C++ Problem Overview

Edit 1

C++ Solutions

Solution 1 - C++

asp.net core app deployed on iis meets 500 internal server error

Build HashSet from a vector in Rust

Attributions