&lt;code&gt;CPPFLAGS&lt;/code&gt; is supposed to be for flags for the **C** &lt;b&gt;P&lt;/b&gt;re&lt;b&gt;P&lt;/b&gt;rocessor; &lt;code&gt;CXXFLAGS&lt;/code&gt; is for flags for the C++ compiler.

The default rules in make (on my machine, at any rate) pass &lt;code&gt;CPPFLAGS&lt;/code&gt; to just about everything, &lt;code&gt;CFLAGS&lt;/code&gt; is only passed when compiling and linking C, and &lt;code&gt;CXXFLAGS&lt;/code&gt; is only passed when compiling and linking C++.


By default, `CPPFLAGS` will be given to the C preprocessor, while `CXXFLAGS` will be given to the C++ compiler.

The [GNU Make Manual](http://www.gnu.org/software/make/manual/) is a good resource for questions like this (see [Implicit Variables](http://www.gnu.org/software/make/manual/html_node/Implicit-Variables.html#Implicit-Variables)).

CPPFLAGS are for the C preprocessor, while CXXFLAGS are for the C++ compiler.

See &lt;a href=&quot;https://www.gnu.org/software/make/manual/html_node/Implicit-Variables.html&quot;&gt;here&lt;/a&gt;.

By default, they&#39;re set to something.

In practice, you need to know what every single project does.  Virtually no one uses those defaults built into make, and if you rely on, for example, CPPFLAGS meaning &quot;flags to the C preprocessor&quot; you&#39;ll find that the project you care about has used it to mean &quot;flags to the C++ compiler&quot; instead.  And does the CFLAGS flag get passed to C++ compile lines?  Sometimes.  Not always.  Etc, etc, etc.

Although people seem to like to [complain][1] about C++, I haven&#39;t been able to find much evidence as to why you would want to choose C over C++. C doesn&#39;t seem to get nearly as much flak and if C++ has all these problems why can&#39;t you just restrict yourself to the C subset? What are your thoughts/experience?


  [1]: http://odgaard.org/jeod/funny/interview.html
  [2]: http://stackoverflow.com/questions/482574/whats-the-advantage-of-using-c-over-c-or-is-there-one

Why would anybody use C over C++?

Does anyone know why  `java.lang.Number` does not implement `Comparable`? This means that you cannot sort `Number`s with `Collections.sort` which seems to me a little strange.

**Post discussion update:**

Thanks for all the helpful responses. I ended up doing [some more research about this topic][1].

The simplest explanation for why java.lang.Number does not implement Comparable is rooted in mutability concerns.

For a bit of review, `java.lang.Number` is the abstract super-type of `AtomicInteger`, `AtomicLong`, `BigDecimal`, `BigInteger`, `Byte`, `Double`, `Float`, `Integer`, `Long` and `Short`. On that list, `AtomicInteger` and `AtomicLong` to do not implement `Comparable`.

Digging around, I discovered that it is not a good practice to implement `Comparable` on mutable types because the objects can change during or after comparison rendering the result of the comparison useless. Both `AtomicLong` and `AtomicInteger` are mutable. The API designers had the forethought to not have `Number` implement `Comparable` because it would have constrained implementation of future subtypes. Indeed, `AtomicLong` and `AtomicInteger` were added in Java 1.5 long after `java.lang.Number` was initially implemented.

Apart from mutability, there are probably other considerations here too. A `compareTo` implementation in `Number` would have to promote all numeric values to `BigDecimal` because it is capable of accommodating all the `Number` sub-types. The implication of that promotion in terms of mathematics and performance is a bit unclear to me, but my intuition finds that solution kludgy.


  [1]: http://radioeiffel.blogspot.com/2009/02/what-java-can-sort-numbers.html

Why doesn&#39;t java.lang.Number implement Comparable?

What&#39;s the difference between CPPFLAGS and CXXFLAGS in GNU Make?

Difference between CPPFLAGS and CXXFLAGS in GNU Make

<p>What's the difference between CPPFLAGS and CXXFLAGS in GNU Make?</p>


I am writing a Makefile with a lot of repetitive stuff, e.g.

    debug_ifort_Linux:
            if [ $(UNAME) = Linux ]; then                           \
              $(MAKE) FC=ifort FFLAGS=$(difort) PETSC_FFLAGS=&quot;...&quot;  \
                      TARGET=$@ LEXT=&quot;ifort_$(UNAME)&quot; -e syst;      \
            else                                                    \
              echo $(err_arch);                                     \
              exit 1;                                               \
            fi

where the target &#39;syst&#39; is defined, the variable &#39;UNAME&#39; is defined (and is usually Linux, but might also by Cygwin or OSF1) and the variables &#39;difort&#39; and &#39;err_arch&#39; are also defined. This block of code is used very many times for different compiler targets (using a name convention of &#39;&lt;debug|profile|optim&gt;_&lt;compiler&gt;_&lt;uname&gt;&#39;). Since this is a huge amount of redundant code, I would like to be able to write it in a more simple manner. E.g., I would like to do something like this:

    debug_ifort_Linux:
            compile(uname,compiler,flags,petsc_flags,target,lext)

where compile could be a function doing the code above based on the arguments. Does anyone have any idea how I could accomplish this?

Functions in Makefile

What is the usage of the -I and -L flags in a makefile?


What is the difference between -I and -L in makefile?

A few years ago, I read the [Recursive Make Considered Harmful](http://aegis.sourceforge.net/auug97.pdf) paper and implemented the idea in my own build process.  Recently, I read another article with ideas about how to [implement non-recursive `make`](http://sites.e-advies.nl/nonrecursive-make.html).  So I have a few data points that non-recursive `make` works for at least a few projects.

But I&#39;m curious about the experiences of others.  Have you tried non-recursive `make`?  Did it make things better or worse?  Was it worth the time?

What is your experience with non-recursive make?

I often find [Bash][1] syntax very helpful, e.g. process substitution like in `diff &lt;(sort file1) &lt;(sort file2)`.

Is it possible to use such Bash commands in a Makefile? I&#39;m thinking of something like this:

    file-differences:
        diff &lt;(sort file1) &lt;(sort file2) &gt; $@

In my GNU Make 3.80 this will give an error since it uses the `shell` instead of `bash` to execute the commands.

  [1]: http://en.wikipedia.org/wiki/Bash_%28Unix_shell%29


How can I use Bash syntax in Makefile targets?

I want to create a makefile variable that is a multi-line string (e.g. the body of an email release announcement).  something like

    ANNOUNCE_BODY=&quot;
    Version $(VERSION) of $(PACKAGE_NAME) has been released
    
    It can be downloaded from $(DOWNLOAD_URL)
    
    etc, etc&quot;

But I can&#39;t seem to find a way to do this.  Is it possible?

Is it possible to create a multi-line string variable in a Makefile

Recently, I switched my development environment from Windows to Linux. So far, I have only used Visual Studio for C++ development, so many concepts, like [make][1] and [Autotools][2], are new to me. I have read the GNU makefile documentation and got almost an idea about it. But I am kind of confused about Autotools.

As far as I know, makefiles are used to make the build process easier.

 1. Why do we need tools like *Autotools* just for creating the makefiles? Since all knows how to create a makefile, I am not getting the real use of Autotools.
 2. What is the standard? Do we need to use tools like this or would just handwritten makefiles do?

  [1]: http://en.wikipedia.org/wiki/Make_%28software%29
  [2]: http://en.wikipedia.org/wiki/GNU_build_system


Why use build tools like Autotools when we can just write our own makefiles?

I have the following makefile for my project, and I&#39;d like to configure it for release and debug builds. In my code, I have lots of `#ifdef DEBUG` macros in place, so it&#39;s simply a matter of setting this macro and adding the `-g3 -gdwarf2` flags to the compilers. How can I do this?

    $(CC) = g++ -g3 -gdwarf2
    $(cc) = gcc -g3 -gdwarf2
    
    all: executable
    
    executable: CommandParser.tab.o CommandParser.yy.o Command.o
    	g++ -g -o output CommandParser.yy.o CommandParser.tab.o Command.o -lfl
    
    CommandParser.yy.o: CommandParser.l 
    	flex -o CommandParser.yy.c CommandParser.l
    	gcc -g -c CommandParser.yy.c
    
    CommandParser.tab.o: CommandParser.y
    	bison -d CommandParser.y
    	g++ -g -c CommandParser.tab.c
    
    Command.o: Command.cpp
    	g++ -g -c Command.cpp
    
    clean:
    	rm -f CommandParser.tab.* CommandParser.yy.* output *.o

Just to clarify, when I say release/debug builds, I want to be able to just type `make` and get a release build or `make debug` and get a debug build, without manually commenting out things in the makefile.


How can I configure my makefile for debug and release builds?

I am trying to understand the difference between &#39;gmake&#39; and &#39;make&#39;?  

On my linux box they are identical:

    % gmake --version
    GNU Make 3.81
    Copyright (C) 2006  Free Software Foundation, Inc.
    This is free software; see the source for copying conditions.
    There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A
    PARTICULAR PURPOSE.

    % make --version
    GNU Make 3.81
    Copyright (C) 2006  Free Software Foundation, Inc.
    This is free software; see the source for copying conditions.
    There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A
    PARTICULAR PURPOSE.

I am guessing this isn&#39;t the same on all platforms?
Is there a good reason to use one over the other?  
Is there some historical significance to why there are the two names?




What is the difference between gmake and make?

Ever since I learned about -j I&#39;ve used -j8 blithely.  The other day I was compiling an atlas installation and the make failed.  Eventually I tracked it down to things being made out of order - and it worked fine once I went back to singlethreaded make.  This makes me nervous.  What sort of conditions do I need to watch for when writing my own make files to avoid doing something unexpected with make -j?

Content Type	Original Author	Original Content on Stackoverflow
Question	elasticrat	View Question on Stackoverflow
Solution 1 - Makefile	Kieron	View Answer on Stackoverflow
Solution 2 - Makefile	Christoph	View Answer on Stackoverflow
Solution 3 - Makefile	starblue	View Answer on Stackoverflow
Solution 4 - Makefile	James Moore	View Answer on Stackoverflow

Difference between CPPFLAGS and CXXFLAGS in GNU Make

Makefile Problem Overview

Makefile Solutions

Solution 1 - Makefile

Solution 2 - Makefile

Solution 3 - Makefile

Solution 4 - Makefile

Why doesn't java.lang.Number implement Comparable?

Why would anybody use C over C++?

Attributions