Yes, we can. The `#endif` statement matches to the previous `#if` `#ifdef` or `#ifndef` etc for which there hasn&#39;t been a corresponding `#endif`.

e.g.

    #if  ----------|
    #if  -----|    |
    #endif ---|    |
    #endif --------|

Yes, you can nest `#if`/`#endif` blocks. Some C coding styles would tell you to write

    #ifdef CONDITION1
    # ifdef CONDITION2
    # endif
    #endif

using spaces to denote the level of nesting.

In your code, the #ifndef QUESTION section will be discarded unless you #undef QUESTION. 

Good luck!

***This is cross-posted on the ggplot2 google group***

My situation is that I&#39;m [working on a function](https://github.com/briandk/granova/blob/dev/R/granova.contr.ggplot.R &quot;Click here to see the development repository for our graphical analysis of variance package in R&quot;) that outputs an arbitrary number of plots (depending upon the input data supplied by the user). The function returns a list of n plots, and I&#39;d like to lay those plots out in 2 x 2 formation. I&#39;m struggling with the simultaneous problems of:

1.  How can I allow the flexibility to be handed an arbitrary (n) number of plots?
2.  How can I also specify I want them laid out 2 x 2

My current strategy uses `grid.arrange` from the `gridExtra` package. It&#39;s probably not optimal, especially since, and this is key, *it totally doesn&#39;t work*. Here&#39;s my commented sample code, experimenting with three plots:

    library(ggplot2)
    library(gridExtra)

    x &lt;- qplot(mpg, disp, data = mtcars)
    y &lt;- qplot(hp, wt, data = mtcars)
    z &lt;- qplot(qsec, wt, data = mtcars)

    # A normal, plain-jane call to grid.arrange is fine for displaying all my plots
    grid.arrange(x, y, z)

    # But, for my purposes, I need a 2 x 2 layout. So the command below works acceptably.
    grid.arrange(x, y, z, nrow = 2, ncol = 2)

    # The problem is that the function I&#39;m developing outputs a LIST of an arbitrary
    # number plots, and I&#39;d like to be able to plot every plot in the list on a 2 x 2
    # laid-out page. I can at least plot a list of plots by constructing a do.call()
    # expression, below. (Note: it totally even surprises me that this do.call expression
    # DOES work. I&#39;m astounded.)
    plot.list &lt;- list(x, y, z)
    do.call(grid.arrange, plot.list)

    # But now I need 2 x 2 pages. No problem, right? Since do.call() is taking a list of
    # arguments, I&#39;ll just add my grid.layout arguments to the list. Since grid.arrange is
    # supposed to pass layout arguments along to grid.layout anyway, this should work.
    args.list &lt;- c(plot.list, &quot;nrow = 2&quot;, &quot;ncol = 2&quot;)

    # Except that the line below is going to fail, producing an &quot;input must be grobs!&quot;
    # error
    do.call(grid.arrange, args.list)

As I am wont to do, I humbly huddle in the corner, eagerly awaiting the sagacious feedback of a community far wiser than I. Especially if I&#39;m making this harder than it needs to be.

How can I arrange an arbitrary number of ggplots using grid.arrange?

Say I have a click handler defined:

    $(&quot;#foo&quot;).click(function(e){
    
    });


How can I, within the function handler, tell whether the event was fired programmatically, or by the user?

In jQuery, how can I tell between a programmatic and user click?

I have a question about Pre-processor directives in c++:

For example:

    #ifndef QUESTION
    
    //some code here
    
    #ifndef QUESTION
    
    //some code here
    
    #endif
    
    #endif


Can we use it in this way, and can the C++ compiler match the `ifndef` and `endif` in the right way?





Can #if pre-processor directives be nested in C++?

I have a question about Pre-processor directives in c++:
For example:
<pre><code class="hljs language-arduino">#ifndef QUESTION

//some code here

#ifndef QUESTION

//some code here

#endif

#endif
</code></pre>
Can we use it in this way, and can the C++ compiler match the <code>ifndef</code> and <code>endif</code> in the right way?

Is there a difference between an `std::pair` and an `std::tuple` with only two members? (Besides the obvious that `std::pair` requires two and only two members and `tuple` may have more or less...)

Difference between std::pair and std::tuple with only two members?

For example, stdlibc++ has the following:

    unique_lock&amp; operator=(unique_lock&amp;&amp; __u)
    {
        if(_M_owns)
            unlock();
        unique_lock(std::move(__u)).swap(*this);
        __u._M_device = 0;
        __u._M_owns = false;
        return *this;
    }
Why not just assign the two __u members to *this directly? Doesn&#39;t the swap imply that __u is assigned the *this members, only to later have then assigned 0 and false... in which case the swap is doing unnecessary work.  What am I missing?
(the unique_lock::swap just does an std::swap on each member)

Why do some people use swap for move assignments?

I need to optimize the size of my executable severely (`ARM` development) and
I noticed that in my current build scheme (`gcc` + `ld`) unused symbols are not getting stripped.

The usage of the `arm-strip --strip-unneeded` for the resulting executables / libraries doesn&#39;t change the output size of the executable *(I have no idea why, maybe it simply can&#39;t)*.

What would be the way *(if it exists)* to modify my building pipeline, so that the unused symbols are stripped from the resulting file?

----------

I wouldn&#39;t even think of this, but my current embedded environment isn&#39;t very &quot;powerful&quot; and 
saving even `500K` out of `2M` results in a very nice loading performance boost.

**Update:**

Unfortunately the current `gcc` version I use doesn&#39;t have the `-dead-strip` option and the `-ffunction-sections... + --gc-sections` for `ld` doesn&#39;t give any significant difference for the resulting output.

*I&#39;m shocked that this even became a problem, because I was sure that `gcc + ld` should automatically strip unused symbols (why do they even have to keep them?).*


How to remove unused C/C++ symbols with GCC and ld?

I know that when we are using template inside another template, we should write it like this:

`vector&lt;pair&lt;int,int&gt; &gt; s;`

and if we write it without the whitespace:

`vector&lt;pair&lt;int,int&gt;&gt; s;`

we will get an error:

&gt; \`&gt;&gt;&#39; should be \`&gt; &gt;&#39; within a nested template argument list

I see this is understandable, but I just can&#39;t help but wondering, in which cases will this be really ambiguous?

Template within template: why &quot;`&gt;&gt;&#39; should be `&gt; &gt;&#39; within a nested template argument list&quot;

This was a question I was asked at my recent interview and I want to know *(I don&#39;t actually remember the theory of the numerical analysis, so please help me :)*

If we have some function, which accumulates floating-point numbers:

    std::accumulate(v.begin(), v.end(), 0.0);

`v` is a `std::vector&lt;float&gt;`, for example.

- **Would it be better to sort these numbers before accumulating them?**

- **Which order would give the most precise answer?**

I suspect that **sorting** the numbers in ascending order would actually make the numerical error **less**, but unfortunately I can&#39;t prove it myself.

*P.S. I do realize this probably has nothing to do with real world programming, just being curious.*


In which order should floats be added to get the most precise result?

&gt; **Possible Duplicate:**  
&gt; [#ifdef inside #define](https://stackoverflow.com/questions/5586429/ifdef-inside-define)  

&lt;!-- End of automatically inserted text --&gt;

How do I use the character &quot;#&quot; successfully inside a Macro? It screams when I do something like that:

    #define DO(WHAT)        \
    #ifdef DEBUG		\							
      MyObj-&gt;WHAT()	        \		
    #endif	         	\

							


&quot;#ifdef&quot; inside a macro

I have a main directory `A` with two sub directories `B` and `C`.

Directory `B` contains a header file `structures.c`:
                        
    #ifndef __STRUCTURES_H
    #define __STRUCTURES_H
    typedef struct __stud_ent__
    {
        char name[20];
        int roll_num;
    }stud;
    #endif


Directory `C` contains `main.c` code:

    #include&lt;stdio.h&gt;
    #include&lt;stdlib.h&gt;
    #include &lt;structures.h&gt;
    int main()
    {
        stud *value;
        value = malloc(sizeof(stud));
        free (value);
        printf(&quot;working \n&quot;);
        return 0;
    }

But I get an error:

&lt;!-- language: none --&gt; 

    main.c:3:24: error: structures.h: No such file or directory
    main.c: In function ‘main’:
    main.c:6: error: ‘stud’ undeclared (first use in this function)
    main.c:6: error: (Each undeclared identifier is reported only once
    main.c:6: error: for each function it appears in.)
    main.c:6: error: ‘value’ undeclared (first use in this function)

What is the correct way to include the `structures.h` file into `main.c`?

Including a header file from another directory


What I&#39;m trying to figure out is if something such as this (written in **C**):

    #define FOO 15
    #define BAR 23
    #define MEH (FOO / BAR)

is allowed?  I would want the preprocessor to replace every instance of

    MEH

with

    (15 / 23)

but I&#39;m not so sure that will work.  Certainly if the preprocessor only goes through the code once then I don&#39;t think it&#39;d work out the way I&#39;d like.

I found several similar examples but all were really too complicated for me to understand.  If someone could help me out with this simple one I&#39;d be eternally grateful!



Can a C macro definition refer to other macros?

Shortly, I want to know if gcc (or g++. I need it in **C**, but also am curious about c++) defines any special symbols if `-g` is enabled. Does it? If so, what symbols?

In the search process I found out that:

- `_DEBUG` is defined manually (by manually I mean `-D_DEBUG`) and is a habit taken from Visual C programmers  (because VC defines `_DEBUG` when compiling in debug mode)
- `NDEBUG` is defined if NOT in debug mode. Although I found a few places saying this, I tried with my gcc and g++ in .c and .cpp files and in none of them with or without `-g` no such symbol was defined!

**Edit**: Let me demonstrate why I don&#39;t want to use a non-standard symbol:

Imagine a kernel module that does something and also provides header files to be included in other kernel modules so that they can connect to this one.

Now as a facility, in one of the header files I have:

    #ifdef DEBUG &lt;-- This is what I need
    #define LOG(x, ...) printk(&quot;Some extra info&quot;x, ##__VA_ARGS__);
    #else
    #define LOG(x, ...) printk(&quot;Without extra info&quot;x, ##__VA_ARGS__);
    #endif

Note that the name is not really `LOG`, that&#39;s an example.

Now, I can use any symbol for `DEBUG` myself, but then if someone includes my header, they may not define that symbol. Of course I can tell them &quot;by the way, to get the headers in debug mode, define this other symbol&quot;, but that just doesn&#39;t sound right to me.

I could define the symbol in a header and include it in all header files. This way, if they include one of my headers, they get the debug symbol too. The problem now is that, if they _don&#39;t_ want to compile in debug mode, my headers still think they are in debug mode.

So what I thought would be best was to use a symbol that is defined when `-g` is used, if there are any!

## Update

So far I came to the conclusion that I could do something like this:

how_to_build.h

    #if !defined(NDEBUG)
    #define MY_DEBUG
    #endif

Usage:

    #include &quot;how_to_build.h&quot;

    #ifdef MY_DEBUG
    // rest of the story

This way, the common option of `NDEBUG` removes my definition also. It still requires me to tell them to define it if they don&#39;t want to get the headers in debug mode.

Does gcc define anything when -g is specified?

If I have:

    #define MAXLINE    5000

What type is MAXLINE understood to be? Should I assume it is an `int`? Can I test it somehow?

In general, how can one determine the type of `#define`ed variable?

Type of #define variables

If have some code where I would like to use C++11x extensions as much as possible, but have a fallback if this is not supported. Currently the OSX version of GCC and the VisualC compiler has little to no support for C++11x, so I use:
    
    #if (defined(__APPLE__) || (defined(_WIN32)))
       ...fallback code without C++11x ...
    #else
       ... code using C++11x ...
    #endif

And this works, but is not really the right thing to do, especially since the gcc compiler in MacPorts DOES support c++11x.

Is there a `#define C11X_SUPPORTED` type macro? Perhaps something only GCC has?

Is there a preprocessor directive for detecting C++11x support?

Suppose that I have 10,000 lines of C++ code. 200 lines of this code are for testing purpose (for example, check the program and show an error message).

Is there an way in C++ to ignore or consider some lines of the code (maybe with [preprocessor][1] keywords)?

  [1]: http://en.wikipedia.org/wiki/C_preprocessor


Force the compiler to ignore some lines in the program

In C/C++/Objective C you can define a macro using compiler preprocessors.
Moreover, you can include/exclude some parts of code using compiler preprocessors.

```c++
#ifdef DEBUG
    // Debug-only code
#endif
```

Is there a similar solution in Swift?


#ifdef replacement in the Swift language

I am a first year computer science student and my professor said `#define` is banned in the industry standards along with `#if`, `#ifdef`, `#else`, and a few other preprocessor directives. He used the word &quot;banned&quot; because of unexpected behaviour.

Is this accurate? If so why?

Are there, in fact, any standards which prohibit the use of these directives?



Is #define banned in industry standards?

I was reading that in C++ using macros like

    #define max(a,b) (a &gt; b ? a : b)

can result in a &#39;double evaluation&#39;. Can someone give me an example of when a double evaluation occurs and why it&#39;s bad?

P.S.: Surprisingly I couldn&#39;t find any detailed explanation when googling for it except for an example in [Clojure][1] (which I can&#39;t understand).

  [1]: http://en.wikipedia.org/wiki/Clojure


Content Type	Original Author	Original Content on Stackoverflow
Question	user707549	View Question on Stackoverflow
Solution 1 - C++	Armen Tsirunyan	View Answer on Stackoverflow
Solution 2 - C++	Fred Foo	View Answer on Stackoverflow
Solution 3 - C++	bert-jan	View Answer on Stackoverflow

Can #if pre-processor directives be nested in C++?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

In jQuery, how can I tell between a programmatic and user click?

How can I arrange an arbitrary number of ggplots using grid.arrange?

Attributions