The object here is an instance of [`std::initializer_list&lt;int&gt;`][1]. From the reference (emphasis mine):

&gt; A std::initializer_list object is automatically constructed when:
&gt;
&gt; a braced-init-list is used to list-initialize an object, where the corresponding constructor accepts an std::initializer_list parameter
&gt;
&gt; a braced-init-list is used as the right operand of assignment or as a function call argument, and the corresponding assignment operator/function accepts an std::initializer_list parameter
&gt;
&gt; a braced-init-list is bound to auto, including **in a ranged for loop**


  [1]: https://en.cppreference.com/w/cpp/utility/initializer_list

&gt; What is the temporary {1,2,3,4,5} in the for loop behind the scenes?

a [`std::initializer_list&lt;int&gt;`](https://en.cppreference.com/w/cpp/utility/initializer_list)

When I tried to read a pickle file that saved by a former version of pandas, it yielded an `ImportError`.

&gt; ImportError: No module named &#39;pandas.core.internals.managers&#39;;
&gt; &#39;pandas.core.internals&#39; is not a package

There was no hit on stackoverflow so i would like to share my solution for this particular problem.

ImportError: No module named &#39;pandas.core.internals.managers&#39;; &#39;pandas.core.internals&#39; is not a package

i&#39;m trying to emit function with parameters like that.

    template: `
        &lt;div class=&quot;searchDropDown&quot;&gt;
        &lt;div class=&quot;dropdown is-active&quot;&gt;
        &lt;div class=&quot;dropdown-trigger&quot;&gt;
          &lt;button class=&quot;button&quot; aria-haspopup=&quot;true&quot; aria-controls=&quot;dropdown-menu&quot;&gt;
            &lt;span&gt;{{selectedItem}}&lt;/span&gt;
          &lt;/button&gt;
        &lt;/div&gt;
        &lt;div class=&quot;dropdown-menu&quot; id=&quot;dropdown-menu&quot; role=&quot;menu&quot;&gt;
          &lt;div class=&quot;dropdown-content&quot;&gt;
            &lt;a class=&quot;dropdown-item&quot; v-for=&quot;item in drop&quot; @click=&quot;$emit(&#39;select-menu-item($event)&#39;)&quot;&gt;
              {{item.name}}
            &lt;/a&gt;
          &lt;/div&gt;
        &lt;/div&gt;
      &lt;/div&gt;
        &lt;/div&gt;
      `

here is the i&#39;m trying to pass item to method like a parameter.

here is my component which i try to emit function: 

    &lt;search-component v-bind=&quot;searchProps&quot; @select-menu-item=&quot;selectedITem($event)&quot;&gt;&lt;/search-component&gt;

and here is my method: 

    selectedITem(arg1) {
          console.log(&quot;cl&quot;)
          console.log(arg1)
        }


here is if i&#39;m not trying to pass parameter everything well work so my method **selectedITem** is working. When i try to pass parameter like that nothing happened and i&#39;m not getting some error.

Emit event with parameters in vue

I am studying C++ and I saw a range-based `for` loop like this:

    for (int i : {1,2,3,4,5})
        std::cout &lt;&lt; i &lt;&lt; &#39; &#39;;

What is the temporary `{1,2,3,4,5}` in the for loop behind the scenes?




What is the following list of behind the scenes inside the range-based for loop?

I am studying C++ and I saw a range-based <code>for</code> loop like this:
<pre><code class="hljs language-c">for (int i : {1,2,3,4,5})
 std::cout &#x3C;&#x3C; i &#x3C;&#x3C; ' ';
</code></pre>
What is the temporary <code>{1,2,3,4,5}</code> in the for loop behind the scenes?

&lt;!-- language: cxx --&gt;

    template &lt;typename CRTP&gt;
    struct Pre {
        CRTP &amp; operator++();
    };

    template &lt;typename CRTP&gt;
    struct Post {
        CRTP operator++(int);
    };

    struct Derived
        : Pre&lt;Derived&gt;
        , Post&lt;Derived&gt;
    {};

    int main() {
        Derived d;
        d++;
        ++d;
    }
    
I get these errors from GCC:

&lt;!-- language: none --&gt;

    &lt;source&gt;: In function &#39;int main()&#39;:
    &lt;source&gt;:18:10: error: request for member &#39;operator++&#39; is ambiguous
            d++;
            ^~
    &lt;source&gt;:8:14: note: candidates are: CRTP Post&lt;CRTP&gt;::operator++(int) [with CRTP = Derived]
            CRTP operator++(int);
                ^~~~~~~~
    &lt;source&gt;:3:16: note:                 CRTP&amp; Pre&lt;CRTP&gt;::operator++() [with CRTP = Derived]
            CRTP &amp; operator++();
                    ^~~~~~~~
    &lt;source&gt;:19:11: error: request for member &#39;operator++&#39; is ambiguous
            ++d;
            ^
    &lt;source&gt;:8:14: note: candidates are: CRTP Post&lt;CRTP&gt;::operator++(int) [with CRTP = Derived]
            CRTP operator++(int);
                ^~~~~~~~
    &lt;source&gt;:3:16: note:                 CRTP&amp; Pre&lt;CRTP&gt;::operator++() [with CRTP = Derived]
            CRTP &amp; operator++();
                    ^~~~~~~~

Pre-decrement and post-decrement operators cause similar errors. No such errors with Clang. Any ideas what could be wrong or how to work around this?

GCC can&#39;t differentiate between operator++() and operator++(int)

I know that an *&quot;undefined behaviour&quot;* in C++ can pretty much allow the compiler to do anything it wants. However, I had a crash that surprised me, as I assumed that the code was safe enough.

In this case, the real problem happened only on a specific platform using a specific compiler, and only if optimization was enabled.

I tried several things in order to reproduce the problem and simplify it to the maximum. Here&#39;s an extract of a function called `Serialize`, that would take a bool parameter, and copy the string `true` or `false` to an existing destination buffer.

Would this function be in a code review, there would be no way to tell that it, in fact, could crash if the bool parameter was an uninitialized value?

    // Zero-filled global buffer of 16 characters
    char destBuffer[16];
    
    void Serialize(bool boolValue) {
        // Determine which string to print based on boolValue
        const char* whichString = boolValue ? &quot;true&quot; : &quot;false&quot;;
        
        // Compute the length of the string we selected
        const size_t len = strlen(whichString);
        
        // Copy string into destination buffer, which is zero-filled (thus already null-terminated)
        memcpy(destBuffer, whichString, len);
    }

If this code is executed with clang 5.0.0 + optimizations, it will/can crash.

The expected ternary-operator `boolValue ? &quot;true&quot; : &quot;false&quot;` looked safe enough for me, I was assuming, &quot;Whatever garbage value is in `boolValue` doesn&#39;t matter, since it will evaluate to true or false anyhow.&quot;

I have setup a [Compiler Explorer example](https://godbolt.org/z/DoFmhA) that shows the problem in the disassembly, here the complete example. *Note: in order to repro the issue, the combination I&#39;ve found that worked is by using Clang 5.0.0 with -O2 optimisation.*

    #include &lt;iostream&gt;
    #include &lt;cstring&gt;
    
    // Simple struct, with an empty constructor that doesn&#39;t initialize anything
    struct FStruct {
        bool uninitializedBool;
        
       __attribute__ ((noinline))  // Note: the constructor must be declared noinline to trigger the problem
       FStruct() {};
    };
    
    char destBuffer[16];
    
    // Small utility function that allocates and returns a string &quot;true&quot; or &quot;false&quot; depending on the value of the parameter
    void Serialize(bool boolValue) {
        // Determine which string to print depending if &#39;boolValue&#39; is evaluated as true or false
        const char* whichString = boolValue ? &quot;true&quot; : &quot;false&quot;;
        
        // Compute the length of the string we selected
        size_t len = strlen(whichString);
        
        memcpy(destBuffer, whichString, len);
    }
    
    int main()
    {
        // Locally construct an instance of our struct here on the stack. The bool member uninitializedBool is uninitialized.
        FStruct structInstance;
        
        // Output &quot;true&quot; or &quot;false&quot; to stdout
        Serialize(structInstance.uninitializedBool);
        return 0;
    }

The problem arises because of the optimizer: It was clever enough to deduce that the strings &quot;true&quot; and &quot;false&quot; only differs in length by 1. So instead of really calculating the length, it uses the value of the bool itself, which *should* technically be either 0 or 1, and goes like this:

    const size_t len = strlen(whichString); // original code
    const size_t len = 5 - boolValue;       // clang clever optimization

While this is &quot;clever&quot;, so to speak, my question is: **Does the C++ standard allow a compiler to assume a bool can only have an internal numerical representation of &#39;0&#39; or &#39;1&#39; and use it in such a way?**

Or is this a case of implementation-defined, in which case the implementation assumed that all its bools will only ever contain 0 or 1, and any other value is undefined behaviour territory?

Does the C++ standard allow for an uninitialized bool to crash a program?

[tag:c++14] introduced generic lambdas that made it possible to write following:

    auto func = [](auto a, auto b){
        return a + b;
    };
    auto Foo = func(2, 5);
    auto Bar = func(&quot;hello&quot;, &quot;world&quot;);

It is very clear that this generic lambda `func` works just like a templated function `func` would work.

Why did the C++ committee decide to add template syntax for generic lamda?



What is the need of template lambda introduced in C++20 when C++14 already has generic lambda?

One of the corners of C++20 concepts is that there are certain situations in which you have to write `requires requires`. For instance, this example from [\[expr.prim.req\]/3](http://eel.is/c++draft/expr#prim.req-3):

&gt; A _requires-expression_ can also be used in a _requires-clause_ ([temp]) as a way of writing ad hoc constraints on template arguments such as the one below:
&gt;
&gt; 
    template&lt;typename T&gt;
      requires requires (T x) { x + x; }
        T add(T a, T b) { return a + b; }

&gt; The first requires introduces the _requires-clause_, and the second introduces the _requires-expression_. 

What is the technical reason behind needing that second `requires` keyword? Why can&#39;t we just allow writing:

    template&lt;typename T&gt;
      requires (T x) { x + x; }
        T add(T a, T b) { return a + b; }

&lt;sub&gt;(Note: please don&#39;t answer that the grammar `requires` it)&lt;/sub&gt;

Why do we require requires requires?

According to the accepted (and only) answer for [this Stack Overflow question](https://stackoverflow.com/questions/48809894/c-zero-initialization),

&gt; Defining the constructor with
&gt; 
&gt;     MyTest() = default;
&gt; 
&gt; will instead zero-initialize the object.

Then why does the following, 

    #include &lt;iostream&gt;
    
    struct foo {
        foo() = default;
        int a;
    };
    
    struct bar {
        bar();
        int b;
    };
    
    bar::bar() = default;
    
    int main() {
        foo a{};
        bar b{};
        std::cout &lt;&lt; a.a &lt;&lt; &#39; &#39; &lt;&lt; b.b;
    }

produce this output:

    0 32766

Both constructors defined are default? Right? And for POD types, the default initialization is zero-initialization. 

And according to the accepted answer for [this question](https://stackoverflow.com/questions/28105256/class-pod-members-default-initialization-vs-zero-initialization-vs-no-initiali?rq=1),

&gt; 2. If a POD member is not initialized in the constructor nor via C++11
&gt; in-class initialization, it is default-initialized.
&gt; 
&gt; 3. The answer is the same regardless of stack or heap.
&gt; 
&gt; 4. In C++98 (and not afterward), new int() was specified as performing
&gt; zero initialization.

Despite trying to wrap my (albeit *tiny*) head around [default constructors](https://en.cppreference.com/w/cpp/language/default_constructor) and [default initialization](https://en.cppreference.com/w/cpp/language/default_initialization), I couldn&#39;t come up with an explanation.

C++ zero initialization - Why is `b` in this program uninitialized, but `a` is initialized?

In a for loop, what is the difference between looping with pairs() and ipairs()? This page uses both: [Lua Docs][1]

With ipairs():

    a = {&quot;one&quot;, &quot;two&quot;, &quot;three&quot;}
    for i, v in ipairs(a) do
      print(i, v)
    end

Result:
  
    1	one
    2	two
    3	three


With pairs():

    a = {&quot;one&quot;, &quot;two&quot;, &quot;three&quot;}
    for i, v in pairs(a) do
      print(i, v)
    end

Result: 

    1	one
    2	two
    3	three


You can test it here: [Lua Demo][2]


  [1]: https://www.lua.org/pil/4.3.5.html &quot;Lua Docs&quot;
  [2]: https://www.lua.org/cgi-bin/demo

What is the difference of pairs() vs. ipairs() in Lua?

I have the following code:

    a = [0,1,2,3]

    for a[-1] in a:
      print(a[-1])

The output is:

    0
    1
    2
    2

I&#39;m confused about why a list index can be used as an indexing variable in a for loop.


Why can I use a list index as an indexing variable in a for loop?

I recently answered a [question on a sister site][1] which asked for a function that counts all even digits of a number. One of the [other answers][2] contained two functions (which turned out to be the fastest, so far):

    def count_even_digits_spyr03_for(n):
        count = 0
        for c in str(n):
            if c in &quot;02468&quot;:
                count += 1
        return count
    
    def count_even_digits_spyr03_sum(n):
        return sum(c in &quot;02468&quot; for c in str(n))

In addition I looked at using a list comprehension and `list.count`:

    def count_even_digits_spyr03_list(n):
        return [c in &quot;02468&quot; for c in str(n)].count(True)


The first two functions are essentially the same, except that the first one uses an explicit counting loop, while the second one uses the built-in `sum`. I would have expected the second one to be faster (based on e.g. [this answer][3]), and it is what I would have recommended turning the former into if asked for a review. But, it turns out it is the other way around. Testing it with some random numbers with increasing number of digits (so the chance that any single digit is even is about 50%) I get the following timings:

[![enter image description here][4]][4]

**Why is the manual `for` loop so much faster?** It&#39;s almost a factor two faster than using `sum`. And since the built-in `sum` should be about five times faster than manually summing a list (as per [the linked answer][3]), it means that it is actually ten times faster! Is the saving from only having to add one to the counter for half the values, because the other half gets discarded, enough to explain this difference?


----------

Using an `if` as a filter like so:

    def count_even_digits_spyr03_sum2(n):
        return sum(1 for c in str(n) if c in &quot;02468&quot;)

Improves the timing only to the same level as the list comprehension.


----------

When extending the timings to larger numbers, and normalizing to the `for` loop timing, they asymptotically converge for very large numbers (&gt;10k digits), probably due to the time `str(n)` takes:

[![enter image description here][5]][5]


  [1]: https://codereview.stackexchange.com/q/220824/98493
  [2]: https://codereview.stackexchange.com/a/220841/98493
  [3]: https://stackoverflow.com/a/24578976/4042267
  [4]: https://i.stack.imgur.com/BbVC2.png
  [5]: https://i.stack.imgur.com/aIhuN.png

Why is a `for` loop so much faster to count True values?

I was looking over some ugly code (that was modifying the underlying sequence while iterating), and to explore the definition of the range-based `for` loop, I went to [cppreference][1]. 

There I noticed something strange:

The range based `for` loop changed in C++17, but I do not see the reason for the change, and the code looks the same to me (just &quot;refactored&quot;).
So the old one was:

    {
      auto &amp;&amp; __range = range_expression;
      for (auto __begin = begin_expr, __end = end_expr; __begin != __end; ++__begin) {
        range_declaration = *__begin;
        loop_statement
      }
    } 

The new one is

    {
      auto &amp;&amp; __range = range_expression;
      auto __begin = begin_expr;
      auto __end = end_expr;
      for ( ; __begin != __end; ++__begin) {
        range_declaration = *__begin;
        loop_statement
      }
    } 

Why was this change made, and does it make any legal C++14 programs exhibit undefined behavior ([UB][2]) in C++17?

  [1]: https://en.cppreference.com/w/cpp/language/range-for
  [2]: https://stackoverflow.com/questions/2766731/what-exactly-do-ib-and-ub-mean



Why did the range based &#39;for&#39; loop specification change in C++17?

Consider a standard for loop:

```
for (int i = 0; i &lt; 10; ++i) 
{
   // do something with i
}
```

I want to prevent the variable `i` from being modified in the body of the `for` loop. 

However, I cannot declare `i` as `const` as this makes the increment statement invalid. Is there a way to make `i` a `const` variable outside of the increment statement?


Content Type	Original Author	Original Content on Stackoverflow
Question	Hamza.S	View Question on Stackoverflow
Solution 1 - C++	taskinoor	View Answer on Stackoverflow
Solution 2 - C++	Jarod42	View Answer on Stackoverflow

What is the following list of behind the scenes inside the range-based for loop?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Emit event with parameters in vue

ImportError: No module named 'pandas.core.internals.managers'; 'pandas.core.internals' is not a package

Attributions