On gcc, use `ar -t`.

`-t` option of the [gnu archiver (ar)][1] writes a table of contents of archive to the standard output. Only the files specified by the file operands shall be included in the written list. If no file operands are specified, all files in archive shall be included in the order of the archive.

[More info here][2].


  [1]: http://en.wikipedia.org/wiki/Ar_(Unix)
  [2]: http://www.opengroup.org/onlinepubs/9699919799/utilities/ar.html

You can see the contents (the .o files that went into it) and the defined symbols by using `nm`. If this contains C++ code you should use the `-C` option to demangle the symbol names:

    nm -C libschnoeck.a | less



On a Mac, simply use

    nm libschnoeck.a | less
There is no `-C` option with the Mac version of nm.

It just stumbled over this:

You can open an archive (.a) with 7zip.
Also works for the object files in the archive. 
Listing all sorts of contents like `.text, .bss, .data,` etc. with their `offset, length, type,` ...
Furthermore its possible to unpack all, using a hex editor or notepad++ to view the contents. 
I tested this with an archive created with `GNUToolsARMEmbedded\2018-q4-major\bin\arm-none-eabi-` Toolchain
and `7Zip 16.04 (64-bit)`

I just discovered that you can use `readelf -a` to display the contents of all the object files in a static library.

Invoke the readelf command like this: `$ readelf -a mystaticlib.a`.

I have the following comma-separated string that I need to split. The problem is that some of the content is within quotes and contains commas that shouldn&#39;t be used in the split.

String:

    111,222,&quot;33,44,55&quot;,666,&quot;77,88&quot;,&quot;99&quot;

I want the output:

	111  
	222  
	33,44,55  
	666  
	77,88  
	99  

I have tried this:  

	(?:,?)((?&lt;=&quot;)[^&quot;]+(?=&quot;)|[^&quot;,]+)   
	
But it reads the comma between &quot;77,88&quot;,&quot;99&quot; as a hit and I get the following  output:  

	111  
	222  
	33,44,55  
	666  
	77,88  
	,  
	99  


split a comma-separated string with both quoted and unquoted strings

I&#39;ve been using the `pthread` library for creating &amp; joining threads in C.

1. When should I create a thread as detached, right from the outset? Does it offer any performance advantage vs. a joinable thread?

2. Is it legal to not do a `pthread_join()` on a joinable (by default) thread? Or should such a thread always use the `detach()` function before `pthread_exit()`ing?

Detached vs. Joinable POSIX threads

I have a static library, say `mystaticlib.a`. I want to see its contents, such as the number of object files inside it. 

How can I do this on gcc?

Contents of a static library

<p>I have a static library, say <code>mystaticlib.a</code>. I want to see its contents, such as the number of object files inside it.</p>
<p>How can I do this on gcc?</p>


Or, &quot;how do Russians throw exceptions?&quot;

The definition of std::exception is:

    namespace std {
      class exception {
      public:
        exception() throw();
        exception(const exception&amp;) throw();
        exception&amp; operator=(const exception&amp;) throw();
        virtual ~exception() throw();
        virtual const char* what() const throw();
      };
    }

A [popular school of thought](http://www.parashift.com/c++-faq-lite/exceptions.html#faq-17.12) for designing exception hierarchies is to derive from std::exception:

&gt; Generally, it&#39;s best to throw objects,
&gt; not built-ins. If possible, you should
&gt; throw instances of classes that derive
&gt; (ultimately) from the std::exception
&gt; class. By making your exception class
&gt; inherit (ultimately) from the standard
&gt; exception base-class, you are making
&gt; life easier for your users (they have
&gt; the option of catching most things via
&gt; std::exception), plus you are probably
&gt; providing them with more information
&gt; (such as the fact that your particular
&gt; exception might be a refinement of
&gt; std::runtime_error or whatever).

But in the face of Unicode, it seems to be impossible to design an exception hierarchy that achieves both of the following:

 -  Derives ultimately from std::exception for ease of use at the catch site
 -  Provides Unicode compatibility so that diagnostics are not sliced or gibberish

Coming up with an exception class that can be constructed with Unicode strings is simple enough.  But the standard dictates that what() must return a const char*, so at some point the input strings must be converted to ASCII.  Whether that is done at construction time or when what() is called (if the source string uses characters not representable by 7-bit ASCII), it might be impossible to format the message without loss of fidelity.

How do you design an exception hierarchy that combines the seamless integration of a std::exception-derived class with lossless Unicode diagnostics?


Exceptions with Unicode what()

I am trying to include several third-party libraries in my source tree with minimal changes to their build system for ease of upgrading. They all use CMake, as do I, so in my own CMakeLists.txt I can use `add_subdirectory(extern/foo)` for libfoo.

But the foo CMakeLists.txt compiles a test harness, builds documentation, a shared library which I don&#39;t need, and so on. The libfoo authors had the foresight to control these via options - `option(FOO_BUILD_SHARED &quot;Build libfoo shared library&quot; ON)` for example - which means I can set them via the CMake command line. But I would like to make that off by default and overridable via the command line.

I have tried doing `set(FOO_BUILD_SHARED OFF)` before `add_subdirectory(extern/foo)`. That has the effect of not trying to build the shared library during the second and subsequent build attempts, but not during the first one, which is the one I really need to speed up.

Is this possible, or do I need to maintain forked CMakeLists.txt for these projects?

Overriding a default option(...) value in CMake from a parent CMakeLists.txt

Hallo!

I&#39;m looking for a way to add custom messages to assert statements.
I found this questions https://stackoverflow.com/questions/3692954/add-custom-messages-in-assert but the message is static there. I want to do something like this:

    assert((0 &lt; x) &amp;&amp; (x &lt; 10), std::string(&quot;x was &quot;) + myToString(x));

When the assertion fails I want the normal output plus for example &quot;x was 100&quot;.

Adding message to assert

I&#39;ve heard the term &quot;memory fragmentation&quot; used a few times in the context of C++ dynamic memory allocation.  I&#39;ve found some questions about how to deal with memory fragmentation, but can&#39;t find a direct question that deals with it itself.  So:

 - What is memory fragmentation?
 - How can I tell if memory fragmentation is a problem for my application?  What kind of program is most likely to suffer?
 - What are good common ways to deal with memory fragmentation?

Also:

 - I&#39;ve heard using dynamic allocations a lot can increase memory fragmentation.  Is this true?  In the context of C++, I understand all the standard containers (std::string, std::vector, etc) use dynamic memory allocation.  If these are used throughout a program (especially std::string), is memory fragmentation more likely to be a problem?
 - How can memory fragmentation be dealt with in an STL-heavy application?

What is memory fragmentation?

Is it possible to capture by `const` reference in a lambda expression?

I want the assignment marked below to fail, for example:

    #include &lt;algorithm&gt;
    #include &lt;string&gt;
    
    using namespace std;
    
    int main()
    {
        string strings[] = 
        {
            &quot;hello&quot;,
            &quot;world&quot;
        };
        static const size_t num_strings = sizeof(strings)/sizeof(strings[0]);
    
        string best_string = &quot;foo&quot;;
    
        for_each( &amp;strings[0], &amp;strings[num_strings], [&amp;best_string](const string&amp; s)
          {
            best_string = s; // this should fail
          }
        );
    return 0;
    }

*Update:* As this is an old question, it might be good to update it if there are facilities in C++14 to help with this. Do the extensions in C++14 allow us to capture a non-const object by const reference? (*August 2015*)

Lambda capture as const reference?

Suppose you have a string which is NOT `null` terminated and you know its exact size, so how can you print that string with `printf` in C? I recall such a method but I can not find out now...

Using printf with a non-null terminated string

Hey, I&#39;m looking to convert a int that is inputed by the user into 4 bytes, that I am assigning to a character array. How can this be done?

Example:

Convert a user inputs of 175 to

`00000000 00000000 00000000 10101111`

-------------------------------------------------------

Issue with all of the answers so far, converting 255 should result in `0 0 0 ff` although it prints out as: `0 0 0 ffffffff`


    unsigned int value = 255;	
    
    buffer[0] = (value &gt;&gt; 24) &amp; 0xFF;
    buffer[1] = (value &gt;&gt; 16) &amp; 0xFF;
    buffer[2] = (value &gt;&gt; 8) &amp; 0xFF;
    buffer[3] = value &amp; 0xFF;
    
    union {
    	unsigned int integer;
    	unsigned char byte[4];
    } temp32bitint;
    
    temp32bitint.integer = value;
    buffer[8] = temp32bitint.byte[3];
    buffer[9] = temp32bitint.byte[2];
    buffer[10] = temp32bitint.byte[1];
    buffer[11] = temp32bitint.byte[0];

both result in `0 0 0 ffffffff` instead of `0 0 0 ff`

Just another example is 175 as the input prints out as `0, 0, 0, ffffffaf` when it should just be `0, 0, 0, af`

Converting an int into a 4 byte char array (C)

In C bitwise left shift operation invokes Undefined Behaviour when the left side operand has negative value.

Relevant quote from ISO C99 (6.5.7/4)

&gt; The  result  of E1 &lt;&lt; E2 is E1 left-shifted E2 bit  positions;  vacated  bits  are  ﬁlled  with zeros.  If E1 has an unsigned type, the value of the result is E1 &#215; 2&lt;sup&gt;E2&lt;/sup&gt;, reduced modulo
one more than the maximum value representable in the result type.  If E1 has a signed
type and nonnegative value, and E1 &#215; 2&lt;sup&gt;E2&lt;/sup&gt; is representable in the result type, then that is
the resulting value; otherwise, **the behavior is undeﬁned**.

But in C++ the behaviour is well defined.

ISO C++-03 (5.8/2)

&gt;The value of E1 &lt;&lt; E2 is E1 (interpreted as a bit pattern) left-shifted E2 bit positions; vacated bits are zero-filled.  If E1 has an unsigned type, the value of the result is E1 multiplied by the quantity 2 raised to the power E2, reduced modulo ULONG_MAX+1 if E1 has type unsigned long, UINT_MAX+1 otherwise.
[Note: the constants ULONG_MAXand UINT_MAXare defined in the header &lt;climits&gt;).  ]

That means

    int a = -1, b=2, c;
    c= a &lt;&lt; b ;

invokes Undefined Behaviour in C but the behaviour is well defined in C++.

What forced the ISO C++ committee to consider that behaviour well defined as opposed to the behaviour in C?

On the other hand the behaviour is `implementation defined` for bitwise right shift operation when the left operand is negative, right?

My question is why does left shift operation invoke Undefined Behaviour in C and why does right shift operator invoke just Implementation defined behaviour?

P.S : Please don&#39;t give answers like &quot;It is undefined behaviour because the Standard says so&quot;. :P






Why does left shift operation invoke Undefined Behaviour when the left side operand has negative value?

I&#39;m working on a project that has a lot of legacy **C** code.  We&#39;ve started writing in C++, with the intent to eventually convert the legacy code, as well.  I&#39;m a little confused about how the **C** and C++ interact.  I understand that by wrapping the **C** code with `extern &quot;C&quot;` the C++ compiler will not mangle the **C** code&#39;s names, but I&#39;m not entirely sure how to implement this.

So, at the top of each **C** header file (after the include guards), we have

    #ifdef __cplusplus
    extern &quot;C&quot; {
    #endif

and at the bottom, we write

    #ifdef __cplusplus
    }
    #endif

In between the two, we have all of our includes, typedefs, and function prototypes.  I have a few questions, to see if I&#39;m understanding this correctly:

 1. If I have a C++ file A.hh which
    includes a **C** header file B.h,
    includes another **C** header file C.h,
    how does this work?  I think that
    when the compiler steps into B.h,
    `__cplusplus` will be defined, so it
    will wrap the code with `extern &quot;C&quot;`
    (and `__cplusplus` will not be
    defined inside this block).  So,
    when it steps into C.h,
    `__cplusplus` will not be defined
    and the code will not be wrapped in
    `extern &quot;C&quot;`.  Is this correct?
    
 2. Is there anything wrong with
    wrapping a piece of code with
    `extern &quot;C&quot; { extern &quot;C&quot; { .. } }`? 
    What will the second `extern &quot;C&quot;`
    do?
    
 3. We don&#39;t put this wrapper around the .c files, just the .h files.  So, what happens if a function doesn&#39;t have a prototype? Does the compiler think that it&#39;s a C++ function?
    
 4. We are also using some third-party
    code which is written in **C**, and does
    not have this sort of wrapper around
    it.  Any time I include a header
    from that library, I&#39;ve been putting
    an `extern &quot;C&quot;` around the #include.
    Is this the right way to deal with
    that?
    
 5. Finally, is this set up a good idea?
    Is there anything else we should do?
    We&#39;re going to be mixing **C** and C++
    for the foreseeable future, and I
    want to make sure we&#39;re covering all
    our bases.

Combining C++ and C - how does #ifdef __cplusplus work?

So I know what pragma is, and what it&#39;s used for, but what is the meaning of the word itself? I&#39;ve used it many times in code, but I never really knew what the word actually means or stands for.

Where does the word &quot;pragma&quot; come from?

When I try to build the following program:


    #include &lt;stdio.h&gt;
    
    int main(void)
    {
      printf(&quot;hello world\n&quot;);
      return 0;
    }

On OS X 10.6.4, with the following flags:

    gcc -static -o blah blah.c

It returns this:

    ld: library not found for -lcrt0.o
    collect2: ld returned 1 exit status

Has anyone else encountered this, or is it something that noone else has been affected with yet?  Any fixes?

Thanks



ld: library not found for -lcrt0.o on OSX 10.6 with gcc/clang -static flag

I am getting this error whenever I try to run GCC outside of its installation directory (`E:\MinGW\bin`). 

So, let&#39;s say I am in `E:\code` and have a file called `one.c`. Running:
`gcc one.c -o one.exe` will give me this error:

    gcc: CreateProcess: No such file or directory

The only workaround is to navigate to its installation directory, run gcc from there, and specify all the other paths. My environmental variable `Path` contains `E:\MinGW\bin`.

Any suggestions to fixing this problem? I am running Windows XP SP3.

CreateProcess: No such file or directory

I&#39;ve had numerous problems compiling shared objects that link statically against static libraries. This problem only shows up on x84_64 platforms. When doing the same compilation work on x86_32 I do not have any problems. 

Perhaps this is a OS specific GCC configuration thing, but my research indicates that its how GCC works on x86_64 platforms. Anyhow, I am using gcc 4.4.3 on Ubuntu 10.04 x86_64.

How is the problem fixed ?... Making sure all the static library dependencies are compiled with -fPIC.

**Question 1:** What is the difference between -fpic and -fPIC (apparently -fPIC generates more instructions on x86) ? Why is the later type more relevant in the x86_64 context ? 

**Question 2:** My assumption is that when you link against static code you are hard-wiring the functions into your binary at link time, why does it need the level of indirection the &quot;position independant code&quot; machinery provides ? 

**Question 3:** Now if x86 doesn&#39;t need -fpic / -fPIC to link shared objects against static archives why is it needed in x86_64 ? 

**Question 4:** even if it is needed why isn&#39;t it supplied implicitly ? I thought breaking changes was supposed to be a big no-no

Why does gcc not implicitly supply the -fPIC flag when compiling static libraries on x86_64

How can I tell GCC to unroll a particular loop?
I have used the CUDA SDK where loops can be unrolled manually using `#pragma unroll`. Is there a similar feature for gcc? I googled a bit but could not find anything.

Tell gcc to specifically unroll a loop

Is there any way to use a `sizeof` in a preprocessor macro?

For example, there have been a ton of situations over the years in which I wanted to do something like:

    #if sizeof(someThing) != PAGE_SIZE
    #error Data structure doesn&#39;t match page size
    #endif

The exact thing I&#39;m checking here is completely made up - the point is, I often like to put in these types of (size or alignment) compile-time checks to guard against someone modifying a data-structure which could misalign or re-size things which would break them.

Needless to say - I don&#39;t appear to be able to use a `sizeof` in the manner described above.

How can I use &quot;sizeof&quot; in a preprocessor macro?

I have 2 static Linux libraries, created by `ar cr`, `libabc.a` and `libxyz.a`.&lt;br&gt;
I want to merge them into one static library `libaz.a`.&lt;br&gt;
How can I do this.

I want to create a merged static library,  not to give both libraries to final link of applications.

How to merge two &quot;ar&quot; static libraries into one?

How can I statically link only a some specific libraries to my binary when linking with GCC?

`gcc ... -static ...` tries to statically link **all** the linked libraries, but I haven&#39;t got the static version of some of them (eg: libX11).

static linking only some libraries

&gt; ## Alternate titles to aid search
&gt; - Xcode can&#39;t find header 
&gt; - Missing .h in Xcode
&gt; - Xcode .h file not found
&gt; - lexical or preprocessor issue file not found

I&#39;m working on an iOS application project which came from Xcode 3.  I have now moved to Xcode 4 my project builds a number of static libraries.

Those static libraries also declare public headers and those headers are used by the application code. In Xcode 3.x the headers were copied (as a build phase) to the `public headers directory`, then in the application project the `public headers directory` was added to the `headers search list`.

Under Xcode 4 the build directory is moved to `~/Library/Developer/Xcode/DerivedData/my-project`. 

The problem is how do I reference this new location in the headers search settings? It seems that:

- `public headers directory` is relative to `DerivedData` directory, but
- `headers search` directory is relative to something else (possibly the project location)

How should I set up a static library target for iOS development in Xcode 4 that will ensure the header files are made available to the clients that use the static library when trying to compile as a dependancy?

Xcode 4 can&#39;t locate public header files from static library dependency

I am quite new to xcode and objective-c. I want to ask a very basic question.

I saw that when &quot;linking binary to libraries&quot; in project settings, there are differences about framework and libraries, imported from other projects in workspace.

First question, why is there a framework? And why is there a library? Cannot my library be a framework?

And then, from a *.h* file, how can I call classes from my imported static library?

I suppose there must be a prefix, but I couldn&#39;t find it.
Neither &lt;ProjName/Myclass.h&gt; nor &quot;ProjName/Myclass.h&quot; are working.

Please, be as specific as you can.

Thanks

Difference between framework and static library in xcode4, and how to call them

I&#39;m trying to understand this LIB file business on Microsoft Windows, and I&#39;ve just made a discovery that will - I hope - dispel the confusion that hitherto has prevented me from getting a clear grasp of the issue. To wit, LIB files are not the one kind of file that their file extension suggests they are.

    :: cd &quot;C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Lib&quot;
    
    :: lib /nologo /list Ad1.Lib
    obj\i386\activdbgid.obj
    obj\i386\activscpid.obj
    obj\i386\ad1exid.obj
    obj\i386\dbgpropid.obj
    obj\i386\dispexid.obj
    
    :: lib /nologo /list oledb.lib
    o:\winmain.obj.x86fre\enduser\…\oledb\uuid\objfre\i386\oledbiid.obj
    o:\winmain.obj.x86fre\enduser\…\oledb\uuid\objfre\i386\oledbnewiid.obj
    o:\winmain.obj.x86fre\enduser\…\oledb\uuid\objfre\i386\cmdtreeiid.obj
    o:\winmain.obj.x86fre\enduser\…\oledb\uuid\objfre\i386\oledbdepiid.obj
    
    :: lib /nologo /list AdvAPI32.Lib | sort | uniq -c
        731 ADVAPI32.dll

The first two examples contain object files (appearing as relative or absolute paths when displayed by the `lib.exe` utility). The third example, however, only contains 731 references to a DLL. (I guess `lib.exe` isn&#39;t designed to display more useful information for this kind of file.)

Some contain object files, and they are static libraries. Others contain symbols, and they are import libraries. (There&#39;s a [short explanation here](https://stackoverflow.com/questions/2240737/2240777#2240777).)

So static libraries appear to be the equivalents of `.a` files on Linux, and DLLs appear to map to `.so` files on Linux. (By the way, how would import libraries fit into this Windows/Linux equivalence picture?)

Now I&#39;m wondering why this is so? Why did Microsoft decide to give import libraries the same file extension as static libraries? (I understand that historically, static libraries were first, like primitive forms of life preceded more complex forms.) Why wouldn&#39;t they say, okay, here&#39;s these new kind of libraries, they shall be referred to as import libraries, and they shall bear the file extension `.ILB` (or whatever)?

Why are LIB files beasts of such a duplicitous nature?

How can I view symbols in a .o file? nm does not work for me. I use g++/linux.

How to view symbols in object files?

I am reading about libraries in C but I have not yet found an explanation on what an object file is. What&#39;s the real difference between any other compiled file and an object file?   
I would be glad if someone could explain in human language.

Content Type	Original Author	Original Content on Stackoverflow
Question	Prasoon Saurav	View Question on Stackoverflow
Solution 1 - C++	Prasoon Saurav	View Answer on Stackoverflow
Solution 2 - C++	Jens Gustedt	View Answer on Stackoverflow
Solution 3 - C++	kakyo	View Answer on Stackoverflow
Solution 4 - C++	GreenBærg	View Answer on Stackoverflow
Solution 5 - C++	Julian	View Answer on Stackoverflow

Contents of a static library

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Solution 4 - C++

Solution 5 - C++

Detached vs. Joinable POSIX threads

split a comma-separated string with both quoted and unquoted strings

Attributions