I had declared a Boolean variable `bool abc;` in a class and thought that it would be false by default. An *if* condition in my program, `if (abc)`, turned out to be true, so I output the value of abc, and saw that it contained the value 55. Is this normal?

Do we always have to assign &#39;bool abc=false&#39; to be sure that it is false?






Aren&#39;t Boolean variables always false by default?

The android app I am working on overrides the Application class to store lightweight state (username, gps location, etc) in static vars.  Most of this state is set in OnCreate of the launch activity (username retrieved from prefs, location listener runs).  Is it safe to rely on the launch activity to initialize the Application class?  Are there any cases where the Application class might be re-created without the Launch activity also being created?  

The question comes up because I ran into a null pointer exception accessing a variable in the Application class on resuming the app after the phone was asleep for several hours (the app was left in the foreground before phone went to sleep).  Is it possible that the process was killed while the phone was asleep and on waking the phone, the Application class was re-created, the top activity in the stack was resumed, but the launch activity.onCreate wasn&#39;t run thus the Application class wasn&#39;t initialized?

Note that I have tried to test these kinds of scenarios by Forcing the App to stop using Settings / Manage applications.  However, I&#39;m not able to recreate the problem.  On the next run, the Application class is created,  followed by the launch activity.onCreate.


**Is it safe to assume that the Application class instance will exist as long as the process, and that when the Application class is created it is equivalent to &quot;restarting&quot; the application ie. start with a new activity stack (and first activity on stack is the launch activity)?**

Android Application Class Lifecycle

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?

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


We use stack traces in proprietary `assert` like macro to catch developer mistakes - when error is caught, stack trace is printed.


I find gcc&#39;s pair `backtrace()`/`backtrace_symbols()` methods insufficient:

1. Names are mangled
2. No line information

1st problem can be resolved by [abi::__cxa_demangle][1].

However 2nd problem s more tough. I found [replacement for backtrace_symbols()][2]. 
This is better than gcc&#39;s backtrace_symbols(), since it can retrieve line numbers (if compiled with -g) and you don&#39;t need to compile with -rdynamic.

Hoverer the code is GNU licenced, so IMHO I can&#39;t use it in commercial code.

Any proposal?

**P.S.**

gdb is capable to print out arguments passed to functions. 
     Probably it&#39;s already too much to ask for :)

**PS 2**

[Similar question][3] (thanks nobar)


  [1]: http://gcc.gnu.org/onlinedocs/libstdc++/manual/ext_demangling.html
  [2]: http://cairo.sourcearchive.com/documentation/1.9.4/backtrace-symbols_8c-source.html
  [3]: https://stackoverflow.com/questions/77005/how-to-generate-a-stacktrace-when-my-gcc-c-app-crashes

How to get a stack trace for C++ using gcc with line number information?

Does anybody have an idea how to statically compile any resource file right into the executable or the shared library file using GCC?

For example I&#39;d like to add image files that never change (and if they do, I&#39;d have to replace the file anyway) and wouldn&#39;t want them to lie around in the file system.

If this is possible (and I think it is because Visual C++ for Windows can do this, too), how can I load the files which are stored in the own binary? Does the executable parse itself, find the file and extract the data out of it?

Maybe there&#39;s an option for GCC which I haven&#39;t seen yet. Using search engines didn&#39;t really spit out the right stuff.

I would need this to work for shared libraries and normal ELF-executables.

C/C++ with GCC: Statically add resource files to executable/library

When I compile a very simple source file with gcc I don&#39;t have to specify the path to standard include files such as stdio or stdlib.

How does GCC know how to find these files?

Does it have the `/usr/include` path hardwired inside, or it will get the paths from other OS components?

What are the GCC default include directories?

How do I convert a `char` to an `int` in C and C++?

Convert char to int in C and C++

I have some C code for Android that does lots of low-level number crunching. I&#39;d like to know what settings I should use (e.g. for my Android.mk and Application.mk) files so that the code produced will run on all current Android devices but also takes advantage of optimisations for specific chipsets. I&#39;m looking for good default Android.mk and Application.mk settings to use and I want to avoid having to litter my C code with #ifdef branches.

For example, I&#39;m aware that ARMv7 has floating point instructions and some ARMv7 chips support NEON instructions and that the default ARM supports neither of these. Is it possible to set flags so that I can build ARMv7 with NEON, ARMv7 without NEON and the default ARM build? I&#39;m know how to do the latter two but not all 3. I&#39;m cautious about what settings I use as I assume the current defaults are the safest settings and what risks other options have.

For GCC specific optimisation, I&#39;m using the following flags:

    LOCAL_CFLAGS=-ffast-math -O3 -funroll-loops

I&#39;ve checked all 3 of these speed up my code. Are there any other common ones I could add?

Another tip I have is to add &quot;LOCAL_ARM_MODE := arm&quot; to Android.mk to enable a speed up on newer arm chips (although I&#39;m confused at exactly what this does and what happens on older chips).


Producing optimised NDK code for multiple architectures?

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?

Is snprintf always null terminating the destination buffer?

In other words, is this sufficient:

    char dst[10];

    snprintf(dst, sizeof (dst), &quot;blah %s&quot;, somestr);

or do you have to do like this, if somestr is long enough?

    char dst[10];

    somestr[sizeof (dst) - 1] = &#39;\0&#39;;
    snprintf(dst, sizeof (dst) - 1, &quot;blah %s&quot;, somestr);


I am interested both in what the standard says and what some popular libc might do which is not standard behavior.



Is snprintf() ALWAYS null terminating?

**Short version of question:**
How can I get gdb to use the debugging symbols for `libc`?

**Longer version:**
I am debugging a program with gdb and I want to see information about a futex used by `libc`. However, at some point during debugging I get output such as:

    Catchpoint 2 (call to syscall futex), 0x00007ffff772b73e in ?? () from /lib/libc.so.6
    (gdb) bt
    #0  0x00007ffff772b73e in ?? () from /lib/libc.so.6
    #1  0x00007ffff767fb90 in ?? () from /lib/libc.so.6
    #2  0x00007ffff767a4c0 in vfprintf () from /lib/libc.so.6
    #3  0x00007ffff768565a in printf () from /lib/libc.so.6
    ....

When I run `info sharedlibrary` in gdb at the breakpoint I see:

    (gdb) info sharedlibrary
    From                To                  Syms Read   Shared Object Library
    0x00007ffff7dddaf0  0x00007ffff7df6704  Yes (*)     /lib64/ld-linux-x86-64.so.2
    0x00007ffff7bc53e0  0x00007ffff7bd1388  Yes (*)     /lib/libpthread.so.0
    0x00007ffff79ba190  0x00007ffff79bd7d8  Yes (*)     /lib/librt.so.1
    0x00007ffff76538c0  0x00007ffff7766c60  Yes (*)     /lib/libc.so.6
    0x00007ffff6c1fd80  0x00007ffff6c303c8  Yes (*)     /lib/libgcc_s.so.1
    (*): Shared library is missing debugging information.

And when I run `ldd` I see:

	linux-vdso.so.1 =&gt;  (0x00007ffff7fde000)
	libpthread.so.0 =&gt; /lib/libpthread.so.0 (0x00007ffff7dbf000)
	librt.so.1 =&gt; /lib/librt.so.1 (0x00007ffff7bb6000)
	libc.so.6 =&gt; /lib/libc.so.6 (0x00007ffff7833000)
	/lib64/ld-linux-x86-64.so.2 (0x00007ffff7fdf000)

I am using Ubuntu 10.04 and I think that the version of `libc` with debug symbols is in `/usr/lib/debug/lib`.  I tried setting my `LD_LIBRARY_PATH` variable to have this at the front of the path but that did not seem to make a difference.

I&#39;m not completely clear on how the program chooses which shared libraries to load, whether this is set at runtime or compile time (I sort of assumed runtime but now I&#39;m not sure).  So information on how to get gdb to use the debug version of `libc` is appreciated.


How to use debug version of libc

A student asked the question and I didn&#39;t know for sure.  

Guesses include: &quot;counted&quot;, &quot;clearing&quot;, &quot;chunked&quot;, &quot;complete&quot;, ...

The standard library documentation doesn&#39;t say what it stands for and there aren&#39;t similarly named functions that would indicate a pattern.  Does anyone know the actual etymology and perhaps have an authoritative reference to back it up?

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

Gcc Problem Overview

Gcc Solutions

Android Application Class Lifecycle

Aren't Boolean variables always false by default?

Attributions