Returning array from function in C

I've here very intersting discussion about the best and common ways to return an array from a function..

Some solutions to use output parameter and copy the value of the array into the value of this output parameter array.
Other solution to pass an array and use it inside the function.

Others to allocate the array inside the function and return refrence to it, but the caller have to free it once done.

Others to return a struct contains this pointer...

Please enjoy; stackoverflow.com/questions/8865982/return-array-from-function-in-c

How to write a static library in Linux

I am going to illustrate how to write a static library in C for Linux.

requirements: a Linux distribution with GCC installed.

1- First, we need to write the header file of our library:

// complex.h
#ifndef _COMPLEX_H
#define _COMPLEX_H

typedef struct
{
    double real;
    double imaginary;
    
}complex_t;

void add(complex_t *const dest, const complex_t *const src);
static int assert_ptr_not_null(void *);

#endif

2- second, let's write the implementation for this libary:

//complex.c
#include <stdio.h>
#include "complex.h"

void add(complex_t *const dest, const complex_t *const src)
{
    
    if ( !assert_ptr_not_null((void*)dest) || !assert_ptr_not_null((void*)src) )
    {
        fprintf(stderr, "NULL Pointers passed");
        return;
    }
    
    
    dest->real = dest->real + src->real;
    dest->imaginary = dest->imaginary + src->imaginary;
}

static int assert_ptr_not_null(void *ptr)
{
    if (ptr == NULL) return 0;
    return 1;
}

3- let's compile the library (but not link it), use the following command to compile the library:

>cc -c complex.c

-c tell the compiler not to do the linking phase
this command will output a files named "complex.o", and it is the object file for our library

4- static libraries in C are archives that contains object files, so let's archive our object file.
use the following command :

>ar libcomplex.a complex.o

ar: is a regular archiving program found in Linux.
libcomplex.a: is the name of our library, it should start with "lib" and ends by ".a" and in between, you can name it as you like.
complex.o: is our object file generated from compiling complex.c in step 3

notice the generation of the library file libcomplex.a

5- we are done!, so let's examine the generated files before using the library.

First, we can use the command "nm" to see the symbols in our object file, use this command:

>nm complex.o
the output will be like:
00000000 T add
00000075 t assert_ptr_not_null
         U fwrite
         U stderr

Notice the existence of our functions (assert_ptr_not_null, add)

let's examine the library too:

>nm libcomplex.a 

complex.o:
00000000 T add
00000075 t assert_ptr_not_null
         U fwrite
         U stderr

6- now, lets use the libary, here's a test program that uses the library:

//program.c
#include <stdio.h>
#include <stdlib.h>

#include "complex.h"

int
main()
{
    
    complex_t *c1 = (complex_t*) malloc(sizeof (complex_t));
    complex_t *c2 = (complex_t*) malloc(sizeof (complex_t));
    
    c1->real = 10;
    c1->imaginary = 10;
    
    add(c1, c2);
    
    
    printf("%f\n", c1->real);
    printf("%f\n", c1->imaginary);
    
    printf("%f\n", c2->real);
    printf("%f\n", c2->imaginary);
    
    free(c1);
    free(c2);
    
    return 0;
}

first, we need to compile our program:

>cc -c program.c

then, it's time for linking the generated object file:

> cc -o program program.o -L. -lcomplex

-lcomplex: composed of "-l" + "complex" which is our library name (without both "lib" and ".a").
-L. : this instruct the linker (ld) to include the current directory among the paths it searches for locating object files/libraries. (so it can look in our libcomplex.a library)

this command will generate the binary file for us, it will be named "program", try executing it:

>./program

also, we can list symbols in this binary using th "nm" tool too.

thats all.

References:
Beginning Linux Programming, third edition, Wiley Publishing, Inc.