Like this

    #if defined(LINUX) || defined(ANDROID)

# OR condition in #ifdef

    #if defined LINUX || defined ANDROID
    // your code here
    #endif /* LINUX || ANDROID */

or-

    #if defined(LINUX) || defined(ANDROID)
    // your code here
    #endif /* LINUX || ANDROID */

Both above are the same, which one you use simply depends on your taste.

---

**P.S.**: `#ifdef` is simply the short form of `#if defined`, however, does not support complex condition.

---

**Further-**

- AND: `#if defined LINUX &amp;&amp; defined ANDROID`
- XOR: `#if defined LINUX ^ defined ANDROID`

I want to run this query:

    SELECT DISTINCT ON (address_id) purchases.address_id, purchases.*
    FROM purchases
    WHERE purchases.product_id = 1
    ORDER BY purchases.purchased_at DESC

But I get this error:

&gt; PG::Error: ERROR:  SELECT DISTINCT ON expressions must match initial ORDER BY expressions

Adding `address_id` as first `ORDER BY` expression silences the error, but I really don&#39;t want to add sorting over `address_id`. Is it possible to do without ordering by `address_id`?

PostgreSQL DISTINCT ON with different ORDER BY

Let&#39;s say you have a JavaScript class like this

    var DepartmentFactory = function(data) {
        this.id = data.Id;
        this.name = data.DepartmentName;
        this.active = data.Active;
    }

Let&#39;s say you then create a number of instances of that class and store them in an array

    var objArray = [];
    objArray.push(DepartmentFactory({Id: 1, DepartmentName: &#39;Marketing&#39;, Active: true}));
    objArray.push(DepartmentFactory({Id: 2, DepartmentName: &#39;Sales&#39;, Active: true}));
    objArray.push(DepartmentFactory({Id: 3, DepartmentName: &#39;Development&#39;, Active: true}));
    objArray.push(DepartmentFactory({Id: 4, DepartmentName: &#39;Accounting&#39;, Active: true}));

So I now would have an array of objects created by `DepartmentFactory`. How would I go about using the `array.sort()` method to sort this array of objects by the `DepartmentName` property of each object?

The `array.sort()` method works just fine when sorting an array of strings

    var myarray=[&quot;Bob&quot;, &quot;Bully&quot;, &quot;Amy&quot;];
    myarray.sort(); //Array now becomes [&quot;Amy&quot;, &quot;Bob&quot;, &quot;Bully&quot;]

But how do I make it work with a list of objects?

Sort objects in an array alphabetically on one property of the array

Sorry for asking very basic question. I would like to set OR condition in #ifdef directive.?
How to do that ?
I tried

    #ifdef LINUX | ANDROID
    ...
    ..
    #endif 
It did not work? What is the proper way?

how to use #ifdef with an OR condition?

Sorry for asking very basic question. I would like to set OR condition in #ifdef directive.?
How to do that ?
I tried
<pre><code class="hljs language-arduino">#ifdef LINUX | ANDROID
...
..
#endif 
</code></pre>
It did not work? What is the proper way?

 I have been involved in some debate with respect to libraries in Linux, and would like to confirm some things.

It is to my understanding (please correct me if I am wrong and I will edit my post later), that there are two ways of using libraries when building an application:

 1. Static libraries (.a files): At link time, a copy of the entire library is put into the final application so that the functions within the library are always available to the calling application
 2. Shared objects (.so files): At link time, the object is just verified against its API via the corresponding header (.h) file. The library isn&#39;t actually used until runtime, where it is needed.

The obvious advantage of static libraries is that they allow the entire application to be self-contained, while the benefit of dynamic libraries is that the &quot;.so&quot; file can be replaced (ie: in case it needs to be updated due to a security bug) without requiring the base application to be recompiled.

I have heard some people make a distinction between shared objects and dynamic link libraries (DLL&#39;s), even though they are both &quot;.so&quot; files. Is there any distinction between shared objects and DLLs when it comes to C/C++ development on Linux or any other POSIX compliant OS (ie: MINIX, UNIX, QNX, etc)? I am told that one key difference (so far) is that shared objects are just used at runtime, while DLL&#39;s must be opened first using the dlopen() call within the application.

Finally, I have also heard some developers mention &quot;shared archives&quot;, which, to my understanding, are also static libraries themselves, but are never used by an application directly. Instead, other static libraries will link against the &quot;shared archives&quot; to pull some (but not all) functions/resources from the shared archive into the static library being built.

Thank you all in advance for your assistance.

# Update

----------

**In the context in which these terms were provided to me, it was effectively erroneous terms used by a team of Windows developers that had to learn Linux. I tried to correct them, but the (incorrect) language norms stuck.**

1. Shared Object: A library that is automatically linked into a program when the program starts, and exists as a standalone file. The library is included in the linking list at compile time (ie: `LDOPTS+=-lmylib` for a library file named `mylib.so`). **The library must be present at compile time, and when the application starts.**
2. Static Library: A library that is merged into the actual program itself at build time for a single (larger) application containing the application code and the library code that is automatically linked into a program when the program is built, and the final binary containing both the main program and the library itself exists as a single standalone binary file. The library is included in the linking list at compile time (ie: `LDOPTS+=-lmylib` for a library file named `mylib.a`). **The library must be present at compile time.**
3. DLL: Essentially the same as a shared object, but rather than being included in the linking list at compile time, the library is loaded via `dlopen()`/`dlsym()` commands so that the library does not need to be present at build time for the program to compile. **Also, the library does not need to be present (necessarily) at application startup or compile time**, as it is only needed at the moment the `dlopen`/`dlsym` calls are made.
4. Shared Archive: Essentially the same as a static library, but is compiled with the &quot;export-shared&quot; and &quot;`-fPIC`&quot; flags. The library is included in the linking list at compile time (ie: `LDOPTS+=-lmylibS` for a library file named `mylibS.a`). The distinction between the two is that this additional flag is required if a shared object or DLL wants to statically link the shared archive into its own code AND be able to make the functions in the shared object available to other programs, rather than just using them internal to the DLL. This is useful in the case when someone provides you with a static library, and you wish to repackage it as an SO. **The library must be present at compile time.**

# Additional Update

The distinction between &quot;`DLL`&quot; and &quot;`shared library`&quot; was just a (lazy, inaccurate) colloquialism in the company I worked in at the time (Windows developers being forced to shift to Linux development, and the term stuck), adhering to the descriptions noted above.

Additionally, the trailing &quot;`S`&quot; literal after the library name, in the case of &quot;shared archives&quot; was just a convention used at that company, and not in the industry in general.


Difference between shared objects (.so), static libraries (.a), and DLL&#39;s (.so)?

If I use a `break` statement, it will only break inner loop and I need to use some flag to break the outer loop. But if there are many nested loops, the code will not look good.

Is there any other way to break all of the loops? (Please don&#39;t use `goto stmt`.)


    for(int i = 0; i &lt; 1000; i++) {
       for(int j = 0; j &lt; 1000; j++) {
           if(condition) {
                // both of the loops need to break and control will go to stmt2
           }
       }
    
    }
    
    stmt2


How to break out of nested loops?

I have two gcc compilers installed on my system, one is `gcc 4.1.2` (default) and the other is `gcc 4.4.4`. How can I check the libc version used by `gcc 4.4.4`, because `/lib/libc.so.6` shows the glibc used by `gcc 4.1.2`, since it is the default compiler.

Check glibc version for a particular gcc compiler

I&#39;m attempting to learn C and already I&#39;ve run into an issue. I assume its trivial but I need to know it. I have written:

    #include &lt;stdio.h&gt;
    #include &lt;string.h&gt;

    int main() 
    {
	    char str_a[20];

	    strcpy(str_a, &quot;Hello, world!\n&quot;);
	    printf(str_a);
    }

Once I attempt to compile it with: gcc -g -o char_array2 char_array2.c I receive an error saying:
 
    char_array2.c: In function ‘main’:
    char_array2.c:9:2: warning: format not a string literal and no format arguments [-Wformat-security]

Can anyone help please?


c array - warning: format not a string literal

Just curious, what actually happens if I define a zero-length array `int array[0];` in code? GCC doesn&#39;t complain at all.

__Sample Program__

    #include &lt;stdio.h&gt;

    int main() {
    	int arr[0];
    	return 0;
    }

__Clarification__

I&#39;m actually trying to figure out if zero-length arrays initialised this way, instead of being pointed at like the variable length in Darhazer&#39;s comments, are optimised out or not.

This is because I have to release some code out into the wild, so I&#39;m trying to figure out if I have to handle cases where the `SIZE` is defined as `0`, which happens in some code with a statically defined `int array[SIZE];`

I was actually surprised that GCC does not complain, which led to my question. From the answers I&#39;ve received, I believe the lack of a warning is largely due to supporting old code which has not been updated with the new [] syntax.

Because I was mainly wondering about the error, I am tagging Lundin&#39;s answer as correct (Nawaz&#39;s was first, but it wasn&#39;t as complete) -- the others were pointing out its actual use for tail-padded structures, while relevant, isn&#39;t exactly what I was looking for.

What happens if I define a 0-size array in C/C++?

I have two macros `FOO2` and `FOO3`:

    #define FOO2(x,y) ...
    #define FOO3(x,y,z) ...

I want to define a new macro `FOO` as follows:

    #define FOO(x,y) FOO2(x,y)
    #define FOO(x,y,z) FOO3(x,y,z)

But this doesn&#39;t work because macros do not overload on number of arguments.

Without modifying `FOO2` and `FOO3`, is there some way to define a macro `FOO` (using `__VA_ARGS__` or otherwise) to get the same effect of dispatching `FOO(x,y)` to `FOO2`, and `FOO(x,y,z)` to `FOO3`?


Overloading Macro on Number of Arguments

Apparently macros were dropped from Visual&amp;nbsp;Studio&amp;nbsp;2012.

Is there a plugin/extension/tool that will let me record &amp; play keyboard macros (much like the record/play temporary macro in Visual&amp;nbsp;Studio&amp;nbsp;2010)?

For example, I typically would use a macro when converting code from one language to another or to quickly generate properties from a text list, etc.



Can I record/play macros in Visual Studio 2012/2013/2015/2017/2019?

I want to know if we can have recursive macros in C/C++? If yes, please provide a sample example.

Second thing: why am I not able to execute the below code? What is the mistake I am doing? Is it because of recursive macros?

    # define pr(n) ((n==1)? 1 : pr(n-1))
    void main ()
    {
        int a=5;
        cout&lt;&lt;&quot;result: &quot;&lt;&lt; pr(5) &lt;&lt;endl;
        getch();
    }


Can we have recursive macros?

How can I put comments inside Jinja2 argument list declaration ?

Everything I have tried gives an error:
**jinja2.exceptions.TemplateSyntaxError: unexpected char u&#39;#&#39;**

    {{ Switch(&#39;var&#39;,
    	[(&#39;1&#39;, &#39;foo&#39;),    #  comment 1
    	 (&#39;2&#39;, &#39;bar&#39;),    ## comment 2
    	 (&#39;3&#39;, &#39;rum&#39;),    {# comment 3 #}
    	 ]) }}


    {% macro Switch(var, caselist) %}
    	{% for case, action in caselist%}
    		CMP  {{var}} {{case}} 
    		JNE  {{LABEL}}
    		{{action}}
    		JMP  {{LABELF}}
    {{LABEL}}:	NOP
    	{%- endfor %}
    {{LABELF}}:	NOP
    {%- endmacro -%}

In my case Jinja2 is used as macro preprocessor for assembler.

Jinja2 inline comments

I&#39;ll start with an example. Here&#39;s an equivalent of `List.fill` for tuples as a macro in Scala 2.10:

    import scala.language.experimental.macros
    import scala.reflect.macros.Context
    
    object TupleExample {
      def fill[A](arity: Int)(a: A): Product = macro fill_impl[A]
    
      def fill_impl[A](c: Context)(arity: c.Expr[Int])(a: c.Expr[A]) = {
        import c.universe._
    
        arity.tree match {
          case Literal(Constant(n: Int)) if n &lt; 23 =&gt; c.Expr(
            Apply(
              Select(Ident(&quot;Tuple&quot; + n.toString), &quot;apply&quot;),
              List.fill(n)(a.tree)
            )
          )
          case _ =&gt; c.abort(
            c.enclosingPosition,
            &quot;Desired arity must be a compile-time constant less than 23!&quot;
          )
        }
      }
    }

We can use this method as follows:

    scala&gt; TupleExample.fill(3)(&quot;hello&quot;)
    res0: (String, String, String) = (hello,hello,hello)

This guy is a weird bird in a couple of respects. First, the `arity` argument must be a literal integer, since we need to use it at compile time. In previous versions of Scala there was no way (as far as I know) for a method even to tell whether one of its arguments was a compile-time literal or not.

Second, the `Product` return type [is a lie][1]—the static return type will include the specific arity and element type determined by the arguments, as shown above.

So how would I document this thing? I&#39;m not expecting Scaladoc support at this point, but I&#39;d like to have a sense of conventions or best practices (beyond just making sure the compile-time error messages are clear) that would make running into a macro method—with its potentially bizarre demands—less surprising for users of a Scala 2.10 library.

The most mature demonstrations of the new macro system (e.g., [ScalaMock][2], [Slick][3], the others listed [here][4]) are still relatively undocumented at the method level. Any examples or pointers would be appreciated, including ones from other languages with similar macro systems.


  [1]: https://stackoverflow.com/a/13673950/334519
  [2]: https://github.com/paulbutcher/ScalaMock
  [3]: https://github.com/slick/slick
  [4]: http://scalamacros.org/news/2012/11/05/status-update.html

Content Type	Original Author	Original Content on Stackoverflow
Question	Whoami	View Question on Stackoverflow
Solution 1 - C	zvrba	View Answer on Stackoverflow
Solution 2 - C	Minhas Kamal	View Answer on Stackoverflow

how to use #ifdef with an OR condition?

C Problem Overview

C Solutions

Solution 1 - C

Solution 2 - C

OR condition in #ifdef

Sort objects in an array alphabetically on one property of the array

PostgreSQL DISTINCT ON with different ORDER BY

Attributions