Instead of calling `/usr/bin/gcc`, use `/usr/bin/c99`. This is the Single-Unix-approved way of invoking a C99 compiler. On an Ubuntu system, this points to a script which invokes `gcc` after having added the `-std=c99` flag, which is precisely what you want.


So I&#39;ve got a library I&#39;m compiling and I need to link different third party things in depending on if it&#39;s the debug or release build (specifically the release or debug versions of those libraries).  Is there an easy way to do this in Cmake?

Edit: I should note I&#39;m using visual studio

Linking different libraries for Debug and Release builds in Cmake on windows?

I have a program that `Process.Start()` another program, and it shuts it down after N seconds. 

Sometimes I choose to attach a debugger to the started program. In those cases, I don&#39;t want the process shut down after N seconds.

I&#39;d like the host program to detect if a debugger is attached or not, so it can choose to not shut it down.

**Clarification**: I&#39;m not looking to detect if a debugger is attached to _my_ process, I&#39;m looking to detect if a debugger is attached to the process I spawned.


Is there a way to detect if a debugger is attached to another process from C#?

I was wondering if there were any files in which I could set the `-std=c99` flag, so that I would not have to set it for every compilation. I am using GCC 4.4 on Ubuntu.

Setting std=c99 flag in GCC

<p>I was wondering if there were any files in which I could set the <code>-std=c99</code> flag, so that I would not have to set it for every compilation. I am using GCC 4.4 on Ubuntu.</p>


I have seen debug printfs in *glibc* which internally is defined as `(void) 0`, if *NDEBUG* is defined. Likewise the [`__noop`][1] for Visual C++ compiler is there too. The former works on both GCC and VC++ compilers, while the latter only on VC++. Now we all know that both the above statements will be treated as no operation and no respective code will be generated; but here&#39;s where I&#39;ve a doubt.

In case of `__noop`, MSDN says that it&#39;s a intrinsic function provided by the compiler. Coming to `(void) 0` ~ Why is it interpreted by the compilers as no op? Is it a tricky usage of the C language or does the standard say something about it explicity? Or even that is something to do with the compiler implementation?


  [1]: http://msdn.microsoft.com/en-us/library/s6btaxcs%28VS.80%29.aspx

Why is (void) 0 a no operation in C and C++?

I declared an enum in my implementation file as shown below, and declared a variable of that type in my interface as PlayerState thePlayerState; and used the variable in my methods. But I am getting errors stating that it is undeclared. How do I correctly declare and use a variable of type PlayerState in my methods?:



In the .m file

    @implementation View1Controller
    
        typedef enum playerStateTypes
        	{
        		PLAYER_OFF,
        		PLAYER_PLAYING,
        		PLAYER_PAUSED
        	} PlayerState;



in the .h file:


    @interface View1Controller : UIViewController {
    	
    	PlayerState thePlayerState;





in some method in .m file:


    -(void)doSomethin{
    
    thePlayerState = PLAYER_OFF;
    
    }



How do I define and use an ENUM in Objective-C?

Let&#39;s say I have the following C code:

    int main () {
      int *p = malloc(10 * sizeof *p);
      *p = 42;
      return 0;  //Exiting without freeing the allocated memory
    }

When I compile and execute that C program, ie after allocating some space in memory, will that memory I allocated be still allocated (ie basically taking up space) after I exit the application and the process terminates? 

When you exit a C application, is the malloc-ed memory automatically freed?

Are there machines (or compilers), where `sizeof(char) != 1`?

Does **C99 standard** says that `sizeof(char)` on standard compliance implementation MUST be exactly 1? If it does, please, give me section number and citation.

*Update:*
If I have a machine (CPU), which can&#39;t address bytes (minimal read is 4 bytes, aligned), but only 4-s of bytes (`uint32_t`), &lt;strike&gt;can compiler for this machine define `sizeof(char)` to 4?&lt;/strike&gt; *`sizeof(char)` will be 1, but char will have 32 bits* (`CHAR_BIT` macros)

*Update2:* 
But sizeof result is NOT a BYTES ! it is the size of CHAR. And char can be 2 byte, or (may be) 7 bit?

*Update3:*
Ok. All machines have `sizeof(char) == 1`. But what machines have `CHAR_BIT &gt; 8` ?

Are there machines, where sizeof(char) != 1, or at least CHAR_BIT &gt; 8?

Can someone explain the difference between a `static` and `const` variable?

What is the difference between a static and const variable?

Have you actually &quot;tried&quot; (means programmed in, not just read an article on it) Erlang and decided against it for a project? If so, why? Also, if you have opted to go back to your old language, or to use another functional language like F#, Haskell, Clojure, Scala, or something else then this counts too, and state why.

Why did you decide &quot;against&quot; using Erlang?

I see a lot of the word &#39;expressiveness&#39; when people want to stress one language is better than the other. But I don&#39;t see exactly what they mean by it. 

 * Is it the verboseness/succinctness? I mean, if one language can write down something shorter than the other, does that mean expressiveness? Please refer to my other question - https://stackoverflow.com/questions/2411772/article-about-code-density-as-a-measure-of-programming-language-power
 * Is it the power of the language? Paul Graham says that one language is more powerful than the other language in a sense that one language can do that the other language can&#39;t do (for example, LISP can do something with macro that the other language can&#39;t do).
 * Is it just something that makes life easier? Regular expression can be one of the examples.
 * Is it a different way of solving the same problem: something like SQL to solve the search problem?

What do you think about the expressiveness of a programming language? Can you show the expressiveness using some code? 

What&#39;s the relationship with the expressiveness and DSL? Do people come up with DSL to get the expressiveness? 

What do you mean by the expressiveness of a programming language?

Is there any reason behind using date(January 1st, 1970) as default standard for time manipulation? I have seen this standard in Java as well as in Python. These two languages I am aware of. Are there other popular languages which follows the same standard?

Please describe.

Why are dates calculated from January 1st, 1970?

Is there a set of things that every JavaScript programmer should know to be able to say &quot;I know JavaScript&quot;?

What should every JavaScript programmer know?

After reading some material on this subject I&#39;m still not sure what the difference between a compiled language and an interpreted language is. I was told this is one of the differences between Java and JavaScript. Would someone please help me in understanding it?

What&#39;s the difference between compiled and interpreted language?

What type for array index in C99 should be used? It have to work on LP32, ILP32, ILP64, LP64, LLP64 and more. It doesn&#39;t have to be a C89 type.

I have found 5 candidates:

* `size_t`
* `ptrdiff_t`
* `intptr_t` / `uintptr_t`
* `int_fast*_t` / `uint_fast*_t`
* `int_least*_t` / `uint_least*_t`

There is simple code to better illustrate problem. What is the best type for `i` and `j` in these two particular loops. If there is a good reason, two different types are fine too.

    for (i=0; i&lt;imax; i++) {
            do_something(a[i]);
    }
    /* jmin can be less than 0 */
    for (j=jmin; j&lt;jmax; j++) {
            do_something(a[j]);
    }

P.S.
In the first version of question I had forgotten about negative indexes.

P.P.S.
I am not going to write a C99 compiler. However any answer from a compiler programmer would be very valuable for me.

Similar question:

* https://stackoverflow.com/questions/1464174/size-t-vs-intptr-t  
The context of this question if different though.

What is the correct type for array indexes in C?

here is very simplified code of problem I have:

&lt;pre&gt;
enum node_type {
    t_int, t_double
};

struct int_node {
    int value;
};

struct double_node {
    double value;
};

struct node {
    enum node_type type;
    &lt;b&gt;union {
        struct int_node int_n;
        struct double_node double_n;
    };&lt;/b&gt;
};

int main(void) {
    struct int_node i;
    i.value = 10;
    struct node n;
    n.type = t_int;
    n.&lt;b&gt;int_n&lt;/b&gt; = i;
    return 0;
}
&lt;/pre&gt;

And what I don&#39;t undestand is this:

&lt;pre&gt;
$ cc us.c 
$ cc -std=c99 us.c 
us.c:18:4: warning: declaration does not declare anything
us.c: In function ‘main’:
us.c:26:4: error: ‘struct node’ has no member named ‘int_n’
&lt;/pre&gt;

Using `GCC` without `-std` option compiles code above without any problems (and the similar code is working pretty well), but it seems that `c99`  does not permit this technique. Why is it so and is it possible to make is `c99` (or `c89`, `c90`) compatible? Thanks.

Anonymous union within struct not in c99?

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 used to think that in C99, even if the side-effects of functions `f` and `g` interfered, and although the expression `f() + g()` does not contain a sequence point, `f` and `g` would contain some, so the behavior would be unspecified: either f() would be called before g(), or g() before f().

I am no longer so sure. What if the compiler inlines the functions (which the compiler may decide to do even if the functions are not declared `inline`) and then reorders instructions? May one get a result different of the above two? In other words, is this undefined behavior?

This is not because I intend to write this kind of thing, this is to choose the best label for such a statement in a static analyzer. 


Content Type	Original Author	Original Content on Stackoverflow
Question	Fatmarik	View Question on Stackoverflow
Solution 1 - C	Thomas Pornin	View Answer on Stackoverflow
Solution 2 - C	dirkgently	View Answer on Stackoverflow

Setting std=c99 flag in GCC

C Problem Overview

C Solutions

Solution 1 - C

Solution 2 - C

Is there a way to detect if a debugger is attached to another process from C#?

Linking different libraries for Debug and Release builds in Cmake on windows?

Attributions