{"id":364,"date":"2019-02-23T08:45:28","date_gmt":"2019-02-23T08:45:28","guid":{"rendered":"https:\/\/blog.syddel.uk\/?p=364"},"modified":"2025-03-04T00:05:57","modified_gmt":"2025-03-04T00:05:57","slug":"testing","status":"publish","type":"post","link":"https:\/\/blog.syddel.uk\/?p=364","title":{"rendered":"Linux C\/C++: Compiling and Linking Basics"},"content":{"rendered":"\n

My parents bought me a TRS-80 model III when I was 13 years of age, and boy did I love my TRS-80! I quickly learnt how to code using the baked in BASIC language, and even familiarized myself with simple Z80 assembly language programming using the magic of BASIC’s “peeks”<\/em> and “pokes”<\/em>. I recall desperately wanting to code in C\/C++ back then. However, in order to get my grubby little hands on a C\/C++ compiler, I needed money (from memory, I think it was around two hundred Australian dollars at the time). Considering I “earned” around $5 a week for washing dishes and taking out the trash, it was going to take me at an eternity to be able to purchase a C\/C++ compiler (I had other expenses at the time – like buying the hand-held double-LCD screen “Donkey Kong” game, jaw busters, and Star Wars action figures\/spaceships). The year was 1983…<\/p>\n\n\n\n

I only started coding in C\/C++ when I managed to purchase my first “IBM compatible” running MS-DOS. The compiler was Borland’s C++ compiler, and it set me back over a hundred Australia dollars. The year was 1987..<\/p>\n\n\n\n

When I first started using Linux, I didn’t really comprehend the ideology\/philosophy behind the FOSS (Free and Open Source Software) movement. I didn’t pay much attention the software licenses, I just knew that Linux was “free of charge”, and was ecstatic that a C\/C++ compiler was included (free of charge!). I cannot remember what the year was – some time in the early 2000s.<\/p>\n\n\n\n

Fast-forward to today, and you can buy a Raspberry Pi for next to nothing, install Raspbian or (I believe) Ubuntu Core, learn how to use one of the editors that can run in a terminal, and start coding in C\/C++ to your heart’s content. The barrier to entry is now so low, that it has literally bought a tear to my eye (once or twice).<\/p>\n\n\n\n

Anyway, enough about my personal journey and experiences with C\/C++ compilers. Let’s get in to some basics about C\/C++ in modern day (at time of writing) Linux.<\/p>\n\n\n\n

\n\n\n\n

Compiling C\/C++ with GNU C\/C++ Compiler<\/h2>\n\n\n\n

Here’s a simple C program that will print out the command line arguments you pass to the program when you execute it:<\/p>\n\n\n\n

<\/path><\/path><\/svg><\/span>
#include<\/span> <\/span><stdio.h><\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>char<\/span> <\/span>*<\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i<\/span>=<\/span>0<\/span>; i<\/span><<\/span>argc; i<\/span>++<\/span>) {<\/span><\/span>\n    <\/span>printf<\/span>(<\/span>"arg[<\/span>%d<\/span>]: <\/span>%s\\n<\/span>"<\/span>, i, argv[i]);<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Let’s assume you’ve saved the above program in a file called program.c<\/code>. To compile it in to a binary called program<\/code>, you would use:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
gcc<\/span> <\/span>-o<\/span> <\/span>program<\/span> <\/span>program.c<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Let’s execute the program we’ve created to see what the output is:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
[syd@pi-server:cpp]$ .\/program one two three four<\/span><\/span>\narg[0]:<\/span> <\/span>.\/program<\/span><\/span>\narg[1]:<\/span> <\/span>one<\/span><\/span>\narg[2]:<\/span> <\/span>two<\/span><\/span>\narg[3]:<\/span> <\/span>three<\/span><\/span>\narg[4]:<\/span> <\/span>four<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Let’s re-write this example as a C++ program and save the file as program.cpp<\/code>:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>char<\/span> <\/span>*<\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i<\/span>=<\/span>0<\/span>; i<\/span><<\/span>argc; i<\/span>++<\/span>) {<\/span><\/span>\n    <\/span>std<\/span>::cout <\/span><<<\/span> <\/span>"arg["<\/span> <\/span><<<\/span> i <\/span><<<\/span> <\/span>"]: "<\/span> <\/span><<<\/span> argv[i] <\/span><<<\/span> <\/span>std<\/span>::endl;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Let’s try to compile this C++ program with the GNU C compiler:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
syd@pi-server:cpp]$<\/span> <\/span>gcc<\/span> <\/span>-o<\/span> <\/span>program<\/span> <\/span>program.cpp<\/span> <\/span><\/span>\n\/tmp\/ccgsFTNy.o:<\/span> <\/span>In<\/span> <\/span>function<\/span> <\/span>`<\/span>main':<\/span><\/span>\nprogram.cpp:(.text+0x34): undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)'<\/span><\/span>\nprogram.cpp:(.text+0x44<\/span>): undefined reference to `<\/span>std::ostream::operator<<(int<\/span>)<\/span>'<\/span><\/span>\nprogram.cpp:(.text+0x54): undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)'<\/span><\/span>\nprogram.cpp:(.text+0x70<\/span>): undefined reference to <\/span>`<\/span>std::basic_ostream<char,<\/span> std::char_traits<\/span><<\/span>char<\/span>><\/span> <\/span>>&<\/span> std::operator<< <\/span><<\/span>std::char_traits<\/span><<\/span>char<\/span>><\/span> >(<\/span>std::basic_ostream<char,<\/span> std::char_traits<\/span><<\/span>char<\/span>><\/span> <\/span>>&<\/span>, char const<\/span>*<\/span>)'<\/span><\/span>\nprogram.cpp:(.text+0x80): undefined reference to `std::ostream::operator<<(std::ostream& (*)(std::ostream&))'<\/span><\/span>\nprogram.cpp:(.text+0xa8<\/span>): undefined reference to `<\/span>std::cout<\/span>'<\/span><\/span>\nprogram.cpp:(.text+0xb0): undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&)'<\/span><\/span>\n\/tmp\/ccgsFTNy.o:<\/span> <\/span>In<\/span> <\/span>function<\/span> <\/span>`<\/span>__static_initialization_and_destruction_0(int,<\/span> int)':<\/span><\/span>\nprogram.cpp:(.text+0xe8): undefined reference to `std::ios_base::Init::Init()'<\/span><\/span>\nprogram.cpp:(.text+0x114<\/span>): undefined reference to <\/span>`std::ios_base::Init::~Init<\/span>()'<\/span><\/span>\ncollect2: error: ld returned 1 exit status<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Compilation failed! What happened? The answer is the GNU C compiler doesn’t pull in the libraries required to compile C++ code – in particular, the stdc++ library. You can explicitly instruct the GNU C compiler to use stdc++<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
gcc<\/span> <\/span>-o<\/span> <\/span>program<\/span> <\/span>-lstdc++<\/span> <\/span>program.cpp<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Compiling C++ code with the gcc compiler is not recommended. Things can quickly become very complicated (i.e. trying to remember what libraries need to be linked, and how). Thankfully, there’s a GNU C++ compiler included with Linux too, and it makes compiler C++ code much easier. For the same example above, the following can be used:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
g++<\/span> <\/span>-o<\/span> <\/span>program<\/span> <\/span>program.cpp<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Large and complicated C and C++ programs often have multiple source files – each specific to a particular feature\/function. This separation assists in creating projects that are easier to maintain and debug. Let’s take a look at a very simple example.<\/p>\n\n\n\naddtwoints.c<\/strong><\/code>\n\n\n\n
<\/path><\/path><\/svg><\/span>
int<\/span> <\/span>add<\/span>(<\/span>int<\/span> <\/span>x<\/span>, <\/span>int<\/span> <\/span>y<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>return<\/span> x <\/span>+<\/span> y;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\naddtwoints.h<\/strong><\/code>\n\n\n\n
<\/path><\/path><\/svg><\/span>
int<\/span> <\/span>add<\/span>(<\/span>int<\/span>, <\/span>int<\/span>);<\/span><\/span><\/code><\/pre><\/div>\n\n\n\nprogram.c<\/strong><\/code>\n\n\n\n
<\/path><\/path><\/svg><\/span>
#include<\/span> <\/span><stdio.h><\/span><\/span>\n#include<\/span> <\/span><stdlib.h><\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"addtwoints.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>char<\/span> <\/span>*<\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>if<\/span> (argc <\/span>!=<\/span> <\/span>3<\/span>) {<\/span><\/span>\n    <\/span>printf<\/span>(<\/span>"*** ERROR! Usage: <\/span>%s<\/span> int1 int2<\/span>\\n<\/span>"<\/span>, argv[<\/span>0<\/span>]);<\/span><\/span>\n    <\/span>return<\/span> <\/span>1<\/span>;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  <\/span>int<\/span> a <\/span>=<\/span> <\/span>atoi<\/span>(argv[<\/span>1<\/span>]), b <\/span>=<\/span> <\/span>atoi<\/span>(argv[<\/span>2<\/span>]);<\/span><\/span>\n  <\/span>printf<\/span>(<\/span>"<\/span>%d<\/span> plus <\/span>%d<\/span> is <\/span>%d<\/span>.<\/span>\\n<\/span>"<\/span>, a, b, <\/span>add<\/span>(a, b));<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Let’s assume the directory you’re working in contains nothing more than the three files listed above:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
[syd@pi-server:addtwonumbers]$ ls -lh<\/span><\/span>\ntotal<\/span> <\/span>12<\/span>K<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>  <\/span>42<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>11<\/span>:25<\/span> <\/span>addtwoints.c<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>  <\/span>19<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>11<\/span>:29<\/span> <\/span>addtwoints.h<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span> <\/span>305<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>11<\/span>:43<\/span> <\/span>program.c<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
A very simple way to compile and link this code in to a binary called program is:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
gcc<\/span> <\/span>-o<\/span> <\/span>program<\/span> <\/span>*<\/span>.c<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
You can then run the program as follows:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
[syd@pi-server:addtwonumbers]$ .\/program <\/span><\/span>\n***<\/span> ERROR<\/span>!<\/span> <\/span>Usage:<\/span> <\/span>.\/program<\/span> <\/span>int1<\/span> <\/span>int2<\/span><\/span>\n[syd@pi-server:addtwonumbers]$ .\/program 1 2<\/span><\/span>\n1<\/span> <\/span>plus<\/span> <\/span>2<\/span> <\/span>is<\/span> <\/span>3<\/span>.<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Great! However, it should be noted that there are advantages to compiling and then linking source files separately. When you compile a C\/C++ source file, the result is an object file (usually with the extension .o). You can then link your object files to create an executable. Let’s take a quick look at how this would be done manually using the above “add two integers” example<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
[syd@pi-server:addtwonumbers]$ gcc -c addtwoints.c program.c <\/span><\/span>\n[syd@pi-server:addtwonumbers]$ ls -l<\/span><\/span>\ntotal<\/span> <\/span>20<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>   <\/span>42<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>11<\/span>:25<\/span> <\/span>addtwoints.c<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>   <\/span>19<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>11<\/span>:29<\/span> <\/span>addtwoints.h<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>  <\/span>868<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>12<\/span>:01<\/span> <\/span>addtwoints.o<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>  <\/span>305<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>11<\/span>:43<\/span> <\/span>program.c<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span> <\/span>1300<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>12<\/span>:01<\/span> <\/span>program.o<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
The -c compiler flag tells the compiler to “compile only” (i.e. do not link and do not create an executable), which is why addtwoints.o<\/code> and program.o<\/code> are the only files that were generated. This becomes very beneficial when you have a large program (perhaps with hundreds or even thousands of C\/C++ source files) and you only change the code in a single file. Instead of having to recompile the entire entire project (which can take hours for very large projects), the single source file change can be compiled and linked with the object files (for which the corresponding source files haven’t been altered) in a matter of minutes or seconds.<\/p>\n\n\n\n
Let’s now link the two object files (addtwoints.o<\/code> and program.o<\/code>) in to a binary that can be executed:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
[syd@pi-server:addtwonumbers]$ gcc -o program addtwoints.o program.o<\/span><\/span>\n[syd@pi-server:addtwonumbers]$ ls -lh<\/span><\/span>\ntotal<\/span> <\/span>32<\/span>K<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>   <\/span>42<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>11<\/span>:25<\/span> <\/span>addtwoints.c<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>   <\/span>19<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>11<\/span>:29<\/span> <\/span>addtwoints.h<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>  <\/span>868<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>12<\/span>:01<\/span> <\/span>addtwoints.o<\/span><\/span>\n-rwxr-xr-x<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span> <\/span>8.1<\/span>K<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>12<\/span>:24<\/span> <\/span>program<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>  <\/span>305<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>11<\/span>:43<\/span> <\/span>program.c<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span> <\/span>1.3<\/span>K<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>12<\/span>:01<\/span> <\/span>program.o<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
\n\n\n\n
Linking<\/h2>\n\n\n\n
There are two ways to link to compiled objects (libraries) so that your executable can use the functionality exposed within them:<\/p>\n\n\n\n
    \n
  1. Static linking<\/li>\n\n\n\n
  2. Dynamic linking<\/li>\n<\/ol>\n\n\n\n
    Static linking is done at compile time and pulls in the pre-compiled object code in to your executable (resulting in a larger executable). Dynamic linking is done at runtime and uses “shared objects”. When linking, this is the default option (if there are both static and shared libraries). Shared objects can be used by any number of executables within the operating system.<\/p>\n\n\n\n
    On Linux systems, there is a convention for libraries:<\/p>\n\n\n\n
      \n
    • Library names are always preceded with lib.<\/li>\n\n\n\n
    • The extension for static libraries is usually .a (for “archive”).<\/li>\n\n\n\n
    • The extension for shared libraries is usually .so (for “shared object”).<\/li>\n<\/ul>\n\n\n\n
      A Linux executable can contain both statically linked and dynamically linked libraries.<\/p>\n\n\n\n
      In this section, we’re going to use four files:<\/p>\n\n\n\naddtwoints.c<\/strong><\/code>\n\n\n\n
      <\/path><\/path><\/svg><\/span>
      int<\/span> <\/span>add<\/span>(<\/span>int<\/span> <\/span>x<\/span>, <\/span>int<\/span> <\/span>y<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>return<\/span> x <\/span>+<\/span> y;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\nsayhello.c<\/strong><\/code>\n\n\n\n
      <\/path><\/path><\/svg><\/span>
      #include<\/span> <\/span><stdio.h><\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>hello<\/span>(<\/span>const<\/span> <\/span>char<\/span> <\/span>**<\/span>s<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>printf<\/span>(<\/span>"Hello there, <\/span>%s<\/span>!<\/span>\\n<\/span>"<\/span>, <\/span>*<\/span>s);  <\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\nmyfunctions.h<\/strong><\/code>\n\n\n\n
      <\/path><\/path><\/svg><\/span>
      int<\/span> <\/span>add<\/span>(<\/span>int<\/span>, <\/span>int<\/span>);<\/span><\/span>\nvoid<\/span> <\/span>hello<\/span>(<\/span>const<\/span> <\/span>char<\/span> <\/span>**<\/span>);<\/span><\/span><\/code><\/pre><\/div>\n\n\n\nprogram.c<\/strong><\/code>\n\n\n\n
      <\/path><\/path><\/svg><\/span>
      #include<\/span> <\/span><stdio.h><\/span><\/span>\n#include<\/span> <\/span><stdlib.h><\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"myfunctions.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>char<\/span> <\/span>*<\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>if<\/span> (argc <\/span>!=<\/span> <\/span>4<\/span>) {<\/span><\/span>\n    <\/span>printf<\/span>(<\/span>"*** ERROR! Usage: <\/span>%s<\/span> int1 int2 string1<\/span>\\n<\/span>"<\/span>, argv[<\/span>0<\/span>]);<\/span><\/span>\n    <\/span>return<\/span> <\/span>1<\/span>;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  <\/span>int<\/span> a <\/span>=<\/span> <\/span>atoi<\/span>(argv[<\/span>1<\/span>]), b <\/span>=<\/span> <\/span>atoi<\/span>(argv[<\/span>2<\/span>]);<\/span><\/span>\n  <\/span>printf<\/span>(<\/span>"<\/span>%d<\/span> plus <\/span>%d<\/span> is <\/span>%d<\/span>.<\/span>\\n<\/span>"<\/span>, a, b, <\/span>add<\/span>(a, b));<\/span><\/span>\n  <\/span><\/span>\n  <\/span>hello<\/span>((<\/span>const<\/span> <\/span>char<\/span> <\/span>**<\/span>)<\/span>&<\/span>argv[<\/span>3<\/span>]);<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
      Static Linking<\/h2>\n\n\n\n
      From the source files listed above, we will create a static library (i.e. an “archive”) using addtwoints.c<\/code> and sayhello.c<\/code>. This is achieved by compiling and then using the ar<\/code> tool on the resulting object files:
      <\/p>\n\n\n\n
      <\/path><\/path><\/svg><\/span>
      [syd@pi-server:static]$ gcc -static -c addtwoints.c sayhello.c <\/span><\/span>\n[syd@pi-server:static]$ ar crv libmyfunctions.a addtwoints.o sayhello.o<\/span><\/span>\na<\/span> <\/span>-<\/span> <\/span>addtwoints.o<\/span><\/span>\na<\/span> <\/span>-<\/span> <\/span>sayhello.o<\/span><\/span>\n[syd@pi-server:static]$ ls -lh<\/span><\/span>\ntotal<\/span> <\/span>28<\/span>K<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>   <\/span>42<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>18<\/span>:23<\/span> <\/span>addtwoints.c<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>  <\/span>868<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>20<\/span>:41<\/span> <\/span>addtwoints.o<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span> <\/span>2.2<\/span>K<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>20<\/span>:42<\/span> <\/span>libmyfunctions.a<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>   <\/span>46<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>18<\/span>:32<\/span> <\/span>myfunctions.h<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>  <\/span>351<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>18<\/span>:36<\/span> <\/span>program.c<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>   <\/span>89<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>18<\/span>:31<\/span> <\/span>sayhello.c<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span> <\/span>1.1<\/span>K<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>20<\/span>:41<\/span> <\/span>sayhello.o<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
      We can now compile and statically link to libmyfunctions.a<\/code>:<\/p>\n\n\n\n
      <\/path><\/path><\/svg><\/span>
      [syd@pi-server:static]$ gcc -o program program.c -L. -lmyfunctions<\/span><\/span>\n[syd@pi-server:static]$ .\/program 1 2 syd<\/span><\/span>\n1<\/span> <\/span>plus<\/span> <\/span>2<\/span> <\/span>is<\/span> <\/span>3<\/span>.<\/span><\/span>\nHello<\/span> <\/span>there,<\/span> <\/span>syd!<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
      By default, the linker will look for libraries in \/usr\/lib<\/code>. The -L<\/code> flag in the example above tells the linker about non-standard directories where libraries exist – in this case, the current directory. The -l<\/code> flag tells the linker to link the specified library. You do not have to use the the leading “lib” part of the library filename, or file extension.<\/p>\n\n\n\n
      You can check shared object dependencies of a Linux executable using:<\/p>\n\n\n\n
      <\/path><\/path><\/svg><\/span>
      [syd@pi-server:static]$ ldd program<\/span><\/span>\n        <\/span>linux-vdso.so.1<\/span> (0x7ea0a000)<\/span><\/span>\n        <\/span>\/usr\/lib\/arm-linux-gnueabihf\/libarmmem.so<\/span> (0x76ecf000)<\/span><\/span>\n        <\/span>libc.so.6<\/span> =<\/span>><\/span> <\/span>\/lib\/arm-linux-gnueabihf\/libc.so.6<\/span> (0x76d90000)<\/span><\/span>\n        <\/span>\/lib\/ld-linux-armhf.so.3<\/span> (0x76ee5000)<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
      The above is verification there is no libmyfunctions.so dependency.<\/p>\n\n\n\n
      Dynamic Linking<\/h2>\n\n\n\n
      Again using the example code above, let’s now create a dynamically loaded library (i.e. a “shared object”):<\/p>\n\n\n\n
      <\/path><\/path><\/svg><\/span>
      [syd@pi-server:dynamic]$ gcc -o libmyfunctions.so -shared -fPIC addtwoints.c sayhello.c <\/span><\/span>\n[syd@pi-server:dynamic]$ gcc -o program program.c -L. -lmyfunctions<\/span><\/span>\n[syd@pi-server:dynamic]$ ls -lh<\/span><\/span>\ntotal<\/span> <\/span>36<\/span>K<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>   <\/span>42<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>18<\/span>:45<\/span> <\/span>addtwoints.c<\/span><\/span>\n-rwxr-xr-x<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span> <\/span>7.5<\/span>K<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>22<\/span>:59<\/span> <\/span>libmyfunctions.so<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>   <\/span>46<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>18<\/span>:45<\/span> <\/span>myfunctions.h<\/span><\/span>\n-rwxr-xr-x<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span> <\/span>8.2<\/span>K<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>23<\/span>:00<\/span> <\/span>program<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>  <\/span>351<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>18<\/span>:45<\/span> <\/span>program.c<\/span><\/span>\n-rw-r--r--<\/span> <\/span>1<\/span> <\/span>syd<\/span> <\/span>syd<\/span>   <\/span>89<\/span> <\/span>Feb<\/span> <\/span>24<\/span> <\/span>18<\/span>:45<\/span> <\/span>sayhello.c<\/span><\/span>\n[syd@pi-server:dynamic]$ <\/span><\/span>\n[syd@pi-server:dynamic]$ ldd program<\/span><\/span>\n        <\/span>linux-vdso.so.1<\/span> (0x7ef00000)<\/span><\/span>\n        <\/span>\/usr\/lib\/arm-linux-gnueabihf\/libarmmem.so<\/span> (0x76f0c000)<\/span><\/span>\n        <\/span>libmyfunctions.so<\/span> =<\/span>><\/span> <\/span>not<\/span> <\/span>found<\/span><\/span>\n        <\/span>libc.so.6<\/span> =<\/span>><\/span> <\/span>\/lib\/arm-linux-gnueabihf\/libc.so.6<\/span> (0x76dcd000)<\/span><\/span>\n        <\/span>\/lib\/ld-linux-armhf.so.3<\/span> (0x76f22000)<\/span><\/span>\n[syd@pi-server:dynamic]$<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
      Notice the results contain: libmyfunctions.so => not found<\/code>? Let’s try to execute the program to see what happens:<\/p>\n\n\n\n
      <\/path><\/path><\/svg><\/span>
      [syd@pi-server:dynamic]$ .\/program 1 2 syd<\/span><\/span>\n.\/program:<\/span> <\/span>error<\/span> <\/span>while<\/span> <\/span>loading<\/span> <\/span>shared<\/span> <\/span>libraries:<\/span> <\/span>libmyfunctions.so:<\/span> <\/span>cannot<\/span> <\/span>open<\/span> <\/span>shared<\/span> <\/span>object<\/span> <\/span>file:<\/span> <\/span>No<\/span> <\/span>such<\/span> <\/span>file<\/span> <\/span>or<\/span> <\/span>directory<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
      The dynamic library loader failed to file libmyfunctions.so. That’s because shared object files need to be a particular directories (e.g. \/usr\/lib or \/lib etc…). There are a number of ways to resolve this:<\/p>\n\n\n\n