There is the &quot;:&quot; prefix that allows you to give different names to your libraries.
If you use 

    g++ -o build/bin/myapp -l:_mylib.so other_source_files

should search your path for the _mylib.so.

If you can copy the shared library to the working directory when g++ is invoked then this should work:

    g++ -o build/bin/myapp _mylib.so other_source_files



If you are on Unix or Linux I think you can create a symbolic link to the library in the directory you want the library.&lt;br&gt;
&lt;br&gt;
For example:&lt;br&gt;
`ln -s build/bin/_mylib.so build/bin/lib_mylib.so`&lt;br&gt;
&lt;br&gt;
You could then use `-l_mylib`
&lt;br&gt;
&lt;br&gt;
[`http://en.wikipedia.org/wiki/Symbolic_link`][1]


  [1]: http://en.wikipedia.org/wiki/Symbolic_link

I&#39;ve read all the advice on const-correctness in C++ and that it is important (in part) because it helps the compiler to optimize your code. What I&#39;ve never seen is a good explanation on how the compiler uses this information to optimize the code, not even the good books go on explaining what happens behind the curtains.  

For example, how does the compiler optimize a method that is declared const vs one that isn&#39;t but should be. What happens when you introduce mutable variables? Do they affect these optimizations of const methods?

Constants and compiler optimization in C++

I have a JavaScript resource that has the possibility of being edited at any time. Once it is edited I would want it to be propagated to the user&#39;s browser relatively quickly (like maybe 15 minutes or so), however, the frequency of this resource being editing is few and far between (maybe 2 a month).

I&#39;d rather the resource to be cached in the browser, since it will be retrieved frequently, but I&#39;d also like the cache to get reset on the browser at a semi-regular interval.

I know I can pass a no-cache header when I request for the resource, but I was wondering when the cache would automatically reset itself on the browser if I did not pass no-cache.

I imagine this would be independent for each browser, but I&#39;m not sure.

I tried to Google this, but most of the hits I found were about clearing the browser&#39;s cache... which isn&#39;t what I&#39;m looking for.

When does browser automatically clear cache of external JavaScript file?

I have a shared library that I wish to link an executable against using GCC. The shared library has a nonstandard name not of the form libNAME.so, so I can not use the usual -l option. (It happens to also be a Python extension, and so has no &#39;lib&#39; prefix.)

I am able to pass the path to the library file directly to the link command line, but this causes the library path to be hardcoded into the executable.

For example:

    g++ -o build/bin/myapp build/bin/_mylib.so

Is there a way to link to this library without causing the path to be hardcoded into the executable?


How to link using GCC without -l nor hardcoding path for a library that does not follow the libNAME.so naming convention?

I have a shared library that I wish to link an executable against using GCC. The shared library has a nonstandard name not of the form libNAME.so, so I can not use the usual -l option. (It happens to also be a Python extension, and so has no 'lib' prefix.)
I am able to pass the path to the library file directly to the link command line, but this causes the library path to be hardcoded into the executable.
For example:
<pre><code class="hljs language-bash">g++ -o build/bin/myapp build/bin/_mylib.so
</code></pre>
Is there a way to link to this library without causing the path to be hardcoded into the executable?

I have a bunch of enum types in some library header files that I&#39;m using, and I want to have a way of converting enum values to user strings - and vice-versa. 

RTTI won&#39;t do it for me, because the &#39;user strings&#39; need to be a bit more readable than the enumerations.

A brute force solution would be a bunch of functions like this, but I feel that&#39;s a bit too C-like.

    enum MyEnum {VAL1, VAL2,VAL3};
    
    String getStringFromEnum(MyEnum e)
    {
      switch e
      {
      case VAL1: return &quot;Value 1&quot;;
      case VAL2: return &quot;Value 2&quot;;
      case VAL1: return &quot;Value 3&quot;;
      default: throw Exception(&quot;Bad MyEnum&quot;);
      }
    }


I have a gut feeling that there&#39;s an elegant solution using templates, but I can&#39;t quite get my head round it yet.


**UPDATE:** Thanks for suggestions - I should have made clear that the enums are defined in a third-party library header, so I don&#39;t want to have to change the definition of them.

My gut feeling now is to avoid templates and do something like this:


    char * MyGetValue(int v, char *tmp); // implementation is trivial
    
    #define ENUM_MAP(type, strings) char * getStringValue(const type &amp;T) \
     { \
     return MyGetValue((int)T, strings); \
     }
    
    ; enum eee {AA,BB,CC}; - exists in library header file 
    ; enum fff {DD,GG,HH}; 
    
    ENUM_MAP(eee,&quot;AA|BB|CC&quot;)
    ENUM_MAP(fff,&quot;DD|GG|HH&quot;)

    // To use...

		eee e;
		fff f;
		std::cout&lt;&lt; getStringValue(e);
		std::cout&lt;&lt; getStringValue(f);


How to easily map c++ enums to strings

Very basic question: how do I write a `short` literal in C++?

I know the following:

* `2` is an `int`
* `2U` is an `unsigned int`
* `2L` is a `long`
* `2LL` is a `long long`
* `2.0f` is a `float`
* `2.0` is a `double`
* `&#39;\2&#39;` is a `char`.

But how would I write a `short` literal?  I tried `2S` but that gives a compiler warning.

How do I write a short literal in C++?

C++ guarantees that variables in a compilation unit (.cpp file) are initialised in order of declaration. For number of compilation units this rule works for each one separately (I mean static variables outside of classes).

But, the order of initialization of variables, is undefined across different compilation units.

Where can I see some explanations about this order for gcc and MSVC (I know that relying on that is a very bad idea - it is just to understand the problems that we may have with legacy code when moving to new GCC major and different OS)?

Static variables initialisation order

This Question is almost the same as the previously asked &lt;a href=&quot;https://stackoverflow.com/questions/122208/get-the-ip-address-of-local-computer&quot;&gt;How can I get the IP Address of a local computer?&lt;/a&gt; -Question. However I need to find the IP address(es) of a **Linux Machine**.

So: How do I - programmatically in **C++** - detect the IP addresses of the linux server my application is running on. The servers will have at least two IP addresses and I need a specific one (the one in a given network (the public one)).

I&#39;m sure there is a simple function to do that - but where?

---

To make things a bit clearer:

* The server will obviously have the &quot;localhost&quot;: 127.0.0.1
* The server will have an internal (management) IP address: 172.16.x.x
* The server will have an external (public) IP address: 80.190.x.x

I need to find the external IP address to bind my application to it. Obviously I can also bind to INADDR_ANY (and actually that&#39;s what I do at the moment). I would prefer to detect the public address, though.

How can I get the IP address of a (Linux) machine?

I am just now learning about function pointers and, as I was reading the K&amp;R chapter on the subject, the first thing that hit me was, &quot;Hey, this is kinda like a closure.&quot; I knew this assumption is fundamentally wrong somehow and after a search online I didn&#39;t find really any analysis of this comparison.

So why are C-style function pointers fundamentally different from closures or lambdas? As far as I can tell it has to do with the fact that the function pointer still points to a defined (named) function as opposed to the practice of anonymously defining the function.

Why is passing a function to a function seen as more powerful in the second case, where it is unnamed, than the first where it is just a normal, everyday function that is being passed?

Please tell me how and why I am wrong to compare the two so closely.

Function pointers, Closures, and Lambda

Why is it that `scanf()` needs the `l` in &quot;`%lf`&quot; when reading a `double`, when `printf()` can use &quot;`%f`&quot; regardless of whether its argument is a `double` or a `float`?

Example code:

    double d;
    scanf(&quot;%lf&quot;, &amp;d);
    printf(&quot;%f&quot;, d);


Why does scanf() need &quot;%lf&quot; for doubles, when printf() is okay with just &quot;%f&quot;?

What does the &quot;bus error&quot; message mean, and how does it differ from a [segmentation fault][1]?

  [1]: https://en.wikipedia.org/wiki/Segmentation_fault


What is a bus error? Is it different from a segmentation fault?

I tried &quot;x = y ** e&quot;, but that didn&#39;t work.

How do you do exponentiation in C?

I&#39;ve been thinking a lot lately about how to go about doing functional programming in C (*not* C++).  Obviously, C is a procedural language and doesn&#39;t really support functional programming natively.

Are there any compiler/language extensions that add some functional programming constructs to the language?  GCC provides &lt;a href=&quot;http://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html&quot;&gt;nested functions&lt;/a&gt; as a language extension; nested functions can access variables from the parent stack frame, but this is still a long way away from mature closures.

For example, one thing that I think could be really useful in C is that anywhere where a function pointer is expected, you could be able to pass a lambda expression, creating a closure which decays into a function pointer.  C++0x is going to include lambda expressions (which I think is awesome); however, I&#39;m looking for tools applicable to straight C.

[Edit] To clarify, I&#39;m not trying to solve a particular problem in C that would be more suited to functional programming; I&#39;m merely curious about what tools are out there if I wanted to do so.

What tools are there for functional programming in C?

How hard would it be to use GCC instead of VC++ from within Visual Studio 2008? Obviously, some of the keywords won&#39;t match, and some may not get syntax highlighting (unless you made a new language service).

Is this what a &#39;makefile project&#39; is for, pretty much?

GCC with Visual Studio?

I&#39;m currently working on some logging code that supposed to - among other things - print information about the calling function. This should be relatively easy, standard C++ has a `type_info` class. This contains the name of the typeid&#39;d class/function/etc. but it&#39;s mangled. It&#39;s not very useful. I.e. `typeid(std::vector&lt;int&gt;).name()` returns `St6vectorIiSaIiEE`.

Is there a way to produce something useful from this? Like `std::vector&lt;int&gt;` for the above example. If it only works for non-template classes, that&#39;s fine too.

The solution should work for gcc, but it would be better if I could port it. It&#39;s for logging so it&#39;s not so important that it can&#39;t be turned off, but it should be helpful for debugging.

Unmangling the result of std::type_info::name

I have the following makefile that I use to build a program (a kernel, actually) that I&#39;m working on. Its from scratch and I&#39;m learning about the process, so its not perfect, but I think its powerful enough at this point for my level of experience writing makefiles.

    AS	=	nasm
    CC	=	gcc
    LD	=	ld
    
    TARGET		=	core
    BUILD		=	build
    SOURCES		=	source
    INCLUDE     =   include
    ASM 		= 	assembly
    
    VPATH = $(SOURCES)
    
    CFLAGS	=	-Wall -O -fstrength-reduce -fomit-frame-pointer -finline-functions \
    			-nostdinc -fno-builtin -I $(INCLUDE)
    ASFLAGS	=	-f elf
    
    #CFILES		=	core.c consoleio.c system.c
    CFILES		=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
    SFILES		=	assembly/start.asm
    
    SOBJS	=	$(SFILES:.asm=.o)
    COBJS	=	$(CFILES:.c=.o)
    OBJS	=	$(SOBJS) $(COBJS)
    
    build : $(TARGET).img
    
    $(TARGET).img : $(TARGET).elf
    	c:/python26/python.exe concat.py stage1 stage2 pad.bin core.elf floppy.img
    
    $(TARGET).elf : $(OBJS)
    	$(LD) -T link.ld -o $@ $^
    
    $(SOBJS) : $(SFILES)
    	$(AS) $(ASFLAGS) $&lt; -o $@
    
    %.o: %.c
    	@echo Compiling $&lt;...
    	$(CC) $(CFLAGS) -c -o $@ $&lt;
    	
    #Clean Script - Should clear out all .o files everywhere and all that.
    clean:
    	-del *.img
    	-del *.o
    	-del assembly\*.o
    	-del core.elf



My main issue with this makefile is that when I modify a header file that one or more C files include, the C files aren&#39;t rebuilt. I can fix this quite easily by having all of my header files be dependencies for all of my C files, but that would effectively cause a complete rebuild of the project any time I changed/added a header file, which would not be very graceful.

What I want is for only the C files that *include* the header file I change to be rebuilt, and for the entire project to be linked again. I can do the linking by causing all header files to be dependencies of the target, but I cannot figure out how to make the C files be invalidated when their included header files are newer.

I&#39;ve heard that GCC has some commands to make this possible (so the makefile can somehow figure out which files need to be rebuilt) but I can&#39;t for the life of me find an actual implementation example to look at. Can someone post a solution that will enable this behavior in a makefile?

EDIT: I should clarify, I&#39;m familiar with the concept of putting the individual targets in and having each target.o require the header files. That requires me to be editing the makefile every time I include a header file somewhere, which is a bit of a pain. I&#39;m looking for a solution that can derive the header file dependencies on its own, which I&#39;m fairly certain I&#39;ve seen in other projects.

How can I have a Makefile automatically rebuild source files that include a modified header file? (In C/C++)

This is a second-hand question from an OS development site, but it made me curious since I couldn&#39;t find a decent explanation anywhere.

When compiling and linking a free-standing C++ program using gcc, sometimes a linker error like this occurs:

    out/kernel.o:(.eh_frame+0x11): undefined reference to `__gxx_personality_v0&#39;

This is apparently because this symbol is defined in libstdc++, which is missing in a free-standing environment. Fixing the problem simply requires defining this symbol somewhere:

    void *__gxx_personality_v0;

Which is nice, but I don&#39;t like things that just magically work... So the question is, what is the purpose of this symbol?

What is __gxx_personality_v0 for?

I have a header file  x.h which is included by more than one *.c source files.
This header file has some structure variables defined.

I have put multiple inclusion prevention guard at the beginning of the header file as:

    #ifndef X_H
    #define X_H
    ...
    ..
    //header file declarations and definitons.
    
    
    #endif//X_H


On building I get linker errors related to multiple definitions. I understand the problem.


1. Won&#39;t a multiple inclusion prevention guard at the top of header file as I have, prevent multiple inclusions of the header file x.h and thereby avoid multiple definitions of the variables that are there in x.h?

2. `#pragma` once does not work on this particular compiler, so what is the solution? 
    Someone had posted [this][1] answer to a similar question. It doesn&#39;t seem to work for me. How does this solution work?


  [1]: https://stackoverflow.com/questions/223771/repeated-multiple-definition-errors-from-including-same-header-in-multiple-cpps#223798

Why aren&#39;t my compile guards preventing multiple definition inclusions?

I just ran across the following error (and found the solution online, but it&#39;s not present in Stack Overflow):

&gt; (.gnu.linkonce.[stuff]): undefined
&gt; reference to [method] [object
&gt; file]:(.gnu.linkonce.[stuff]):
&gt; undefined reference to `typeinfo for
&gt; [classname]&#39;

Why might one get one of these &quot;undefined reference to typeinfo&quot; linker errors?

(Bonus points if you can explain what&#39;s going on behind the scenes.)

g++ undefined reference to typeinfo

I often hear the terms &#39;statically linked&#39; and &#39;dynamically linked&#39;, often in reference to code written in [C][1], [C++][2] or [C#][3]. What are they, what exactly are they talking about, and what are they linking?

  [1]: http://en.wikipedia.org/wiki/C_%28programming_language%29
  [2]: https://en.wikipedia.org/wiki/C++
  [3]: http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29


What do &#39;statically linked&#39; and &#39;dynamically linked&#39; mean?

We have an issue related to a Java application running under a (rather old) FC3 on an Advantech POS board with a Via C3 processor. The java application has several compiled shared libs that are accessed via JNI.

Via C3 processor is supposed to be i686 compatible. Some time ago after installing Ubuntu 6.10 on a MiniItx board with the same processor, I found out that the previous statement is not 100% true. The Ubuntu kernel hanged on startup due to the lack of some specific and optional instructions of the i686 set in the C3 processor. These instructions missing in C3 implementation of i686 set are used by default by GCC compiler when using i686 optimizations. The solution, in this case, was to go with an i386 compiled version of Ubuntu distribution.

The base problem with the Java application is that the FC3 distribution was installed on the HD by cloning from an image of the HD of another PC, this time an Intel P4. Afterwards, the distribution needed some hacking to have it running such as replacing some packages (such as the kernel one) with the i386 compiled version.

The problem is that after working for a while the system completely hangs without a trace. I am afraid that some i686 code is left somewhere in the system and could be executed randomly at any time (for example after recovering from suspend mode or something like that).

My question is: 

  - Is there any tool or way to find out at what specific architecture extensions a binary file (executable or library) requires? `file` does not give enough information.


Determine target ISA extensions of binary file in Linux (library or executable)

I have two applications under `tomcat/webapps` folder.   

    tomcat/webapps/App1
    tomcat/webapps/App2

Both applications share the same libraries. Which are stored for example in `tomcat/webapps/App1/WEB-INF/lib`.

Are both libraries loaded twice in memory?

Should I put these shared libraries in `tomcat/server/lib`?


Does Tomcat load the same library file into memory twice if they are in two web apps?

I am attempting to link an application with g++ on this Debian lenny system. ld is complaining it cannot find specified libraries. The specific example here is ImageMagick, but I am having similar problems with a few other libraries too.

I am calling the linker with:

    g++ -w (..lots of .o files/include directories/etc..) \
    -L/usr/lib -lmagic

ld complains:

    /usr/bin/ld: cannot find -lmagic

However, libmagic exists:

	$ locate libmagic.so
	/usr/lib/libmagic.so.1
	/usr/lib/libmagic.so.1.0.0
	$ ls -all /usr/lib/libmagic.so.1*
	lrwxrwxrwx 1 root root    17 2008-12-01 03:52 /usr/lib/libmagic.so.1 -&gt; libmagic.so.1.0.0
	-rwxrwxrwx 1 root root 84664 2008-09-09 00:05 /usr/lib/libmagic.so.1.0.0
	$ ldd /usr/lib/libmagic.so.1.0.0 
		linux-gate.so.1 =&gt;  (0xb7f85000)
		libz.so.1 =&gt; /usr/lib/libz.so.1 (0xb7f51000)
		libc.so.6 =&gt; /lib/i686/cmov/libc.so.6 (0xb7df6000)
		/lib/ld-linux.so.2 (0xb7f86000)
	$ sudo ldconfig -v | grep &quot;libmagic&quot;
		libmagic.so.1 -&gt; libmagic.so.1.0.0

How do I diagnose this problem further, and what could be wrong? Am I doing something completely stupid?


ld cannot find an existing library

Some platforms mandate that you provide a list of a shared library&#39;s external symbols to the linker. However, on most unixish systems that&#39;s not necessary: all non-static symbols will be available by default.

My understanding is that the GNU toolchain can optionally restrict visibility just to symbols explicitly declared. How can that be achieved using GNU ld?

Limiting visibility of symbols when linking shared libraries

Program is part of the Xenomai test suite, cross-compiled from Linux PC into Linux+Xenomai ARM toolchain.

    # echo $LD_LIBRARY_PATH                                                                                                                                          
    /lib                                                                                                                                                             
    # ls /lib                                                                                                                                                        
    ld-2.3.3.so         libdl-2.3.3.so      libpthread-0.10.so                                                                                                       
    ld-linux.so.2       libdl.so.2          libpthread.so.0                                                                                                          
    libc-2.3.3.so       libgcc_s.so         libpthread_rt.so                                                                                                         
    libc.so.6           libgcc_s.so.1       libstdc++.so.6                                                                                                           
    libcrypt-2.3.3.so   libm-2.3.3.so       libstdc++.so.6.0.9                                                                                                       
    libcrypt.so.1       libm.so.6                                                                                                                                    
    # ./clocktest                                                                                                                                                    
    ./clocktest: error while loading shared libraries: libpthread_rt.so.1: cannot open shared object file: No such file or directory                                 

**Edit:** OK I didn&#39;t notice the .1 at the end was part of the filename. What does that mean anyway?


Content Type	Original Author	Original Content on Stackoverflow
Question	kbluck	View Question on Stackoverflow
Solution 1 - C++	David Nehme	View Answer on Stackoverflow
Solution 2 - C++	Robert Gamble	View Answer on Stackoverflow
Solution 3 - C++	Chris Roland	View Answer on Stackoverflow

How to link using GCC without -l nor hardcoding path for a library that does not follow the libNAME.so naming convention?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

When does browser automatically clear cache of external JavaScript file?

Constants and compiler optimization in C++

Attributions