using –with-local-prefix=/the_directory_of_choice

another important argument is

–enable-languages=c,<other compilers go here>

for portability symlink gcc to cc

ar rc libname object files

where r tells the archiver to replace object files in the library if they are newer ones and the c stands for create the library if it does not exist. As an example, say you want to build a static library call libstruct.a with the object file struct.o the command would be as follows:

g++ -c struct.cpp <—– to build the struct.o object file then:

ar rc libstruct.a struct.o <———- to build the library

To index the library to speed up the compiling process when using the library so you can use ranlib on the library like:

ranlib libstruct.a

Note that not all platforms need this as the archiver may index the library for you.
You can then link in that library just as you would any other object file.

eg g++ -o appname main.o libstruct.a

CMAKE
use the command add_library(nameoflibrary STATIC sourcefile.cpp) this will setup the make file to build the library for you

For a very simple project the first thing to create would be the

CMakeLists.txt

The most basic of cmake files you would need to build an executable would contain three declarations.
project(), add_executable() and set.
project(projectname) holds the name of the project.
The set function lists files into a variable that is
set(varname main.cpp someotherfile.cpp andanother.cpp) would allow you to reference all those file with the statement ${varname}.
For make it is done the same as setting environment variables VARNAME=main.cpp someotherfile.cpp andanother.cpp and then is referenced using $(varname).For the example of building a main.cpp into an executable you would use something like this for a make file.

SRC=main.cpp
OBJ=main.o
appname : $(OBJ)
g++ -o appname $(OBJ)
main.o : $(SRC)
g++ -c $(SRC)

then you would run make and it will happily build your executable.

To build this minimal application with cmake you could use the following functions in a CMakeLists.txt

project(projectname)
set(varname sourcefiles).
add_executable(appname ${varname})

Applying this to our main.cpp example and using the name “myapp” for the final executable, it would look something like this

project(myproject)
set(myapp_SRC
main.cpp
)
add_executable(myapp ${myapp_SRC})

you would then type cmake . <– notice the dot. This would build among numerous other things, a Makefile.
You then type make as usual and the application is built.
Now lets say you add another src file to your application say struct.cpp and want to build that into your application.
This is where cmake very early on starts to show how much more usefull it can be, and this is only a hint.
To build the new struct.cpp files code into our application you would have to alter the Makefile to to tell it how to build the new struct code, something like this

SRC=main.cpp
STRUCT_SRC=struct.cpp
OBJ=main.o struct.o
appname : $(OBJ)
g++ -o appname $(OBJ)
main.o : $(SRC)
g++ -c $(SRC)
struct.o : $(STRUCT_SRC) <——– new struct code
g++ -c $(STRUCT_SRC)

However with the cmake example you would just add the source file into the CMakeLists.txt like

set(myapp_SRC
main.cpp
struct.cpp <——- just add this in
)
Then just run cmake . again to regenerate the Makefile.
Other usefull functions are building a library the command:

add_library(libname [SHARED | STATIC | MODULE source1 source2 ......] )

This will just build a library, just like that. For example if you want to build a library out of the files struct.cpp and anotherfile.cpp just add

add_library(struct SHARED struct.cpp anotherfile.cpp)

to your CMakeLists.txt file and run cmake on the current directory: cmake .
and you will see that libstruct.so has appeared there.

Addding

project(projectname)

to a CMakeLists.txt tells cmake to set a couple of variables namely projectname_BINARY_DIR and projectname_SOURCE_DIR but most importantly you will want to set this if you are building you application with a C compiler and not a C++ compiler.

gcc source.c -l”libraryname”
g++ source.cpp -l”libraryname”

When linking in a shared library with the -l argument, one just removes the lib prefix and inserts the name directly AFTER the -l ( thats a lowercase L ) .For example to link in the library libpng.so into your main excecutable you would enter the command:

gcc main.c -lpng
g++ main.cpp -lpng

This of course will search your standard library paths on linux machines. Most common are /usr/lib and /lib. If however your not using the default library locations for linking in a library you can use the UPPERCASE -L switch to specify a path to search for library’s on.
Again an example, lets say you have a library libQtCore.so sitting in /home/haxor/ and you want to link this library into your source code contained in main.cpp, You would issue the command:

gcc main.c -L/home/haxor -lQtCore
g++ main.cpp -L/home/haxor -lQtCore

Or if you are linking in a shared library in the same directory that you are working in just use the dot ‘.’
eg:
gcc main.c -L. -lQtCore

For more information on linking and or C programming in general visit
C programming