It&#39;s defined in `stddef.h`.

---

That header defines the integral types `size_t`, `ptrdiff_t`, and `wchar_t`, the functional macro `offsetof`, and the constant macro `NULL`.

It is defined by the POSIX standard: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/stddef.h.html Where the type is exactly may be implemetation-specific, but interface is stddef.h

Should I check in my .project and .classpath files?

My friend told me that I should only check in .java files and the build.xml to guarantee portability. He said &quot;.classpath will cause you much less portability on different environment. .project is entirely your local eclipse setting&quot;

I agree with him, but partially. 

-- Not checking in .project file will make my development less efficient (I can&#39;t simply &quot;import&quot; a project code from a directory)

-- Not checking in .classpath file seems OK to me (?) if my build.xml is written carefully.

Anyone wants to share their experience here?

Java project: should .classpath .project file be committed into repository?

This is a relatively open question.  If I have built an application in a project in Eclipse and I then want to test this project, should I create the JUnit code within the same project or create a separate project.  For instance...

`ShopSystem` maybe the name of my main project - should I create a project called say, `ShopSystemTest`?

In general - how far &quot;away&quot; should the testing code be stored from the main project folder?  If I store the testing code within the main project and then export the main project as a runnable jar it will take the testing code with it, which isn&#39;t ideal...

Suggestions?

Eclipse junit testing in the same project

Where is ptrdiff_t defined in C?

<p>Where is <code>ptrdiff_t</code> defined in C?</p>


For instance:

    Bool NullFunc(const struct timespec *when, const char *who)
    {
       return TRUE;
    }

In C++ I was able to put a `/*...*/` comment around the parameters. But not in C of course, where it gives me the error:

&gt; error: parameter name omitted





How can I suppress &quot;unused parameter&quot; warnings in C?

For example,

    int result;
    
    result = 125/100;

or 

    result = 43/100;

Will result always be the floor of the division? What is the defined behavior?

What is the behavior of integer division?

I have a list of numbers as below:

&gt; 0, 16, 32, 48 ...

I need to output those numbers in hexadecimal as:

&gt; 0000,0010,0020,0030,0040 ...

I have tried solution such as:

    printf(&quot;%.4x&quot;,a); // where a is an integer

but the result that I got is:

&gt; 0000, 0001, 0002, 0003, 0004 ...

I think I&#39;m close there. Can anybody help as I&#39;m not
so good at `printf` in C.

Thanks.



How to display hexadecimal numbers in C?

I learned that `memset(ptr, 0, nbytes)` is really fast, but is there a faster way (at least on x86)?

I assume that memset uses `mov`, however when zeroing memory most compilers use `xor` as it&#39;s faster, correct? **edit1:** Wrong, as GregS pointed out that only works with registers. What was I thinking?

Also I asked a person who knew of assembler more than me to look at the stdlib, and he told me that on x86 memset is not taking full advantage of the 32 bit wide registers. However at that time I was very tired, so I&#39;m not quite sure I understood it correctly.

**edit2**:
I revisited this issue and did a little testing. Here is what I tested:

        #include &lt;stdio.h&gt;
        #include &lt;malloc.h&gt;
        #include &lt;string.h&gt;
        #include &lt;sys/time.h&gt;

        #define TIME(body) do {                                                     \
            struct timeval t1, t2; double elapsed;                                  \
            gettimeofday(&amp;t1, NULL);                                                \
            body                                                                    \
            gettimeofday(&amp;t2, NULL);                                                \
            elapsed = (t2.tv_sec - t1.tv_sec) * 1000.0 + (t2.tv_usec - t1.tv_usec) / 1000.0; \
            printf(&quot;%s\n --- %f ---\n&quot;, #body, elapsed); } while(0)                 \


        #define SIZE 0x1000000

        void zero_1(void* buff, size_t size)
        {
            size_t i;
            char* foo = buff;
            for (i = 0; i &lt; size; i++)
                foo[i] = 0;

        }

        /* I foolishly assume size_t has register width */
        void zero_sizet(void* buff, size_t size)
        {
            size_t i;
            char* bar;
            size_t* foo = buff;
            for (i = 0; i &lt; size / sizeof(size_t); i++)
                foo[i] = 0;
    
            // fixes bug pointed out by tristopia
            bar = (char*)buff + size - size % sizeof(size_t);
            for (i = 0; i &lt; size % sizeof(size_t); i++)
                bar[i] = 0;
        }

        int main()
        {
            char* buffer = malloc(SIZE);
            TIME(
                memset(buffer, 0, SIZE);
            );
            TIME(
                zero_1(buffer, SIZE);
            );
            TIME(
                zero_sizet(buffer, SIZE);
            );
            return 0;
        }

results:

&lt;strike&gt;
zero_1 is the slowest, except for -O3. zero_sizet is the fastest with roughly equal performance across -O1, -O2 and -O3. memset was always slower than zero_sizet. (twice as slow for -O3). one thing of interest is that at -O3 zero_1 was equally fast as zero_sizet. however the disassembled function had roughly four times as many instructions (I think caused by loop unrolling). Also, I tried optimizing zero_sizet further, but the compiler always outdid me, but no surprise here.&lt;/strike&gt; 

For now memset wins, previous results were distorted by CPU cache. (all tests were run on Linux) Further testing needed. I&#39;ll try assembler next :)

**edit3:** fixed bug in test code, test results are not affected 

**edit4:** While poking around the disassembled VS2010 C runtime, I noticed that `memset` has a SSE optimized routine for zero. It will be hard to beat this.


Faster way to zero memory than with memset?

I have an `int` pointer (i.e., `int *count`) that I want to increment the integer being pointed at by using the `++` operator. I thought I would call:

    *count++;

However, I am getting a build warning *&quot;expression result unused&quot;*. I can: call

    *count += 1;

But, I would like to know how to use the `++` operator as well. Any ideas?

increment value of int being pointed to by pointer

It seems that when I use a numeric type as a key name in an object, it always gets converted to a string. Is there anyway to actually get it to store as a numeric? The normal typecasting does not seem to work.

Example:

    var userId = 1;
    console.log( typeof userId ); // number
    myObject[userId] = &#39;a value&#39;;
    console.dir(myObject);

Dir Output:

    {
        &#39;1&#39;: &#39;a value&#39;
    }


What I **want** is this:

    {
        1: &#39;a value&#39;
    }


Advice?

Is there any way to use a numeric type as an object key?

It seems that the C# 3.0 object initializer syntax allows one to exclude the open/close pair of parentheses in the constructor when there is a parameterless constructor existing. Example:

    var x = new XTypeName { PropA = value, PropB = value };

As opposed to:

    var x = new XTypeName() { PropA = value, PropB = value };

I&#39;m curious why the constructor open/close parentheses pair is optional here after `XTypeName`?

Why are C# 3.0 object initializer constructor parentheses optional?

I know about `int` and `long` (32-bit and 64-bit numbers), but what are `uint` and `ulong`?

What is the difference between “int” and “uint” / “long” and “ulong”?

The `inline` keyword in F# seems to me to have a somewhat different purpose than what I&#39;m used to in e.g. C. For example, it seems to affect a function&#39;s type (what are &quot;statically resolved type parameters&quot;? Aren&#39;t all F# types resolved statically?)

When should I be using `inline` functions?

Use of `inline` in F#

For clarity, if I&#39;m using a language that implements IEE 754 floats and I declare:

    float f0 = 0.f;
    float f1 = 1.f;

...and then print them back out, I&#39;ll get 0.0000 and 1.0000 - exactly.

But IEEE 754 isn&#39;t capable of representing all the numbers along the real line. Close to zero, the &#39;gaps&#39; are small; as you get further away, the gaps get larger.

So, my question is: **for an IEEE 754 float, which is the first (closest to zero) integer which cannot be exactly represented?** I&#39;m only really concerned with 32-bit floats for now, although I&#39;ll be interested to hear the answer for 64-bit if someone gives it!

I thought this would be as simple as calculating 2&lt;sup&gt;bits_of_mantissa&lt;/sup&gt; and adding 1, where _bits\_of\_mantissa_ is how many bits the standard exposes. I did this for 32-bit floats on my machine (MSVC++, Win64), and it seemed fine, though.

Which is the first integer that an IEEE 754 float is incapable of representing exactly?

Linux binaries are usually dynamically linked to the core system library (libc). This keeps the memory footprint of the binary quite small but binaries which are dependent on the latest libraries will not run on older systems. Conversely, binaries linked to older libraries will run happily on the latest systems.

Therefore, in order to ensure our application has good coverage during distribution we need to figure out the oldest libc we can support and link our binary against that. 

How should we determine the oldest version of libc we can link to?

Linking against an old version of libc to provide greater application coverage

I just discovered that the `-lm` flag is needed by gcc in order to compile a program that refers a function from the math library. I&#39;m wondering why an explicit linking flag isn&#39;t needed when compiling programs containing other libraries such as the time library. If I write a program where the `time()` function is called, it would compile with no problems even with no linking options. But a program with the math library involved just won&#39;t work without the `-lm` flag. 

Can anyone please explain the reason behind this behaviour? Thanks for your time.

gcc: why is the -lm flag needed to link the math library?

I often see source code using types like uint32, uint64 and I wonder if they should be defined by the programmer in the application code or if they are defined in a standard lib header.

What&#39;s the best way to have these types on my application source code?


Are types like uint32, int32, uint64, int64 defined in any stdlib header?

I have grown accustomed to `strtod` and variants.
I am wondering why there is no `strtoi` shipped with `&lt;stdlib.h&gt;`.
Why is it that the integer type is left out of this party?

Specifically I am asking why there is not a version of `atoi` with the safety features of `strtod`?

Why is there no strtoi in stdlib.h?

What is the difference between stdint.h and inttypes.h?

If none of them is used, uint64_t is not recognized but with either of them it is a defined type.

difference between stdint.h and inttypes.h

C99 standard has integer types with bytes size like int64_t. I am using Windows&#39;s `%I64d` format currently (or unsigned `%I64u`), like:

    #include &lt;stdio.h&gt;
    #include &lt;stdint.h&gt;
    int64_t my_int = 999999999999999999;
    printf(&quot;This is my_int: %I64d\n&quot;, my_int);

and I get this compiler warning:

    warning: format ‘%I64d’ expects type ‘int’, but argument 2 has type ‘int64_t’

I tried with:

    printf(&quot;This is my_int: %lld\n&quot;, my_int); // long long decimal

But I get the same warning. I am using this compiler:

    ~/dev/c$ cc -v
    Using built-in specs.
    Target: i686-apple-darwin10
    Configured with: /var/tmp/gcc/gcc-5664~89/src/configure --disable-checking --enable-werror --prefix=/usr --mandir=/share/man --enable-languages=c,objc,c++,obj-c++ --program-transform-name=/^[cg][^.-]*$/s/$/-4.2/ --with-slibdir=/usr/lib --build=i686-apple-darwin10 --program-prefix=i686-apple-darwin10- --host=x86_64-apple-darwin10 --target=i686-apple-darwin10 --with-gxx-include-dir=/include/c++/4.2.1
    Thread model: posix
    gcc version 4.2.1 (Apple Inc. build 5664)

Which format should I use to print my_int variable without having a warning?



How to print a int64_t type in C

I already know that `stdint` is used to when you need specific variable sizes for portability between platforms. I don&#39;t really have such an issue for now, but what are the cons and pros of using it besides the already shown fact above?

Looking for this on stackoverflow and others sites, I found 2 links that treats about the theme:

* [codealias.info](http://www.codealias.info/technotes/why_you_should_use_stdint.h) - this one talks about the **portability** of the stdint.

* [stackoverflow](https://stackoverflow.com/questions/1725855/uint8-t-vs-unsigned-char) - this one is more specific about **uint8_t**.

These two links are great specially if one is looking to know more about the main reason of this header - **portability**. But for me, what I like most about it is that I think `uint8_t` is cleaner than `unsigned char` (for storing an RBG channel value for example), `int32_t` looks more meaningful than simply `int`, etc.

So, my question is, exactly what are the cons and pros of using `stdint` besides the portability? Should I use it just in some specifics parts of my code, or everywhere? if everywhere, how can I use functions like `atoi()`, `strtok()`, etc. with it?

Thanks!

Reasons to use (or not) stdint

What is the difference between `stdint.h` and `cstdint`?

Both of them are available in MSVC (Visual Studio 2010) and gcc-4.5.1. Also both define the `intX_t`/`uintX_t` types (where `X` is the size in bytes of the type).

* If the rationale in both headers is the same (portable types), what decisions I must take to decide on one or the other?

The `stdint.h` defines each type without any namespace, the `cstdint` types lies in the `std` namespace.

* Is there any reason to include or to not include the defined types into the `std` namespace? What is different between the two headers?

`cstdint` has no file extension and uses the `c` prefix, `stdint.h` uses the `.h` extension.

* What are the naming conventions for this headers? the `c` prefix indicates that this is a C library? there&#39;s a reason for the lack of file extension in `cstdint`?

&lt;cstdint&gt; vs &lt;stdint.h&gt;

If you want to use [Qt][1], you have to embrace `quint8`, `quint16` and so forth.

If you want to use **[GLib][2]**, you have to welcome `guint8`, `guint16` and so forth.

On [Linux][3] there are `u32`, `s16` and so forth.

**uC/OS** defines `SINT32`, `UINT16` and so forth.

And if you have to use some combination of those things, you better be prepared for trouble. Because on your machine `u32` will be `typedef`d over `long` and `quint32` will be `typedef`d over `int` and the compiler *will complain*.

Why does everybody do this, if there is `&lt;stdint.h&gt;`? Is this some kind of tradition for libraries?

  [1]: https://en.wikipedia.org/wiki/Qt_%28software%29
  [2]: https://en.wikipedia.org/wiki/GLib
  [3]: http://en.wikipedia.org/wiki/Linux


Content Type	Original Author	Original Content on Stackoverflow
Question	Matt Joiner	View Question on Stackoverflow
Solution 1 - C	GManNickG	View Answer on Stackoverflow
Solution 2 - C	user933161	View Answer on Stackoverflow

Where is ptrdiff_t defined in C?

C Problem Overview

C Solutions

Solution 1 - C

Solution 2 - C

Eclipse junit testing in the same project

Java project: should .classpath .project file be committed into repository?

Attributions