There are two ways to achieve that:

 - Use `-rpath` linker option:

`gcc XXX.c -o xxx.out -L$HOME/.usr/lib -lXX -Wl,-rpath=/home/user/.usr/lib`


 - Use `LD_LIBRARY_PATH` environment variable - put this line in your `~/.bashrc` file:

    `export LD_LIBRARY_PATH=/home/user/.usr/lib`

This will work even for a pre-generated binaries, so you can for example download some packages from the [debian.org][1], unpack the binaries and shared libraries into your home directory, and launch them without recompiling.

  [1]: http://packages.debian.org/ &quot;debian.org&quot;

For a quick test, you can also do (in bash at least):

    LD_LIBRARY_PATH=/home/user/.usr/lib ./xxx.out

which has the advantage of not changing your library path for everything else.

Should it be `LIBRARY_PATH` instead of `LD_LIBRARY_PATH`. 
gcc checks for `LIBRARY_PATH` which can be seen with `-v` option

Is there a function I can apply to a string that will return true of false if a string contains a character. 

I have strings with one or more character options such as:

    var abc = &quot;s&quot;;
    var def = &quot;aB&quot;;
    var ghi = &quot;Sj&quot;;

What I would like to do for example is have a function that would return true or false if the above contained a lower or upper case &quot;s&quot;.

    if (def.Somefunction(&quot;s&quot;) == true) { }

Also in C# do I need to check if something is true like this or could I just remove the &quot;== true&quot; ?

How can I check if a string contains a character in C#?

I know that I can use the verbose syntax for properties:

    private string _postalCode;

    public string PostalCode
    {
        get { return _postalCode; }
        set { _postalCode = value; }
    }

Or I can use auto-implemented properties.

    public string PostalCode { get; set; }

Can I somehow access the backing field that is behind the auto-implemented property? (In this example that would be _**postalCode**). 

----------
**Edit**: My question is not about design, but rather about, let&#39;s say, theoretical ability to do so.

Is it possible to access backing fields behind auto-implemented properties?

There is a laptop on which I have no root privilege. 

onto the machine I have a library installed using `configure --prefix=$HOME/.usr` .

after that, I got these files in `~/.usr/lib` :

    libXX.so.16.0.0
    libXX.so.16
    libXX.so
    libXX.la
    libXX.a

when I compile a program that invokes one of function provided by the library with this command :
`gcc XXX.c -o xxx.out -L$HOME/.usr/lib -lXX`

xxx.out was generated without warning, but when I run it error like this was thrown:

`./xxx.out: error while loading shared libraries: libXX.so.16: cannot open shared object file: No such file or directory` , though `libXX.so.16` resides there.

my clue-less assumption is that `~/.usr/lib` wasn&#39;t searched when xxx.out is invoked.
but what can I do to specify path of .so , in order that xxx.out can look there for .so file?




An addition is when I feed `-static` to gcc, another error happens like this:

    undefined reference to `function_proviced_by_the_very_librar&#39;

It seems `.so` does not matter even though `-L` and `-l` are given to gcc.
what should I do to build a usable exe with that library?

------------------
### For other people who has the same question as I did

I found [a useful article at tldp](http://tldp.org/HOWTO/Program-Library-HOWTO/index.html) about this.

It introduces static/shared/dynamic loaded library, as well as some example code to use them.

How to specify non-default shared-library path in GCC Linux? Getting &quot;error while loading shared libraries&quot; when running

There is a laptop on which I have no root privilege.
onto the machine I have a library installed using <code>configure --prefix=$HOME/.usr</code> .
after that, I got these files in <code>~/.usr/lib</code> :
<pre><code class="hljs">libXX.so.16.0.0
libXX.so.16
libXX.so
libXX.la
libXX.a
</code></pre>
when I compile a program that invokes one of function provided by the library with this command :
<code>gcc XXX.c -o xxx.out -L$HOME/.usr/lib -lXX</code>
xxx.out was generated without warning, but when I run it error like this was thrown:
<code>./xxx.out: error while loading shared libraries: libXX.so.16: cannot open shared object file: No such file or directory</code> , though <code>libXX.so.16</code> resides there.
my clue-less assumption is that <code>~/.usr/lib</code> wasn't searched when xxx.out is invoked.
but what can I do to specify path of .so , in order that xxx.out can look there for .so file?
An addition is when I feed <code>-static</code> to gcc, another error happens like this:
<pre><code class="hljs language-vbnet">undefined reference to `function_proviced_by_the_very_librar'
</code></pre>
It seems <code>.so</code> does not matter even though <code>-L</code> and <code>-l</code> are given to gcc.
what should I do to build a usable exe with that library?
<hr>
<h5 id="for-other-people-who-has-the-same-question-as-i-did"><a aria-hidden="true" tabindex="-1" href="#for-other-people-who-has-the-same-question-as-i-did"></a>For other people who has the same question as I did</h5>
I found <a href="http://tldp.org/HOWTO/Program-Library-HOWTO/index.html" target="_blank" rel="noopener noreferrer">a useful article at tldp</a> about this.
It introduces static/shared/dynamic loaded library, as well as some example code to use them.

I wrote this simple C program:

&lt;!-- language: c --&gt;

    int main() {
        int i;
        int count = 0;
        for(i = 0; i &lt; 2000000000; i++){
            count = count + 1;
        }
    }

I wanted to see how the gcc compiler optimizes this loop (clearly add *1* 2000000000 times should be &quot;add *2000000000* one time&quot;). So:

**gcc test.c** and then `time` on `a.out` gives:

    real 0m7.717s  
    user 0m7.710s  
    sys 0m0.000s  

**$ gcc -O2 test.c**  and then `time on `a.out` gives: 
 
    real 0m0.003s  
    user 0m0.000s  
    sys	0m0.000s  

Then I disassembled both with `gcc -S`. First one seems quite clear:

        .file &quot;test.c&quot;  
        .text  
    .globl main
        .type	main, @function  
    main:
    .LFB0:
        .cfi_startproc
        pushq	%rbp
        .cfi_def_cfa_offset 16
        movq	%rsp, %rbp
        .cfi_offset 6, -16
        .cfi_def_cfa_register 6
        movl	$0, -8(%rbp)
        movl	$0, -4(%rbp)
        jmp	.L2
    .L3:
        addl	$1, -8(%rbp)
        addl	$1, -4(%rbp)
    .L2:
        cmpl	$1999999999, -4(%rbp)
        jle	.L3
        leave
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
    .LFE0:
        .size	main, .-main
        .ident	&quot;GCC: (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2&quot;
        .section	.note.GNU-stack,&quot;&quot;,@progbits

L3 adds, L2 compare `-4(%rbp)` with `1999999999` and loops to L3 if `i &lt; 2000000000`.

**Now the optimized one:**

        .file &quot;test.c&quot;  
        .text
        .p2align 4,,15
    .globl main
        .type main, @function
    main:
    .LFB0:
        .cfi_startproc
        rep
        ret
        .cfi_endproc
    .LFE0:
        .size main, .-main
        .ident &quot;GCC: (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2&quot;
        .section .note.GNU-stack,&quot;&quot;,@progbits

I can&#39;t understand at all what&#39;s going on there! I&#39;ve got little knowledge of assembly, but I expected something like

    addl $2000000000, -8(%rbp)

I even tried with **gcc -c -g -Wa,-a,-ad -O2 test.c** to see the C code together with the assembly it was converted to, but the result was no more clear that the previous one.  

**Can someone briefly explain:**

 1. The **gcc -S -O2** output.
 2. If the loop is optimized as I expected (one sum instead of many sums)?


How does GCC optimize out an unused variable incremented inside a loop?

If I come across old code that does `if (!this) return;` in an app, how severe a risk is this? Is it a dangerous ticking time bomb that requires an immediate app-wide search and destroy effort, or is it more like a code smell that can be quietly left in place?

I am not planning on *writing* code that does this, of course. Rather, I&#39;ve recently discovered something in an old core library used by many pieces of our app. 

Imagine a `CLookupThingy` class has a *non-virtual* `CThingy *CLookupThingy::Lookup( name )` member function. Apparently one of the programmers back in those cowboy days encountered many crashes where NULL `CLookupThingy *`s were being passed from functions, and rather than fixing hundreds of call sites, he quietly fixed up Lookup():

    CThingy *CLookupThingy::Lookup( name ) 
    {
       if (!this)
       {
          return NULL;
       }
       // else do the lookup code...
    }
    
    // now the above can be used like
    CLookupThingy *GetLookup() 
    {
      if (notReady()) return NULL;
      // else etc...
    }
    
    CThingy *pFoo = GetLookup()-&gt;Lookup( &quot;foo&quot; ); // will set pFoo to NULL without crashing

I discovered this gem earlier this week, but now am conflicted as to whether I ought to fix it. This is in a core library used by all of our apps. Several of those apps have already been shipped to millions of customers, and it seems to be working fine; there are no crashes or other bugs from that code. Removing the `if !this` in the lookup function will mean fixing thousands of call sites that potentially pass NULL; inevitably some will be missed, introducing new bugs that will pop up randomly over the next *year* of development. 

So I&#39;m inclined to leave it alone, unless absolutely necessary.

Given that it is technically undefined behavior, how dangerous is `if (!this)` in practice? Is it worth man-weeks of labor to fix, or can MSVC and GCC be counted on to safely return?

Our app compiles on MSVC and GCC, and runs on Windows, Ubuntu, and MacOS. Portability to other platforms is irrelevant. The function in question is guaranteed to never be virtual.

**Edit:** The kind of objective answer I am looking for is something like

 - &quot;Current versions of MSVC and GCC use an ABI where nonvirtual members are really statics with an implicit &#39;this&#39; parameter; therefore they will safely branch into the function even if &#39;this&#39; is NULL&quot; or 
 - &quot;a forthcoming version of GCC will change the ABI so that even nonvirtual functions require loading a branch target from the class pointer&quot; or 
 - &quot;the current GCC 4.5 has an inconsistent ABI where sometimes it compiles nonvirtual members as direct branches with an implicit parameter, and sometimes as class-offset function pointers.&quot; 

The former means the code is stinky but unlikely to break; the second is something to test after a compiler upgrade; the latter requires immediate action even at high cost. 

Clearly this is a latent bug waiting to happen, but right now I&#39;m only concerned with mitigating risk on our specific compilers.

How bad is &quot;if (!this)&quot; in a C++ member function?

I&#39;m just wondering what the `-fpermissive` flag does in the g++ compiler? I am getting:

&gt;error: taking address of temporary [-fpermissive]

which I can solve by giving the  `-fpermissive` flag to the compiler. 

**EDIT**:
I just found what was causing the temporary address error part! I&#39;m going to fix that part right now.

What does the fpermissive flag do?

When I compile C/C++ program with `popen` in `php`... I got this error:

    g++: error trying to exec &#39;cc1plus&#39;: execvp: No such file or directory

but if I run php code in shell.. it works fine..

in Arch Linux..

PHP Code:

&lt;!-- language: lang-php --&gt;

    &lt;?php
        function rfile($fp) {
        $out=&quot;&quot;;
           while (!feof($fp)) {
               $out.= fgets($fp, 1024000);
           }
           return $out;
        }
        $p = popen(&#39;g++ -Wall -g aplusb.cc -o aplusb 2&gt;&amp;1&#39;, &#39;r&#39;);
        $result = rfile($p);
        pclose($p);
        echo $result;
    ?&gt;

thanks

Compile error: &quot;g++: error trying to exec &#39;cc1plus&#39;: execvp: No such file or directory&quot;

I downloaded GCC 4.5 from http://www.netgull.com/gcc/releases/gcc-4.5.0/ but when I try to setup / build I am getting below error:

    Linux:&gt;~/shared_scripts/bin/gcc/gcc-4.5.0 1040&gt; /x/home/prakash_satya/shared_scripts/bin/gcc/gcc-4.5.0/configure CC=&quot;gcc -m64&quot; --prefix=/x/home/prakash_satya/shared_scripts/bin/gcc/gcc-4.5.0 --with-gmp-lib=/usr/lib64 --with-mpfr-lib=/usr/lib64 --enable-shared --enable-threads=posix --enable-__cxa_atexit --enable-clocale=gnu --enable-languages=c,c++
    checking build system type... x86_64-unknown-linux-gnu
    checking host system type... x86_64-unknown-linux-gnu
    checking target system type... x86_64-unknown-linux-gnu
    checking for a BSD-compatible install... /usr/bin/install -c
    checking whether ln works... yes
    checking whether ln -s works... yes
    checking for a sed that does not truncate output... /bin/sed
    checking for gawk... gawk
    checking for gcc... gcc -m64
    checking for C compiler default output file name... a.out
    checking whether the C compiler works... yes
    checking whether we are cross compiling... no
    checking for suffix of executables...
    checking for suffix of object files... o
    checking whether we are using the GNU C compiler... yes
    checking whether gcc -m64 accepts -g... yes
    checking for gcc -m64 option to accept ISO C89... none needed
    checking for g++... g++
    checking whether we are using the GNU C++ compiler... yes
    checking whether g++ accepts -g... yes
    checking for gnatbind... no
    checking for gnatmake... no
    checking whether compiler driver understands Ada... no
    checking how to compare bootstrapped objects... cmp --ignore-initial=16 $$f1 $$f2
    checking for objdir... .libs
    checking for the correct version of gmp.h... no
    configure: error: Building GCC requires GMP 4.2+, MPFR 2.3.1+ and MPC 0.8.0+.
    Try the --with-gmp, --with-mpfr and/or --with-mpc options to specify
    their locations.  Source code for these libraries can be found at
    their respective hosting sites as well as at
    ftp://gcc.gnu.org/pub/gcc/infrastructure/.  See also
    http://gcc.gnu.org/install/prerequisites.html for additional info.  If
    you obtained GMP, MPFR and/or MPC from a vendor distribution package,
    make sure that you have installed both the libraries and the header
    files.  They may be located in separate packages.
    Linux:&gt;~/shared_scripts/bin/gcc/gcc-4.5.0 1041&gt;

The following libs are present in respective directories 

    /usr/lib/libgmp.a
    /usr/lib64/libgmp.a
    
    /usr/lib/libmpfr.a
    /usr/lib64/libmpfr.a

I do not have libmpc.a library installed anywhere in boxes. 

Based upon the error how can I know :

a) what is the current version of libgmp.a and libmpfr.a are installed.

b) If they are of incorrect version how can I deploy my own version without disturbing the current one?


Building GCC requires GMP 4.2+, MPFR 2.3.1+ and MPC 0.8.0+

 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)?

The [LD manual](http://ftp.gnu.org/old-gnu/Manuals/ld-2.9.1/html_mono/ld.html#SEC2) does not explain what the `KEEP` command does. Below is a snippet from a third-party linker script that features `KEEP`. What does the `KEEP` command do in `ld`?

    SECTIONS
    {  
        .text :
        {
            . = ALIGN(4);
            _text = .;
            PROVIDE(stext = .);
            KEEP(*(.isr_vector))
            KEEP(*(.init))
            *(.text .text.*)        
            *(.rodata .rodata.*)        
            *(.gnu.linkonce.t.*)
            *(.glue_7)
            *(.glue_7t)
            *(.gcc_except_table)
            *(.gnu.linkonce.r.*)
            . = ALIGN(4);
            _etext = .;
    		_sidata = _etext;
            PROVIDE(etext = .);   
         		_fini = . ;
    				*(.fini)
    
        } &gt;flash

What does KEEP mean in a linker script?

What is the way to print the search paths that in looked by **ld** in the order it searches.

How to print the ld(linker) search path

I&#39;m very new to C and I have this code: 

    #include &lt;stdio.h&gt;
    #include &lt;math.h&gt;
    int main(void)
    {
      double x = 0.5;
      double result = sqrt(x);
      printf(&quot;The square root of %lf is %lf\n&quot;, x, result);
      return 0;
    }

But when I compile this with:

    gcc test.c -o test

I get an error like this:

    /tmp/cc58XvyX.o: In function `main&#39;:
    test.c:(.text+0x2f): undefined reference to `sqrt&#39;
    collect2: ld returned 1 exit status


Why does this happen? Is `sqrt()` not in the `math.h` header file? I get the same error with `cosh` and other trigonometric functions. Why?


Why am I getting &quot;undefined reference to sqrt&quot; error even though I include math.h header?

I have a problem regarding FFI in Haskell and the interactive mode of GHC [again][1].

Consider `FFISo.hs`:

    {-# LANGUAGE OverloadedStrings #-}
    module Main where
    
    import qualified Data.ByteString.Char8 as B
    
    import FFIFun.Foo
    
    main :: IO ()
    main = do
      B.putStrLn &quot;main&quot;
      callMeFromC
      callMeFromHaskell
      return ()

`c.c`:

&lt;!-- language: lang-c --&gt;

    #include &lt;stdio.h&gt;
    
    void callMeFromC(void);
    
    void callMeFromHaskell(void)
    {
        printf(&quot;callMeFromHaskell\n&quot;);
        callMeFromC();
    }

`FFIFun/Foo.hs`:

    {-# LANGUAGE OverloadedStrings #-}
    {-# LANGUAGE ForeignFunctionInterface #-}
    module FFIFun.Foo where
    
    import qualified Data.ByteString.Char8 as B
    
    foreign import ccall &quot;callMeFromHaskell&quot;
      callMeFromHaskell :: IO ()
    
    foreign export ccall callMeFromC :: IO ()
    callMeFromC :: IO ()
    callMeFromC = B.putStrLn &quot;callMeFromC&quot;

and a `Makefile`:

&lt;!-- language: none --&gt;

    SHELL := bash
    
    GHC_OPT := -Wall -O2 -fno-warn-unused-do-bind
    
    
    all: ffiso
    
    test: ffiso
        ./$&lt;
    
    ffiso: FFISo.hs c.c
        ghc --make $(GHC_OPT) $^ -o $@
    
    clean:
        rm -rf *{.hi,o,_stub.*} ffiso FFIFun/*{.hi,.o,_stub.*}
    
    ghci: ffiso
        ghci -package bytestring FFIFun/Foo.o c.o FFISo.hs

you find it also [here as a gist][2].

So, my problem now:

&lt;!-- language: none --&gt;

    $ make ghci
    [...]
    Ok, modules loaded: Main, FFIFun.Foo.
    Prelude Main&gt; -- fine, it&#39;s loading.
    Prelude Main&gt; :t callMeFromC
    
    &lt;interactive&gt;:1:1: Not in scope: `callMeFromC&#39;
    Prelude Main&gt; -- uhm, why?
    Prelude Main&gt; :t main
    main :: IO ()
    Prelude Main&gt; main
    
    
    GHCi runtime linker: fatal error: I found a duplicate definition for symbol
       FFIFunziFoo_callMeFromC_info
    whilst processing object file
       ./FFIFun/Foo.o
    This could be caused by:
       * Loading two different object files which export the same symbol
       * Specifying the same object file twice on the GHCi command line
       * An incorrect `package.conf&#39; entry, causing some object to be
         loaded twice.
    GHCi cannot safely continue in this situation.  Exiting now.  Sorry.

Hrmpf, what is wrong here? Interestingly I get an different error on `i686` (above, it&#39;s a `x86_64` system, but both GHC 7.4.1):

&lt;!-- language: none --&gt;

    GHCi runtime linker: fatal error: I found a duplicate definition for symbol
       __stginit_FFIFunziFoo
    whilst processing object file
       ./FFIFun/Foo.o
    This could be caused by:
       * Loading two different object files which export the same symbol
       * Specifying the same object file twice on the GHCi command line
       * An incorrect `package.conf&#39; entry, causing some object to be
         loaded twice.
    GHCi cannot safely continue in this situation.  Exiting now.  Sorry.


Also, is there some documentation about it? I feel like I&#39;m the only one who has hard times with FFI and GHCi out there.

edit:
note, that `make test` works fine:

&lt;!-- language: none --&gt;

    $ ghc --make -Wall -O2 -fno-warn-unused-do-bind FFISo.hs c.c -o ffiso
    [1 of 2] Compiling FFIFun.Foo       ( FFIFun/Foo.hs, FFIFun/Foo.o )
    [2 of 2] Compiling Main             ( FFISo.hs, FFISo.o )
    Linking ffiso ...
    ./ffiso
    main
    callMeFromC
    callMeFromHaskell
    callMeFromC


  [1]: https://stackoverflow.com/questions/10123040/ghci-doesnt-work-with-ffi-export-declarations-shared-libaries
  [2]: https://gist.github.com/2724649

GHCi runtime linker issue when using FFI declarations

When loading shared libraries in Windows, `LoadLibrary()` call causes `DllMain` in library to execute for each new process and thread library attaches to, and for each process and thread library deattaches from.

Is there similar mechanism for Mac OS X, Linux and possibly other POSIX-compatible OSs?

Automatically executed functions when loading shared libraries

I&#39;m currently trying to port a C application to [AIX][1] and am getting confused. What are .a and .so files and how are they used when building/running an application?

  [1]: https://en.wikipedia.org/wiki/IBM_AIX


What are .a and .so files?

When developing for native platform, I can use ldd to list all the shared libraries (.so files) a binary executable I build will try to load upon start-up. But when cross-compiling, I don&#39;t know how to get the same information. The `ldd` is not a normal binutils utility, like `strip` or `ar`, that can be built alongside `gcc` for cross compiling, but instead, it is a cryptic shell script that apparently can only run on native platform.

So, using the cross-target binutils tools, is there any way to get a list of the dynamically linked dependency for of a foreign binary?

How to list library dependencies of a non-native binary?

I found the following command: `strings /usr/lib/libstdc++.so.6 | grep GLIBC` from [here][1]. It seems to work but this is an ad-hoc/heuristic method.

Is there a specific command that can be used to query the library version of C++? Or is the method I found the accepted method?


  [1]: https://stackoverflow.com/questions/5216399/usr-lib-libstdc-so-6-version-glibcxx-3-4-15-not-found

How do you find what version of libstdc++ library is installed on your linux machine?

I have the following layout:

    top_project
        + subproject1
        + subproject2

Each of `subproject1` and `subproject2` creates a static library. I would like to link these static libraries in a single shared library at the `top_project` level.

The information I gathered so far is:

- Either compile using `-fPic` (necessary on everything but Windows) in order to create position-independent code which will allow linking the static libraries into a single shared library or decompress all static libraries (e.g. using `ar`) and re-link them into a shared library (which I think is an inelegant &amp; non-portable solution)
- All source files must be given explicitly to the `add_library` command: for some reason which I cannot comprehend, simply writing `add_library(${PROJECT_NAME} SHARED subproject1 subproject2)` does not work as expected (it essentially creates an empty library &amp; does not register the dependencies properly)
- There is an OBJECT library feature in CMake but I don&#39;t think it&#39;s purpose is really to do what I want.

Any thoughts?

Content Type	Original Author	Original Content on Stackoverflow
Question	Jokester	View Question on Stackoverflow
Solution 1 - Gcc	pelya	View Answer on Stackoverflow
Solution 2 - Gcc	Ashit	View Answer on Stackoverflow

How to specify non-default shared-library path in GCC Linux? Getting "error while loading shared libraries" when running

Gcc Problem Overview

For other people who has the same question as I did

Gcc Solutions

Solution 1 - Gcc

Solution 2 - Gcc

Is it possible to access backing fields behind auto-implemented properties?

How can I check if a string contains a character in C#?

Attributions