It is only evaluated once. The standard defines a range-based `for` statement as equivalent to:

    {
        auto &amp;&amp; __range = range-init;
        for ( auto __begin = begin-expr, __end = end-expr; __begin != __end; ++__begin ) {
            for-range-declaration = *__begin;
            statement
        }
    }

where `range-init` is the expression (surrounded by parentheses) or braced-init-list after the `:`

When you fork a repository on github your forked repo contains all branches and tags.

Over time these branches and tags gets outdated.

How does one as easy it is with fork make sure your fork has all branches and tags without having to reclone ?

i.e. a git magicpull --rebase upstream/* myremote/*

which would fetch all the branches and tags in upstream and make sure the same are present in myremote.


How to update my fork to have the same branches and tags as the original repository on github?

How would I hide the first element of an ng-repeat?

    &lt;div ng-repeat=&quot;item in items&quot; ng-hide=&quot;true&quot;&gt;
    	&lt;div&gt;{{ item.value }}&lt;/div&gt;
    &lt;/div&gt;

This works in that the whole ng-repeat block is hidden, but how would I hide only the first item in items? I want to display it completely differently using more prominent html/etc, so it&#39;s useful to have it in that list of data.

Angular JS hide first element of ng-repeat

    for(auto&amp; entity : memoryManager.getItems()) entity-&gt;update(mFrameTime);

If memoryManager contains 1000 items, does `memoryManager.getItems()` get called 1000 times or only one at the beginning of the loop?

Does the compiler run any optimization with -O2 (or -O3)?

(`memoryManager.getItems()` returns a `std::vector&lt;Entity*&gt;&amp;`)

Does a C++11 range-based for loop condition get evaluated every cycle?

<pre><code class="hljs language-scss">for(auto&#x26; entity : memoryManager.getItems()) entity->update(mFrameTime);
</code></pre>
If memoryManager contains 1000 items, does <code>memoryManager.getItems()</code> get called 1000 times or only one at the beginning of the loop?
Does the compiler run any optimization with -O2 (or -O3)?
(<code>memoryManager.getItems()</code> returns a <code>std::vector&#x3C;Entity*>&#x26;</code>)

I&#39;ve created a time point, but I have been struggling to print it to the terminal.

    #include &lt;iostream&gt;
    #include &lt;chrono&gt;
    
    int main(){
    
    	//set time_point to current time
    	std::chrono::time_point&lt;std::chrono::system_clock,std::chrono::nanoseconds&gt; time_point;
    	time_point = std::chrono::system_clock::now();
    
    	//print the time
    	//...
    	
    	return 0;
    }

The only documentation I can find that prints a time_point is found here:
http://en.cppreference.com/w/cpp/chrono/time_point

however, I&#39;m not even able to create a time_t based on my time_point(like the example).

    std::time_t now_c = std::chrono::system_clock::to_time_t(time_point); //does not compile

**Error:**

    /usr/lib/gcc/x86_64-redhat-linux/4.7.2/../../../../include/c++/4.7.2/chrono: In instantiation of ‘constexpr std::chrono::time_point&lt;_Clock, _Dur&gt;::time_point(const std::chrono::time_point&lt;_Clock, _Dur2&gt;&amp;) [with _Dur2 = std::chrono::duration&lt;long int, std::ratio&lt;1l, 1000000000l&gt; &gt;; _Clock = std::chrono::system_clock; _Dur = std::chrono::duration&lt;long int, std::ratio&lt;1l, 1000000l&gt; &gt;]’:
    time.cpp:13:69:   required from here
    /usr/lib/gcc/x86_64-redhat-linux/4.7.2/../../../../include/c++/4.7.2/chrono:540:32: error: no matching function for call to ‘std::chrono::duration&lt;long int, std::ratio&lt;1l, 1000000l&gt; &gt;::duration(std::chrono::time_point&lt;std::chrono::system_clock, std::chrono::duration&lt;long int, std::ratio&lt;1l, 1000000000l&gt; &gt; &gt;::duration)’
    /usr/lib/gcc/x86_64-redhat-linux/4.7.2/../../../../include/c++/4.7.2/chrono:540:32: note: candidates are:
    /usr/lib/gcc/x86_64-redhat-linux/4.7.2/../../../../include/c++/4.7.2/chrono:247:14: note: template&lt;class _Rep2, class _Period2, class&gt; constexpr std::chrono::duration::duration(const std::chrono::duration&lt;_Rep2, _Period2&gt;&amp;)
    /usr/lib/gcc/x86_64-redhat-linux/4.7.2/../../../../include/c++/4.7.2/chrono:247:14: note:   template argument deduction/substitution failed:
    /usr/lib/gcc/x86_64-redhat-linux/4.7.2/../../../../include/c++/4.7.2/chrono:243:46: error: no type named ‘type’ in ‘struct std::enable_if&lt;false, void&gt;’
    /usr/lib/gcc/x86_64-redhat-linux/4.7.2/../../../../include/c++/4.7.2/chrono:240:23: note: template&lt;class _Rep2, class&gt; constexpr std::chrono::duration::duration(const _Rep2&amp;)
    /usr/lib/gcc/x86_64-redhat-linux/4.7.2/../../../../include/c++/4.7.2/chrono:240:23: note:   template argument deduction/substitution failed:
    /usr/lib/gcc/x86_64-redhat-linux/4.7.2/../../../../include/c++/4.7.2/chrono:236:27: error: no type named ‘type’ in ‘struct std::enable_if&lt;false, void&gt;’
    /usr/lib/gcc/x86_64-redhat-linux/4.7.2/../../../../include/c++/4.7.2/chrono:234:12: note: constexpr std::chrono::duration&lt;_Rep, _Period&gt;::duration(const std::chrono::duration&lt;_Rep, _Period&gt;&amp;) [with _Rep = long int; _Period = std::ratio&lt;1l, 1000000l&gt;]
    /usr/lib/gcc/x86_64-redhat-linux/4.7.2/../../../../include/c++/4.7.2/chrono:234:12: note:   no known conversion for argument 1 from ‘std::chrono::time_point&lt;std::chrono::system_clock, std::chrono::duration&lt;long int, std::ratio&lt;1l, 1000000000l&gt; &gt; &gt;::duration {aka std::chrono::duration&lt;long int, std::ratio&lt;1l, 1000000000l&gt; &gt;}’ to ‘const std::chrono::duration&lt;long int, std::ratio&lt;1l, 1000000l&gt; &gt;&amp;’
    /usr/lib/gcc/x86_64-redhat-linux/4.7.2/../../../../include/c++/4.7.2/chrono:232:12: note: constexpr std::chrono::duration&lt;_Rep, _Period&gt;::duration() [with _Rep = long int; _Period = std::ratio&lt;1l, 1000000l&gt;]
    /usr/lib/gcc/x86_64-redhat-linux/4.7.2/../../../../include/c++/4.7.2/chrono:232:12: note:   candidate expects 0 arguments, 1 provided

How do you print a C++11 time_point?

    #include &lt;iostream&gt;
    #include &lt;stdio.h&gt; 
    using namespace std;
    
    // Base class
    class Shape 
    {
       public:
          void setWidth(int w)
          {
             width = w;
          }
          void setHeight(int h)
          {
             height = h;
          }
          Shape()
          {
    	printf(&quot;creating shape \n&quot;);
          }
          Shape(int h,int w)
          {
    	 height = h;
             width = w;
             printf(&quot;creatig shape with attributes\n&quot;);
          }	
       protected:
          int width;
          int height;
    };
    
    // Derived class
    class Rectangle: public Shape
    {
       public:
          int getArea()
          { 
             return (width * height); 
          }
          Rectangle()
          {
    	 printf(&quot;creating rectangle \n&quot;);
          }
          Rectangle(int h,int w)
          {
    	 printf(&quot;creating rectangle with attributes \n&quot;);
    	 height = h;
             width = w;
          }
    };
    
    int main(void)
    {
       Rectangle Rect;
       
       Rect.setWidth(5);
       Rect.setHeight(7);
    
       Rectangle *square = new Rectangle(5,5);
       // Print the area of the object.
       cout &lt;&lt; &quot;Total area: &quot; &lt;&lt; Rect.getArea() &lt;&lt; endl;
    
       return 0;
    }

The output of the program is given below


    creating shape 
    creating rectangle 
    creating shape 
    creating rectangle with attributes 
    Total area: 35

When constructing both the derived class objects I see that it is always the default constructor of the base class that is called first. Is there a reason for this? Is this the reason why languages like python insist on explicit calls of base class constructors rather than implicit calls like C++?


C++ calling base class constructors

I have a C++ vector. I want the vector to hold a variable number of objects. 

Visual Studio 2012 is giving me an error:  

    Error: type name is not allowed

From this C++ code:

    #include &lt;iostream&gt;
    #include &lt;vector&gt;
    using namespace std;
    
    class testObject{
    private:
       int someInt;
    public:
       testObject(int a){ someInt=a; }
       void show() { cout&lt;&lt;someInt&lt;&lt;endl; }
    };
    
    int main()
    {
        vector&lt;testObject&gt; testVector;
        cout &lt;&lt; &quot;Initial size: &quot; &lt;&lt; testVector.size() &lt;&lt;endl;
        
        for ( int i = 0; i &lt; 3; i++ )
            testVector.push_back(testObject(3));
        cout &lt;&lt; &quot;New size: &quot; &lt;&lt; testVector.size() &lt;&lt; endl;
        
        for ( int j = 0; j &lt; 3; j++ )
            testVector[ j ].show();
        
        system(&quot;pause&quot;);
    }    

But here&#39;s another sample of code that looks the same but it&#39;s not working.

    void Dealer::setNumberOfPlayers( const int tNumber )
    {
    	for ( int i = 0; i &lt; tNumber; i++ )
    		vectorOfGamers.push_back(Player); // Player is a class that I created
    }



Can I create vector to hold objects of Dealer, Bot and Player at the same time? How do I do that? As I know, all objects in vector should be of one type.

How can I create objects while adding them into a vector?

This question comes from answering Stack Overflow question *[Why do books say, “the compiler allocates space for variables in memory”?][1]*, where I tried to demonstrate to the OP what happens when you allocate a variable on the stack and how the compiler generates code that knows the size of memory to allocate. Apparently the compiler allocates much more space than what is needed.

However, when compiling the following

    #include &lt;iostream&gt;
    using namespace std;

    int main()
    {
        int foo;
        return 0;
    }

You get the following assembler output with Visual C++ 2012 compiled in debug mode with no optimisations on:

    int main()
    {
    00A31CC0  push        ebp
    00A31CC1  mov         ebp,esp
    00A31CC3  sub         esp,0CCh  // Allocates 204 bytes here.
    00A31CC9  push        ebx
    00A31CCA  push        esi
    00A31CCB  push        edi
    00A31CCC  lea         edi,[ebp-0CCh]
    00A31CD2  mov         ecx,33h
    00A31CD7  mov         eax,0CCCCCCCCh
    00A31CDC  rep stos    dword ptr es:[edi]
       int foo;
       return 0;
    00A31CDE  xor         eax,eax
    }

Adding one more `int` to my program makes the commented line above to the following:

    00B81CC3  sub         esp,0D8h // Allocate 216 bytes

The question raised by @JamesKanze in my answer linked atop, is why the compiler, and apparently it&#39;s not only Visual C++ (I haven&#39;t done the experiment with another compiler), allocated 204 and 216 bytes respectively, where in the first case it only needs four and in the second it needs only eight?

This program creates a 32-bit executable.

From a technical perspective, why may it need to allocate 204 bytes instead of just 4?

EDIT:

Calling two functions and creating a `double` and two `int` in main, you get

     01374493  sub         esp,0E8h  // 232 bytes

For the same program as the edit above, it does this in release mode (no optimizations):

     sub    esp, 8                // Two ints
     movsd  QWORD PTR [esp], xmm0 // I suspect this is where my `double` goes

  [1]: https://stackoverflow.com/a/15806010/174614


Why is so much space allocated on the stack?

How do you get Qt5 to download and integrate with Visual Studio 2012? What are some of the problems you will encounter, and how do you solve those problems?

**UPDATE re. Visual Studio 2013**

Successes are reported with Visual Studio 2013 as well, and the notes are being maintained for VS 2013.

Also note that **the focus of the question** is strongly on just *building* Qt with Visual Studio.  There are also notes about integrating with the Visual Studio IDE

Building Qt5 with Visual Studio 2012 / Visual Studio 2013, and integrating with the IDE

I&#39;m seeing some really strange perf related to a very simple query using Entity Framework Code-First with .NET framework version 4. The LINQ2Entities query looks like this:

     context.MyTables.Where(m =&gt; m.SomeStringProp == stringVar);

This takes over 3000 milliseconds to execute. The generated SQL looks very simple:

     SELECT [Extent1].[ID], [Extent1].[SomeStringProp], [Extent1].[SomeOtherProp],
     ...
     FROM [MyTable] as [Extent1]
     WHERE [Extent1].[SomeStringProp] = &#39;1234567890&#39;

This query runs almost instantaneously when run through Management Studio. When I change the C# code to use the SqlQuery function, it runs in 5-10 milliseconds:

     context.MyTables.SqlQuery(&quot;SELECT [Extent1].[ID] ... WHERE [Extent1].[SomeStringProp] = @param&quot;, stringVar);

So, exact same SQL, the resulting entities are change-tracked in both cases, but wild perf difference between the two. What gives?

Entity Framework query slow, but same SQL in SqlQuery is fast

I have a Java Application (web-based) that at times shows very high CPU Utilization (almost 90%) for several hours. Linux `TOP` command shows this. On application restart, the problem goes away.

***So to investigate***:

I take Thread Dump to find what threads are doing. Several Threads are found in `&#39;RUNNABLE&#39;` state, some in few other states. On taking repeated Thread Dumps, i do see some threads that are always present in `&#39;RUNNABLE&#39;` state. So, they appear to be the culprit.

But I am unable to tell for sure, which Thread is hogging the CPU or has gone into a infinite loop (thereby causing high CPU util).

Logs don&#39;t necessarily help, as the offending code may not be logging anything.

***How do I investigate - What part of the application or what-thread is causing High CPU Utilization? - Any other ideas?*** 


High CPU Utilization in java application - why?

How do you check if a boolean is null or not? So if I know &quot;hideInNav&quot; is null. How do I stop 
it from further executing? Something like the below doesn&#39;t seem to work but why? 

    boolean hideInNav = parent.getProperties().get(&quot;hideInNav&quot;, false);
    String hideNavigation = hideInNav != null ? hideInNav : &quot;&quot;;



Java check if boolean is null

Imagine the code:

    public class obj
    {
        // elided
    }
    
    public static Dictionary&lt;string, obj&gt; dict = new Dictionary&lt;string, obj&gt;();

**Method 1**

    public static obj FromDict1(string name)
    {
        if (dict.ContainsKey(name))
        {
            return dict[name];
        }
        return null;
    }

**Method 2**

    public static obj FromDict2(string name)
    {
        try
        {
            return dict[name];
        }
        catch (KeyNotFoundException)
        {
            return null;
        }
    }

I was curious if there is a difference in performance of these 2 functions, because the first one SHOULD be SLOWER than second one - given that it needs to check twice if the dictionary contains a value, while second function does need to access the dictionary only once but WOW, it&#39;s actually opposite:

Loop for 1 000 000 values (with 100 000 existing and 900 000 non existing):

&gt; first function: 306 milliseconds
&gt; 
&gt; second function: 20483 milliseconds

Why is that?

EDIT: As you can notice in comments below this question, the performance of second function is actually slightly better than first one in case there are 0 non existing keys. But once there is at least 1 or more non existing keys, the performance of second one decrease rapidly.

Why is it faster to check if dictionary contains the key, rather than catch the exception in case it doesn&#39;t?

I try computing **`Ackermann(4,1)`** and there&#39;s a big difference in performance between different languages/compilers. Below are results on my **Core i7 3820QM, 16G, Ubuntu 12.10 64bit**, 

**C: 1.6s**, `gcc -O3` *(with gcc 4.7.2)*

    int ack(int m, int n) {
      if (m == 0) return n+1;
      if (n == 0) return ack(m-1, 1);
      return ack(m-1, ack(m, n-1));
    }
    
    int main() {
      printf(&quot;%d\n&quot;, ack(4,1));
      return 0;
    }


**OCaml: 3.6s**, `ocamlopt` *(with ocaml 3.12.1)*

    let rec ack = function
      | 0,n -&gt; n+1
      | m,0 -&gt; ack (m-1, 1)
      | m,n -&gt; ack (m-1, ack (m, n-1))
    in print_int (ack (4, 1))


**Standard ML: 5.1s** `mlton -codegen c -cc-opt -O3` *(with mlton 20100608)*

    fun ack 0 n = n+1
      | ack m 0 = ack (m-1) 1
      | ack m n = ack (m-1) (ack m (n-1));
    print (Int.toString (ack 4 1));


**Racket: 11.5s** `racket` *(with racket v5.3.3)*

    (require racket/unsafe/ops)
    
    (define + unsafe-fx+)
    (define - unsafe-fx-)
    (define (ack m n)
      (cond
        [(zero? m) (+ n 1)]
        [(zero? n) (ack (- m 1) 1)]
        [else (ack (- m 1) (ack m (- n 1)))]))
    
    (time (ack 4 1))

&lt;strike&gt;**Haskell: unfinished**, killed by system after 22s `ghc -O2` *(with ghc 7.4.2)*&lt;/strike&gt;

**Haskell: 1.8s** `ajhc` *(with ajhc 0.8.0.4)*

    main = print $ ack 4 1
      where ack :: Int -&gt; Int -&gt; Int
            ack 0 n = n+1
            ack m 0 = ack (m-1) 1
            ack m n = ack (m-1) (ack m (n-1))


The Haskell version is the only one that fails to terminate properly because it takes too much memory. It freezes my machine and fills the swap space before getting killed.
What can I do to improve it without heavily fuglifying the code?

**EDIT**: I appreciate some of the asymptotically smarter solutions, but they are not exactly what I am asking for. This is more about seeing whether the compiler handles certain patterns in a reasonably efficient way (stack, tail calls, unboxing, etc.) than computing the ackermann function.

**EDIT 2**: As pointed out by several responses, this seems to be [a bug in recent versions of GHC][1]. I try the same code with [AJHC][2] and get much better performance.

Thank you very much :)


  [1]: http://hackage.haskell.org/trac/ghc/ticket/7850
  [2]: http://ajhc.metasepi.org/

Ackermann very inefficient with Haskell/GHC

I was just linting some JavaScript code using JSHint. In the code I have two for-loops both used like this: 

    for (var i = 0; i &lt; somevalue; i++) { ... }

So both for-loops use the var i for iteration.

Now JSHint shows me an error for the second for-loop: &quot;&#39;i&#39; is already defined&quot;. I can&#39;t say that this isn&#39;t true (because it obviously is) but I always thought this wouldn&#39;t matter as the var i is only used in that specific place. 

Is it bad practice to use for-loops this way? Should I use a different variable for each for-loop in my code like

    //for-loop 1
    for (var i = 0; ...; i++) { ... }
    
    //for-loop 2
    for (var j = 0; ...; j++) { ... }

Or is this on e of the errors I can ignore (because it doesn&#39;t break my code, it still does what it is supposed to do)?

JSLint btw. stops validating at the first for loop because I don&#39;t define var i at the top of the function (that&#39;s why I switched to JSHint in the first place). So according to the example in this question: https://stackoverflow.com/questions/6803305/should-i-use-jslint-or-jshint-javascript-validation/10763615#10763615 – I should use for-loops like this anyway to confirm JSLint: 

    ...
    var i;
    ...
    //for-loop 1
    for (i = 0; ...; i++) { ... }
    ...
    //for-loop 2
    for (i = 0; ...; i++) { ... }

This also looks good to me, because this way I should avoid both errors in JSLint and JSHint. But what I am uncertain about is if I should use a different variable for each for-loop like this: 

    ...
    var i, j;
    ...
    //for-loop 1
    for (i = 0; ...; i++) { ... }
    //for-loop 2
    for (j = 0; ...; j++) { ... }

So is there a best practice for this or could I just go with any of the codes above, meaning I choose &quot;my&quot; best practice?

Is it bad practice to use the same variable name in multiple for-loops?

Let&#39;s suppose I have these types:

    type Attribute struct {
        Key, Val string
    }
    type Node struct {
        Attr []Attribute
    }

and that I want to iterate on my node&#39;s attributes to change them.

I would have loved to be able to do:

    for _, attr := range n.Attr {
        if attr.Key == &quot;href&quot; {
            attr.Val = &quot;something&quot;
        }
    }

but as `attr` isn&#39;t a pointer, this wouldn&#39;t work and I have to do:

    for i, attr := range n.Attr {
        if attr.Key == &quot;href&quot; {
            n.Attr[i].Val = &quot;something&quot;
        }
    }

Is there a simpler or faster way? Is it possible to directly get pointers from `range`?

Obviously I don&#39;t want to change the structures just for the iteration and more verbose solutions are no solutions.

Change values while iterating

I have defined a JavaScript variables called `myData` which is a `new Array` like this:

    var myData = new Array([&#39;2013-01-22&#39;, 0], [&#39;2013-01-29&#39;, 0], [&#39;2013-02-05&#39;, 0],
                 [&#39;2013-02-12&#39;, 0], [&#39;2013-02-19&#39;, 0], [&#39;2013-02-26&#39;, 0], 
                 [&#39;2013-03-05&#39;, 0], [&#39;2013-03-12&#39;, 0], [&#39;2013-03-19&#39;, 0], 
                 [&#39;2013-03-26&#39;, 0], [&#39;2013-04-02&#39;, 21], [&#39;2013-04-09&#39;, 2]);

I am wondering if it is possible to sum the number values found in the array (ex. 0+0+21+2+0 and so on) and have probably a variable with the result that I can use outside of the script tag because I have 7 of this kind of arrays corresponding for each of the day in the week. I want to make a comparison afterwards based on that. That is the most preferred method for this kind of actions if is possible? 

Sum values from an array of key-value pairs in JavaScript

I want to implement a kind of jQuery live search.
But before sending the input to the server I&#39;d like to remove all items in my array which have 3 or less characters (because in the german language, those words usually can be ignored in terms of searching)
So `[&quot;this&quot;, &quot;is&quot;, &quot;a&quot;, &quot;test&quot;] ` becomes `[&quot;this&quot;, &quot;test&quot;] `

    $(document).ready(function() {
    var timer, searchInput;
	$(&#39;#searchFAQ&#39;).keyup(function() {
		clearTimeout(timer);
		timer = setTimeout(function() {
			searchInput = $(&#39;#searchFAQ&#39;).val().match(/\w+/g);
			if(searchInput) {
				for (var elem in searchInput) {
					if (searchInput[elem].length &lt; 4) {
						//remove those entries
						searchInput.splice(elem, 1);
					}
				}
				$(&#39;#output&#39;).text(searchInput);
                //ajax call here
			}
		}, 500);
    });
    });

Now my problem is that not all items get removed in my for loop. 
If I for example typ &quot;this is a test&quot; &quot;is&quot; gets removed, &quot;a&quot; stays.
[JSFIDDLE][1]

I think the problem is the for loop because the indexes of the array change if I remove an item with splice, so it goes on with the &quot;wrong&quot; index.

Perhaps anybody could help me out?

  [1]: http://jsfiddle.net/4Wdp9/

Remove items from array with splice in for loop

This works fine (means as expected) in C# 5.0:

    var actions = new List&lt;Action&gt;();
    foreach (var i in Enumerable.Range(0, 10))
    {
        actions.Add(() =&gt; Console.WriteLine(i));
    }
    foreach (var act in actions) act();

Prints 0 to 9. But this one shows 10 for 10 times:

    var actions = new List&lt;Action&gt;();
    for (var i = 0; i &lt; 10; i++)
    {
        actions.Add(() =&gt; Console.WriteLine(i));
    }
    foreach (var act in actions) act();

Question: This was a problem that we had in C# versions before 5.0; so we had to use a loop-local placeholder for the closure and it&#39;s fixed now - in C# 5.0 - in &quot;foreach&quot; loops. But not in &quot;for&quot; loops!

What is the reasoning behind this (not fixing the problem for `for` loops too)?

Captured Closure (Loop Variable) in C# 5.0

Being able to create and manipulate strings during compile-time in C++ has several useful applications. Although it is possible to create compile-time strings in C++, the process is very cumbersome, as the string needs to be declared as a variadic sequence of characters, e.g.

    using str = sequence&lt;&#39;H&#39;, &#39;e&#39;, &#39;l&#39;, &#39;l&#39;, &#39;o&#39;, &#39;,&#39;, &#39; &#39;, &#39;w&#39;, &#39;o&#39;, &#39;r&#39;, &#39;l&#39;, &#39;d&#39;, &#39;!&#39;&gt;;

Operations such as string concatenation, substring extraction, and many others, can easily be implemented as operations on sequences of characters. **Is it possible to declare compile-time strings more conveniently? If not, is there a proposal in the works that would allow for convenient declaration of compile-time strings?**

### Why Existing Approaches Fail

Ideally, we would like to be able to declare compile-time strings as follows:

    // Approach 1
    using str1 = sequence&lt;&quot;Hello, world!&quot;&gt;;

or, using user-defined literals,

    // Approach 2
    constexpr auto str2 = &quot;Hello, world!&quot;_s;

where `decltype(str2)` would have a `constexpr` constructor. A messier version of approach 1 is possible to implement, taking advantage of the fact that you can do the following:

    template &lt;unsigned Size, const char Array[Size]&gt;
    struct foo;

However, the array would need to have external linkage, so to get approach 1 to work, we would have to write something like this:

    /* Implementation of array to sequence goes here. */
    
    constexpr const char str[] = &quot;Hello, world!&quot;;
    
    int main()
    {
        using s = string&lt;13, str&gt;;
        return 0;
    }

Needless to say, this is very inconvenient. Approach 2 is actually not possible to implement. If we were to declare a (`constexpr`) literal operator, then how would we specify the return type? Since we need the operator to return a variadic sequence of characters, so we would need to use the `const char*` parameter to specify the return type:

    constexpr auto
    operator&quot;&quot; _s(const char* s, size_t n) -&gt; /* Some metafunction using `s` */

This results in a compile error, because `s` is not a `constexpr`. Trying to work around this by doing the following does not help much.

    template &lt;char... Ts&gt;
    constexpr sequence&lt;Ts...&gt; operator&quot;&quot; _s() { return {}; }

The standard dictates that this specific literal operator form is reserved for integer and floating-point types. While `123_s` would work, `abc_s` would not. What if we ditch user-defined literals altogether, and just use a regular `constexpr` function?

    template &lt;unsigned Size&gt;
    constexpr auto
    string(const char (&amp;array)[Size]) -&gt; /* Some metafunction using `array` */

As before, we run into the problem that the array, now a parameter to the `constexpr` function, is itself no longer a `constexpr` type.

I believe it should be possible to define a C preprocessor macro that takes a string and the size of the string as arguments, and returns a sequence consisting of the characters in the string (using `BOOST_PP_FOR`, stringification, array subscripts, and the like). However, I do not have the time (or enough interest) to implement such a macro =)

Conveniently Declaring Compile-Time Strings in C++

Given this C++11 program, should I expect to see a number or a letter?  Or not make expectations?

    #include &lt;cstdint&gt;
    #include &lt;iostream&gt;
    
    int main()
    {
        int8_t i = 65;
        std::cout &lt;&lt; i;
    }

Does the standard specify whether this type can or will be a character type?

Are int8_t and uint8_t intended to be char types?

What is the correct way of using C++11&#39;s range-based `for`?

What syntax should be used? `for (auto elem : container)`, 
or `for (auto&amp; elem : container)` or `for (const auto&amp; elem : container)`? 
Or some other?


What is the correct way of using C++11&#39;s range-based for?

Can/does the compiler inline lambda functions to increase efficiency, as it might with simple standard functions?

e.g.

    std::vector&lt;double&gt; vd;
    std::for_each(vd.begin(), vd.end(), [](const double d) {return d*d;});

Or is there loss of efficiency caused by lack of optimisation?

A second question: where I can check if the compiler I use has optimised calls of inline functions, which are sent to an algorithm? What I mean is, if a function—not a function object—is sent to an algorithm, the last one gets a pointer to the function, and some compilers optimize pointers to inline functions and others don&#39;t.

Are lambdas inlined like functions in C++?

How come the following prints boss and not bass? 

    String boss = &quot;boss&quot;;
    char[] array = boss.toCharArray();
 
    for(char c : array)
    {
     if (c== &#39;o&#39;)
         c = &#39;a&#39;; 
    }
    System.out.println(new String(array)); //How come this does NOT print out bass?It prints boss.

Why does the foreach statement not change the element value?

I was looking at some snippets of code, and I found multiple elements calling a function over a node list with a forEach applied to an empty array.

For example I have something like:

    [].forEach.call( document.querySelectorAll(&#39;a&#39;), function(el) {
       // whatever with the current node
    });

but I can&#39;t understand how it works. Can anyone explain me the behaviour of the empty array in front of the forEach and how the `call` works?

What does [].forEach.call() do in JavaScript?

I&#39;m new to C/C++ programming, but I&#39;ve been programming in C# for 1.5 years now. I like C# and I like the List class, so I thought about making a List class in C++ as an exercise.

    List&lt;int&gt; ls;
    int whatever = 123;
    ls.Add(1);
    ls.Add(235445);
    ls.Add(whatever);
    
The implementation is similar to any Array List class out there. I have a `T* vector` member where I store the items, and when this storage is about to be completely filled, I resize it. 

Please notice that this is not to be used in production, this is only an exercise. I&#39;m well aware of `vector&lt;T&gt;` and friends.

Now I want to loop through the items of my list. I don&#39;t like to use `for(int i=0;i&lt;n; i==)`. I typed `for` in the visual studio, awaited for Intellisense, and it suggested me this:
	
    for each (object var in collection_to_loop)
    {

    }        

This obviously won&#39;t work with my List implementation. I figured I could do some macro magic, but this feels like a huge hack. Actually, what bothers me the most is passing the type like that:
      
    #define foreach(type, var, list)\
    int _i_ = 0;\
    ##type var;\
    for (_i_ = 0, var=list[_i_]; _i_&lt;list.Length();_i_++,var=list[_i_]) 

    foreach(int,i,ls){
        doWork(i);
    }

My question is: is there a way to make this custom List class work with a `foreach-like` loop?

Content Type	Original Author	Original Content on Stackoverflow
Question	Vittorio Romeo	View Question on Stackoverflow
Solution 1 - C++	Mike Seymour	View Answer on Stackoverflow

Does a C++11 range-based for loop condition get evaluated every cycle?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Angular JS hide first element of ng-repeat

How to update my fork to have the same branches and tags as the original repository on github?

Attributions