It may be used for call chaining like:

    char a[200];
    strcpy(memset(a, 0, 200), &quot;bla&quot;);

The signature is in line with all the other similar functions: `memcpy()`, `strcpy()` etc. I always thought this was done to enable one to chain calls to such functions, and to otherwise use such calls in expressions.

That said, I&#39;ve never come across a real-world situation where I would feel compelled to use the return value in such a manner.

In order to use the function as an argument for another function such as `sprintf`

I came across this question when Googling to see what memset returned.

I have some code where I test for one value, then if that is true test to see if a value is zeros.

Because there is no completely portable way in C to test for zeros I have to run memset in the middle.

So my code is:

    if ( a==true &amp;&amp; (memcmp(memset(zeros, 0, sizeof(zeros)), b, sizeof(zeros)) == 0) )

This speaks to the chaining purpose listed in the previous questions, but it is an example of a use for this technique.

I&#39;ll leave it to others to judge if this is good coding or not.

I&#39;m adding the Joda Time repository to SBT with

    libraryDependencies ++= Seq(
      &quot;joda-time&quot;         % &quot;joda-time&quot;           % &quot;2.1&quot;
    )

Then I merrily use it like this:

     val ymd = org.joda.time.format.DateTimeFormat.forPattern(&quot;yyyyMMdd&quot;)
      ymd.parseDateTime(&quot;20121212&quot;)

But, when I compile the project in SBT, I get a nasty:

    [warn] Class org.joda.convert.FromString not found - continuing with a stub.
    [warn] Caught: java.lang.NullPointerException while parsing annotations in /home/jack/.ivy2/cache/joda-time/joda-time/jars/joda-time-2.1.jar(org/joda/time/DateTime.class)
    [error] error while loading DateTime, class file &#39;/home/jack/.ivy2/cache/joda-time/joda-time/jars/joda-time-2.1.jar(org/joda/time/DateTime.class)&#39; is broken
    [error] (class java.lang.RuntimeException/bad constant pool tag 10 at byte 42)

I tried the 2.0 version of joda-time, but get the same error.


Class broken error with Joda Time using Scala

I&#39;m wondering if there are any differences between `MemoryCache` and `HttpRuntime.Cache`, which one is preferred in ASP.NET MVC projects?

As far as I understand, both are thread safe, API is from first sight more or less the same, so is there any difference when to use which?

System.Runtime.Caching.MemoryCache vs HttpRuntime.Cache - are there any differences?

`memset()` is declared to return `void*` that is always the same value as the address passed into the function.

What&#39;s the use of the return value? Why does it not return `void`?

What&#39;s the use of memset() return value?

<p><code>memset()</code> is declared to return <code>void*</code> that is always the same value as the address passed into the function.</p>
<p>What's the use of the return value? Why does it not return <code>void</code>?</p>


In his book `The C++ Standard Library (Second Edition)` Nicolai Josuttis states that lambdas can be better optimized by the compiler than plain functions.

&gt; In addition, C++ compilers optimize lambdas better than they do
&gt; ordinary functions.
(Page 213)

Why is that? 

I thought when it comes to inlining there shouldn&#39;t be any difference any more. The only reason I could think of is that compilers might have a better local context with lambdas and such can make more assumptions and perform more optimizations. 

Why can lambdas be better optimized by the compiler than plain functions?

The following link provides the 4 forms of reference collapsing (if I&#39;m correct that these are the only 4 forms): http://thbecker.net/articles/rvalue_references/section_08.html.

From the link:

&gt;  1. A&amp; &amp; becomes A&amp;    
&gt;  2. A&amp; &amp;&amp; becomes A&amp;
&gt;  3. A&amp;&amp; &amp; becomes A&amp;
&gt;  4. A&amp;&amp; &amp;&amp; becomes A&amp;&amp;

Although I can make an educated guess, I would like a concise explanation for the rationale behind each of these reference-collapsing rules.

A related question, if I might: Are these reference-collapsing rules utilized **in C++11** internally by such STL utilities such as `std::move()`, `std::forward()`, and the like, in typical real-world use cases?  (Note: I&#39;m specifically asking whether the reference-collapsing rules are utilized in C++11, as opposed to C++03 or earlier.)

I ask this related question because I am aware of such C++11 utilities as `std::remove_reference`, but I do not know if the reference-related utilities such as `std::remove_reference` are routinely used in C++11 to *avoid need for* the reference-collapsing rules, or whether they are used *in conjunction with* the reference-collapsing rules.

Concise explanation of reference collapsing rules requested: (1) A&amp; &amp; -&gt; A&amp; , (2) A&amp; &amp;&amp; -&gt; A&amp; , (3) A&amp;&amp; &amp; -&gt; A&amp; , and (4) A&amp;&amp; &amp;&amp; -&gt; A&amp;&amp;

&gt; **Possible Duplicate:**  
&gt; [Why would I prefer using vector to deque](https://stackoverflow.com/questions/5345152/why-would-i-prefer-using-vector-to-deque)  

&lt;!-- End of automatically inserted text --&gt;

I am curious why is it that [`std::vector`](http://en.cppreference.com/w/cpp/container/vector) is so much more popular than [`std::deque`](http://en.cppreference.com/w/cpp/container/deque). Deque is almost as efficient in lookup, more efficient in insert (without vector::reserve)and allows for inserting/deleting in the front. 

Herb Sutter once recommended that [if you want to use vector, just prefer deque](http://www.gotw.ca/gotw/054.htm) (I am paraphrasing). However in a recent talk on [Writing Modern C++](http://channel9.msdn.com/Events/Build/BUILD2011/TOOL-835T) he again strongly recommends thinking of `std::vector` as a default container. According to the [GOTW](http://www.gotw.ca/gotw/054.htm) I linked earlier, even the standard has similar wording. 

Is there a reason for this disparity? Is it just that `vector` is simpler and more well known, or is there a technical reason? Or is it that `vector` is just a cooler name .. ?

Why is std::vector so much more popular than std::deque?

I use mingw from here: `http://sourceforge.net/projects/mingwbuilds/files/host-windows/releases/4.7.2/32-bit/threads-posix/sjlj/x32-4.7.2-release-posix-sjlj-rev2.7z/download`

And I&#39;ve sucessfully managed to link statically `libstdc++-6.dll` and `libgcc_s_sjlj-1.dll` by using `-static-libgcc -static-libstdc++` parameters, but I cannot find a command for doing the same with `libwinpthread-1.dll`.

how to do static linking of libwinpthread-1.dll in mingw?

**Updated**(for clarity and to reduce ambiguity):

I&#39;m going to start tinkering around with android apps.  I was planning on writing the in C++ using the NDK (since I have more experience in C++ and prefer it to Java) but came across the following on the [Android NDK page][1]:

&gt; you should only use the NDK if it is essential to your
&gt; app—**never because you simply prefer to program in C/C++.**

I was under the impression that you should use the language that you prefer, as long as it fits the job.  Could somebody explain why it is so heavily advised not to use C/C++ for android development?

---
**Original:**

I&#39;m going to start tinkering around with mobile apps, specifically android which is the OS of my current phone, and I was wondering if writing the app in C++ (or at least the core, then wrapping in Java) was an acceptable option.  

Some background, I&#39;m a computer science major who has taken 3 C++ courses(intro, intermediate, OOP, and am taking an STL course in the spring) and only 1 Java course(intermediate).  Because of this, I am more comfortable with C++ and prefer it to Java.  I came across the following on the [Android NDK page][1]:

&gt; Using native code on Android generally does not result in a noticeable
&gt; performance improvement, but it always increases your app complexity.
&gt; In general, you should only use the NDK if it is essential to your
&gt; app—**never because you simply prefer to program in C/C++.**

 - I was under the impression that you should use the language the fits
   the job as well as one you&#39;re familiar with
 - I may want to port the application to another mobile platform, such
   as iOS, that supports C++ but not java
 - While Java is a high level language and thus should make development
   faster, I feel like development would be slower because I would have
   to relearn almost everything (since I have only taken one class on
   the language)

Any advice would be much appreciate.


ps: many of the answers on this subject are from years ago and there are very few follow up answers that mention the NDK allowing the development of full native apps on android 2.3 and newer.

  [1]: http://developer.android.com/tools/sdk/ndk/index.html#Installing

Why shouldn&#39;t an Android app be written in C/C++ because you &quot;simply prefer to program in C/C++&quot;?

I try to read-in 2 values using scanf() in C, but the values the system writes into memory are not equal to my entered values. Here is the code:

    double a,b;
    printf(&quot;--------\n&quot;); //seperate lines
    scanf(&quot;%ld&quot;,&amp;a);
    printf(&quot;--------\n&quot;); 
    scanf(&quot;%ld&quot;,&amp;b);
    printf(&quot;%d %d&quot;,a,b);

If I enter 1 and 2, CMD returns a correct, but b = -858993460 Here is what I already tried:
using float or int instead of double, using scanf_s, using scanf(&quot;%d or %f for %i or %li or %lf or %e or %g ), using fflush(stdin) to clear keyboard buffer, reading in b first, trying like all possible combinations. I found out that there is a problem with the length of double on 32 bit OS, so that you are forced to use scanf(&quot;%lf&quot;, &amp;f) to read in a double. No matter what I do, second value is always wrong.

I use MS VS express 2012 for Desktop on Windows 7 32 bit OS.

Reading in double values with scanf in c

What is the difference in OpenMP between :

    #pragma omp parallel sections
    {
        #pragma omp section
        {
           fct1();
        }
        #pragma omp section
        {
           fct2();
        }
    }

and : 

    #pragma omp parallel 
    {
        #pragma omp single
        {
           #pragma omp task
           fct1();
           #pragma omp task
           fct2();
        }
    }

I&#39;m not sure that the second code is correct...

Difference between section and task openmp

Say we have a macro like this 

    #define FOO(type,name) type name
Which we could use like

    FOO(int, int_var);

But not always as simply as that:

    FOO(std::map&lt;int, int&gt;, map_var); // error: macro &quot;FOO&quot; passed 3 arguments, but takes just 2

Of course we could do:

     typedef std::map&lt;int, int&gt; map_int_int_t;
     FOO(map_int_int_t, map_var); // OK

which is not very ergonomic. Plus type incompatibilities have to be dealt with. Any idea how to resolve this with macro ?





Comma in C/C++ macro

&gt; **Possible Duplicate:**  
&gt; [Why doesn’t a+++++b work in C?](https://stackoverflow.com/questions/5341202/why-doesnt-ab-work-in-c)  

&lt;!-- End of automatically inserted text --&gt;

I got this from page 113 on the &quot;An Embedded Software Primer&quot; by David Simon. 


I saw this statement below:
 
 
    iHoursTemp = iHoursTemp + iZoneNew ---iZoneOld;
 
 
Can you really have three minus signs in this line? What does a triple minus sign mean?
 

I believe it is a C programming statement.





Can you have a triple minus signs in C programming? What does it mean?

In my project we have a piece of code like this: 

~~~c++
// raw data consists of 4 ints
unsigned char data[16];
int i1, i2, i3, i4;
i1 = *((int*)data);
i2 = *((int*)(data + 4));
i3 = *((int*)(data + 8));
i4 = *((int*)(data + 12));
~~~

I talked to my tech lead that this code may not be portable since it&#39;s trying to cast a `unsigned char*` to a `int*` which usually has a more strict alignment requirement. But tech lead says that&#39;s all right, most compilers remains the same pointer value after casting, and I can just write the code like this.

To be frank, I&#39;m not really convinced. After researching, I find some people against use of pointer castings like above, e.g., [here][1] and [here][2].

So here are my questions:

 1. Is it REALLY safe to dereference the pointer after casting in a real project?
 2. Is there any difference between C-style casting and `reinterpret_cast`?
 3. Is there any difference between C and C++?


  [1]: https://www.securecoding.cert.org/confluence/display/cplusplus/EXP36-CPP.+Do+not+convert+pointers+into+more+strictly+aligned+pointer+types
  [2]: http://www.informit.com/guides/content.aspx?g=cplusplus&amp;seqNum=548

Should I worry about the alignment during pointer casting?

In a Systems Programming class I took this previous semester, we had to implement a basic client/server in C.  When initializing the structs, like `sock_addr_in`, or char buffers (that we used to send data back and forth between client and server) the professor instructed us to only use `bzero` and not `memset` to initialize them.  He never explained why, and I&#39;m curious if there is a valid reason for this?

I see here: http://fdiv.net/2009/01/14/memset-vs-bzero-ultimate-showdown that `bzero` is more efficient due to the fact that is only ever going to be zeroing memory, so it doesn&#39;t have to do any additional checking that `memset` may do.  That still doesn&#39;t necessarily seem like a reason to absolutely not use `memset` for zeroing memory though.

`bzero` is considered deprecated, and furthermore is a not a standard C function. According to the manual, `memset` is preferred over `bzero` for this reason.  So why would you want to still use `bzero` over `memset`?  Just for the efficiency gains, or is it something more?  Likewise, what are the benefits of `memset` over `bzero` that make it the de facto preferred option for newer programs?

Why use bzero over memset?

The [manpage](http://linux.die.net/man/3/memset) says about `memset`: 
&gt; 
    #include &lt;string.h&gt;
    void *memset(void *s, int c, size_t n)
&gt;The `memset()` function fills the first `n` **bytes** of the memory area pointed to by `s` with the constant byte `c`.   

It is obvious that `memset` can&#39;t be used to initialize `int` array as shown below:  

    int a[10];
    memset(a, 1, sizeof(a));  
it is because `int` is represented by 4 bytes (say) and one can not get the desired value for the integers in array `a`.  
But I often see the programmers use  `memset` to set the `int` array elements to either `0` or `-1`.  

    int a[10];
    int b[10];
    memset(a, 0, sizeof(a));  
    memset(b, -1, sizeof(b));  
As per my understanding, initializing with integer `0` is OK because `0` can be represented in 1 byte (may be I am wrong in this context). But how is it possible to initialize `b` with `-1` (a 4 bytes value)?   

How memset initializes an array of integers by -1?

I have observed on a system that `std::fill` on a large `std::vector&lt;int&gt;` was significantly and consistently slower when setting a constant value `0` compared to a constant value `1` or a dynamic value:

**5.8 GiB/s vs 7.5 GiB/s**

However, the results are different for smaller data sizes, where `fill(0)` is faster:

[![performance for single thread at different data sizes][1]][1]

With more than one thread, at 4 GiB data size, `fill(1)` shows a higher slope, but reaches a much lower peak than `fill(0)` (51 GiB/s vs 90 GiB/s):

[![performance for various thread counts at large data size][2]][2]

This raises the secondary question, why the peak bandwidth of `fill(1)` is so much lower.

The test system for this was a dual socket Intel Xeon CPU E5-2680 v3 set at 2.5 GHz (via `/sys/cpufreq`) with 8x16 GiB DDR4-2133. I tested with GCC 6.1.0 (`-O3`) and Intel compiler 17.0.1 (`-fast`), both get identical results. `GOMP_CPU_AFFINITY=0,12,1,13,2,14,3,15,4,16,5,17,6,18,7,19,8,20,9,21,10,22,11,23` was set. Strem/add/24 threads gets 85 GiB/s on the system.

I was able to reproduce this effect on a different Haswell dual socket server system, but not any other architecture. For example on Sandy Bridge EP, memory performance is identical, while in cache `fill(0)` is much faster.

Here is the code to reproduce:

    #include &lt;algorithm&gt;
    #include &lt;cstdlib&gt;
    #include &lt;iostream&gt;
    #include &lt;omp.h&gt;
    #include &lt;vector&gt;
    
    using value = int;
    using vector = std::vector&lt;value&gt;;
    
    constexpr size_t write_size = 8ll * 1024 * 1024 * 1024;
    constexpr size_t max_data_size = 4ll * 1024 * 1024 * 1024;
    
    void __attribute__((noinline)) fill0(vector&amp; v) {
        std::fill(v.begin(), v.end(), 0);
    }
    
    void __attribute__((noinline)) fill1(vector&amp; v) {
        std::fill(v.begin(), v.end(), 1);
    }
    
    void bench(size_t data_size, int nthreads) {
    #pragma omp parallel num_threads(nthreads)
        {
            vector v(data_size / (sizeof(value) * nthreads));
            auto repeat = write_size / data_size;
    #pragma omp barrier
            auto t0 = omp_get_wtime();
            for (auto r = 0; r &lt; repeat; r++)
                fill0(v);
    #pragma omp barrier
            auto t1 = omp_get_wtime();
            for (auto r = 0; r &lt; repeat; r++)
                fill1(v);
    #pragma omp barrier
            auto t2 = omp_get_wtime();
    #pragma omp master
            std::cout &lt;&lt; data_size &lt;&lt; &quot;, &quot; &lt;&lt; nthreads &lt;&lt; &quot;, &quot; &lt;&lt; write_size / (t1 - t0) &lt;&lt; &quot;, &quot;
                      &lt;&lt; write_size / (t2 - t1) &lt;&lt; &quot;\n&quot;;
        }
    }
    
    int main(int argc, const char* argv[]) {
        std::cout &lt;&lt; &quot;size,nthreads,fill0,fill1\n&quot;;
        for (size_t bytes = 1024; bytes &lt;= max_data_size; bytes *= 2) {
            bench(bytes, 1);
        }
        for (size_t bytes = 1024; bytes &lt;= max_data_size; bytes *= 2) {
            bench(bytes, omp_get_max_threads());
        }
        for (int nthreads = 1; nthreads &lt;= omp_get_max_threads(); nthreads++) {
            bench(max_data_size, nthreads);
        }
    }

Presented results compiled with `g++ fillbench.cpp -O3 -o fillbench_gcc -fopenmp`.

  [1]: https://i.stack.imgur.com/LVKcW.png
  [2]: https://i.stack.imgur.com/uKfEK.png

Content Type	Original Author	Original Content on Stackoverflow
Question	sharptooth	View Question on Stackoverflow
Solution 1 - C++	Juraj Blaho	View Answer on Stackoverflow
Solution 2 - C++	NPE	View Answer on Stackoverflow
Solution 3 - C++	Noah	View Answer on Stackoverflow
Solution 4 - C++	Gerard Nicol	View Answer on Stackoverflow

What's the use of memset() return value?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Solution 4 - C++

System.Runtime.Caching.MemoryCache vs HttpRuntime.Cache - are there any differences?

Class broken error with Joda Time using Scala

Attributions