How to return array from function

We want function which dynamically creates array of integers, so no static declaration is possible because we do not know how big array needs to be.

#include <stdio.h> #include <stdlib.h> int * allocator(int size) { int * array = malloc(size * sizeof(int)); printf ("%p\n", (void*)array); return array; } int main() { int * i = allocator(2); i[0] = 1; i[1] = 2; printf ("%d, %d\n", i[0], i[1]); printf ("%p\n", (void*)i); free(i); return 0; }

We print address of dynamically allocated array in function and in main to be sure it points to the same place and use it to show it is usable. We must use pointer to integer in main because expression

int i[] = allocator(2);

is illegal initializer. It doesn't prevent us from using pointer to integer later as array. Finally we free allocated memory. That what we did is called manual memory allocation and such memory is placed on heap. If we want to use pointer arithmetic we will do something like this:

*i = 1;
*(i + 1) = 2;
printf ("%d, %d\n", *i, *(i+1));

Please note that *(i + 1) is not the same as *i + 1 even if it produces the same output in our example. Dereferencing pointer got higher order of precedence than addition. Because of precedence we are using braces. What if we need two-dimensional array? Two-dimensional array is array of arrays and we will need pointer to pointer.

#include <stdio.h> #include <stdlib.h> int ** allocator(int columns, int rows) { int i; int ** array = malloc(rows * sizeof(int)); printf ("%p\n", (void*)array); for(i = 0; i < columns; i++) array[i] = malloc(columns * sizeof(int)); return array; } int main() { int ** i = allocator(2, 3), j; i[0][0] = 1; i[1][1] = 2; printf ("%d, %d\n", i[0][0], i[1][1]); printf ("%p\n",(void*)i); for(j = 0; j < 3; j++) free(i[j]); free(i); return 0; }

As we see allocating is more complicated and feeing also. It goes in two steps, first we allocate array of rows and after that we allocate arrays of columns. As in previous case we can use array syntax. Now we can go mixing pointer arithmetic and array syntax or go completely pointer arithmetic

*(array+i) = malloc(columns * sizeof(int)); … **i = 1; *(*(i+1)+1) = 2; … *i[0] = 1; *(i[1]+1) = 2; printf ("%d, %d\n", i[0][0], i[1][1]);

Maybe to add that *(*i+1) corresponds to i[0][1]. That was how to do it, now how not to do it. Going heroic and forcing through pointer to array as return type.

typedef int (*array_t)[]; array_t justdont() { static int array[] = { 0, 1}; return &array; } int (*fun())[] { static int array[] = { 0, 1}; return &array; } int main() { int* i = justdont(); printf ("%d, %d\n", i[0], i[1]); printf ("%p\n",(void*)i); i = fun(); printf ("%d, %d\n", i[0], i[1]); printf ("%p\n",(void*)i); return 0; }

This compiles and executes with few warnings, if we change fun return type by adding another pointer int* (*fun())[], that also works. If something looks difficult, like returning address of array, than design needs additional work. For example

int * justdont() { static int array[] = { 0, 1}; return array; }

this is much nicer and easy to understand. Please note that returning static array is perfectly fine and that we do not use free on it. Statically declared variables are allocated automatically and available through execution of program. If we forget to declare array as static than we will return dangling pointer, local variable goes out of scope and returned pointer points to who knows what.

bgfx

Not sure into which category falls this blog entry, maybe review? I never did any 3D programming, so tutorial is out of question. Anyway I was fiddling with bgfx library and here are my experiences.
According to author, Branimir Karadzic, bgfx is cross-platform, graphics API agnostic, "Bring Your Own Engine/Framework" style rendering library. Since it works on Linux I was interested to take a look at it. Best way to get info on project is to visit https://github.com/bkaradzic/bgfx and read README.md. If you are curious to try it you will need also https://github.com/bkaradzic/bx to build it. Library uses custom tool GENie so that is reason why bx is needed, we will need it for projects as well. I have built it and attempted running examples. Some were working, some not. I was attempting to run them from directory where compiled assemblies are but they need runtime. So to run examples go to /examples/runtime and execute ../../.build/linux64_gcc/bin/example-00-helloworldDebug.
How to generate project make files or codeblocks or codelite projects. Since this is cross-platform tool Windows and Mac OS X targets are supported but I will focus on Linux only. Go to bgfx project root and run

../bx/tools/bin/linux/genie --help

To generate make files, do

../bx/tools/bin/linux/genie --gcc=linux-gcc --with-tools gmake

That will produce examples as targets plus tools, like shaderc. Now cd to .build/projects/gmake-linux and execute make help to see options. For 64 bit Linux we may build using this command:

make config=debug64 example-XY-name/nothing for all

If we are using IDE, we go to .build/projects/codeblocks or codelite, open generated project set target and build it. Now we are ready to start fiddling with provided examples.
For somebody who never did any 3D coding, like me, examples provided with bgfx are too complicated so I dumbed them down.

#include "common.h" #include <bgfx.h> int _main_(int /*_argc*/, char** /*_argv*/) { uint32_t width = 1280; uint32_t height = 720; uint32_t debug = BGFX_DEBUG_NONE; uint32_t reset = BGFX_RESET_VSYNC; bgfx::init(); bgfx::setDebug(debug); bgfx::setViewClear(0 , BGFX_CLEAR_COLOR|BGFX_CLEAR_DEPTH , 0x0000ffff , 1.0f , 0 ); while (!entry::processEvents(width, height, debug, reset) ) { bgfx::setViewRect(0, 0, 0, width, height); bgfx::submit(0); bgfx::frame(); } bgfx::shutdown(); return 0; }

This is example-00-helloworld reduced to creating and showing blue window. There is huge amount of plumbing code which makes those examples work in very few lines of code. For example entry::processEvents. In original shape example will print some text and place image on the screen.
Next to be slaughtered is cubes example. It draws now single triangle:

#include "common.h" #include "bgfx_utils.h" #include <stdlib.h> struct PosColorVertex { float m_x; float m_y; float m_z; uint32_t m_abgr; static void init() { ms_decl .begin() .add(bgfx::Attrib::Position, 3, bgfx::AttribType::Float) .add(bgfx::Attrib::Color0, 4, bgfx::AttribType::Uint8, true) .end(); }; static bgfx::VertexDecl ms_decl; }; bgfx::VertexDecl PosColorVertex::ms_decl; static PosColorVertex s_triangleVertices[3] = { { 0.0f, 1.0f, 0.0f, 0xff0000ff }, {-1.0f, -1.0f, 0.0f, 0xffff0000 }, { 1.0f, -1.0f, 0.0f, 0xffff00ff }, }; static const uint16_t s_triangleIndices[3] = { 0, 1, 2 }; float * view; float * proj; int _main_(int /*_argc*/, char** /*_argv*/) { uint32_t width = 1280; uint32_t height = 720; uint32_t debug = BGFX_DEBUG_TEXT; uint32_t reset = BGFX_RESET_VSYNC; bgfx::init(); bgfx::reset(width, height, reset); // Enable debug text. bgfx::setDebug(debug); // Set view 0 clear state. bgfx::setViewClear(0 , BGFX_CLEAR_COLOR|BGFX_CLEAR_DEPTH , 0x303030ff , 1.0f , 0 ); // Create vertex stream declaration. PosColorVertex::init(); // Create static vertex buffer. bgfx::VertexBufferHandle vbh = bgfx::createVertexBuffer( // Static data can be passed with bgfx::makeRef bgfx::makeRef(s_triangleVertices, sizeof(s_triangleVertices) ) , PosColorVertex::ms_decl ); // Create static index buffer. bgfx::IndexBufferHandle ibh = bgfx::createIndexBuffer( // Static data can be passed with bgfx::makeRef bgfx::makeRef(s_triangleIndices, sizeof(s_triangleIndices) ) ); // Create program from shaders. bgfx::ProgramHandle program = loadProgram("vs_cubes", "fs_cubes"); view = (float*)calloc(16,sizeof(float)); view[0] = view[5] = view[10] = view[15] = 1; proj = (float*)calloc(16,sizeof(float)); proj[0] = proj[5] = 0.9; proj[15] = 1; while (!entry::processEvents(width, height, debug, reset) ) { // Use debug font to print information about this example. bgfx::dbgTextClear(); bgfx::dbgTextPrintf(0, 1, 0x4f, "bgfx/examples/01-cube"); bgfx::dbgTextPrintf(0, 2, 0x6f, "Description: Rendering simple static mesh."); bgfx::setViewTransform(0, view, proj); const bgfx::HMD* hmd = bgfx::getHMD(); if (NULL != hmd) { bgfx::setViewRect(0, 0, 0, hmd->width, hmd->height); } else { bgfx::setViewRect(0, 0, 0, width, height); } // Set vertex and fragment shaders. bgfx::setProgram(program); // Set vertex and index buffer. bgfx::setVertexBuffer(vbh); bgfx::setIndexBuffer(ibh); // Set render states. bgfx::setState(BGFX_STATE_DEFAULT); // Submit primitive for rendering to view 0. bgfx::submit(0); // Advance to next frame. Rendering thread will be kicked to // process submitted rendering primitives. bgfx::frame(); } // Cleanup. bgfx::destroyIndexBuffer(ibh); bgfx::destroyVertexBuffer(vbh); bgfx::destroyProgram(program); free(proj); free(view); // Shutdown bgfx. bgfx::shutdown(); return 0; }

Naturally I didn't touch shaders. If we remove completely shaders from code, instances of program, triangle will become black, new achievements of hacking. I also did square, here is the relevant code:

static PosColorVertex s_triangleVertices[4] = { {-1.0f, 1.0f, 0.0f, 0xff0000ff }, {-1.0f, -1.0f, 0.0f, 0xffff0000 }, { 1.0f, -1.0f, 0.0f, 0xffff00ff }, { 1.0f, 1.0f, 0.0f, 0xffff00ff }, }; static const uint16_t s_triangleIndices[6] = { 0, 1, 2, 0, 2, 3 };

Everything else is the same as for triangle. I hope my experience helps somebody to get started. After I spent eternity in programming there are still areas completely unknown to me. If I didn't get friendly suggestion to use identity as view and orthogonal matrix as projection I would stay on Hello World/blue window.

Thread-Specific Data API

Last time it was making function thread safe or reentrant via thread local storage, now more complicated thread-specific data. Everything happens on Linux but should be applicable on any UNIX since we are using POSIX.
This one is also called thread-private data API. It creates per thread and per reentrant function storage. Process starts with key creation when thread for the first time calls function, any thread. In order to have key created once pthread_once is used. Then, once we got key, pthread_getspecific and pthread_setspecific are used to deal with thread-specific data. Here is example:

#include <pthread.h> #include <stdio.h> #include <stdlib.h> #define MAXSSZ 128 static pthread_once_t once = PTHREAD_ONCE_INIT; static pthread_key_t key; static void ctor(void){ int err; err = pthread_key_create(&key, free); if (err != 0){ perror("pthread_key_create failed"); exit(1); } } char * reentrant(char * msg){ char * storage; int err; err = pthread_once(&once, ctor); if (err != 0){ perror("pthread_once failed"); exit(1); } storage = pthread_getspecific(key); if (storage == NULL) { storage = malloc(MAXSSZ); if (storage == NULL){ perror("out of memory?"); exit(1); } err = pthread_setspecific(key, storage); if (err != 0){ perror("pthread_setspecific failed"); exit(1); } } if(msg != NULL) snprintf(storage, MAXSSZ, "Message is '%s'", msg); return storage; } static void * threadFunc(void *arg) { char *str; str = reentrant("Hello I am lumberjack!"); printf("From thread: %s\n", str); sleep(1); str = reentrant(NULL); printf("Again thread: %s\n", str); return NULL; } int main(int argc, char *argv[]) { pthread_t t; int err; char *str; str = reentrant("Hello from main!"); printf("Main message: %s\n", str); err = pthread_create(&t, NULL, threadFunc, NULL); if (err != 0){ perror("pthread_create failed"); exit(1); } str = reentrant("I am not lumberjack!"); err = pthread_join(t, NULL); if (err != 0){ perror("pthread_join failed"); exit(1); } printf("Main message: %s\n", str); return 0; }

To compile it the following is used:

gcc -o tsdexample tsdexample.c -pthread

Result of execution is:

Main message: Message is 'Hello from main!'
From thread: Message is 'Hello I am lumberjack!'
Again thread: Message is 'Hello I am lumberjack!'
Main message: Message is 'I am not lumberjack!'

In order to init static variable once, macro  PTHREAD_ONCE_INIT is used. During key creation destructor, ordinary free, is passed as parameter to pthread_key_create. Main thread and another thread then are calling reentrant function and setting and retrieving messages which are thread specific, what is expected. If we want to delete key it looks like this:

if(&key != NULL){ err = pthread_key_delete(key); if (err != 0){ perror("pthread_key_delete failed"); exit(1); } }

Though in example program it is static variable and it will go out of scope together with program.

Thread safety

Before I start with thread safety, evolving design, if something can be improved don't be lazy.
Now I remembered that GCC supports 128 bit integers and that Fibonacci numbers can be calculated up to forty digits. There is problem with printing those 128 bit integers but somebody already offered utility function to convert them to string, that was Perkins . I only added zero case to his solution.

#include <stdio.h> #include <stdlib.h> void uint128_to_str_iter(__uint128_t n, char *out,int firstiter){ static int offset=0; if (firstiter){ offset=0; } if (n == 0) { return; } uint128_to_str_iter(n/10,out,0); out[offset++]=n%10+0x30; } char* uint128_to_str(__uint128_t n){ if(!n) { char * c = (char*)calloc(sizeof(char),2); c[0] = '0'; return c; } char *out=calloc(sizeof(char),40); uint128_to_str_iter(n, out, 1); return out; } __uint128_t * allocate(uint i){ __uint128_t* res = (__uint128_t*)malloc(2 * sizeof(__uint128_t)); res[0] = 1; res[1] = i; return res; } __uint128_t * recurse(uint i){ if(i<2) return allocate(i); __uint128_t * t = recurse(i/2); __uint128_t t0 = t[0]*t[0]+t[1]*t[1]; t[1] = t[1]*((t[0]<<1)-t[1]); t[0] = t0; if(i%2){ t0 = t[0]+t[1]; t[1] = t[0]; t[0] = t0; } return t; } __uint128_t square(uint n){ __uint128_t * result = recurse(n); __uint128_t r = result[1]; free(result); return r; } uint main(){ uint i; for(i=0; i<187; i++){ char * str = uint128_to_str(square(i)); printf("F(%d) = %s\n", i, str); free(str); } return 0; }

Now we can go up to 186th Fibonacci number without overflow.

Threads

There is few buzz words which people are using in job ads, related to threads, but usually they fail to define them. For example multithreading, concurrency, thread safety, reentrant function and similar.
What is reentrant function or thread safe function? That would be such function that does not use statically allocated or global variables and result depends only on input arguments. For example:

int increase(int i){ static counter = 0; counter += i; return counter; }

is not reentrant or threadsafe. If more than one thread calls that function in the same time, that is concurrency, it will produce unpredictable result. Even if it is called sequentially result will be influenced by previous calls, possibly from different thread. We are on Linux and we are using POSIX threads. So, here is example where two threads are calling nonreentrant function:

#include <stdio.h> #include <stdlib.h> #include <pthread.h> int increase(int i){ static int counter = 0; counter += i; return counter; } void * runnable1(void *arg){ int i; for(i = 1; i < 5; i++){ printf("thread 1 call %d = %d, expecting %d\n", i, increase(2), 2*i); } return((void *)1); } void * runnable2(void *arg) { int i; for(i = 1; i < 5; i++){ printf("thread 2 call %d = %d, expecting %d\n", i, increase(3), 3*i); } pthread_exit((void *)2); } int main(void) { int error; pthread_t tid1, tid2; void * exitCode; error = pthread_create(&tid1, NULL, runnable1, NULL); if (error != 0){ perror("create thread 1 failed"); exit(1); } error = pthread_create(&tid2, NULL, runnable2, NULL); if (error != 0){ perror("create thread 2 failed"); exit(1); } error = pthread_join(tid1, &exitCode); if (error != 0){ perror("join thread 1 failed"); exit(1); } printf("thread 1 exit code %ld\n", (long)exitCode); error = pthread_join(tid2, &exitCode); if (error != 0){ perror("join thread 2 failed"); exit(1); } printf("thread 2 exit code %ld\n", (long)exitCode); return 0; }

To compile it I used:

gcc -o notreentrant -g -gdwarf-2 notreentrant.c -pthread

That -gdwarf-2 story is distraction, I am using gcc version 4.9.2 built from source on old Mint based on Ubuntu 12.04 and new gcc outputs by default debug info which gdb doesn’t understand. If you just built new gcc and gdb doesn't work as expected, that is cure. Linker switch -pthread is required.
Example output from execution looks like this:

thread 1 call 1 = 2, expecting 2
thread 1 call 2 = 7, expecting 4
thread 1 call 3 = 9, expecting 6
thread 1 call 4 = 11, expecting 8
thread 2 call 1 = 5, expecting 3
thread 2 call 2 = 14, expecting 6
thread 2 call 3 = 17, expecting 9
thread 2 call 4 = 20, expecting 12
thread 1 exit code 1
thread 2 exit code 2

How do we remedy that? We make increase reentrant or thread safe:

int increase(int i){ static __thread int counter = 0; counter += i; return counter; }

We requested thread local storage, available since kernel 2.6 and supported by gcc 3.3 and higher. When thread terminates and goes out of scope, local thread storage does to. We could make function reentrant via using thread specific data, but that is much more code, maybe next time.

Similarities and differences between Java and C

As almost everybody knows Java was intended to be sort of C without pointers and to be used in smart home appliances. And then Gosling and his co-workers were drinking too much coffee and it come out more like C++ without pointers, resource management and multiple inheritance. So, how really different can be coding the same task in C and Java. Practically we are addressing just resource management part, we will not try to go OO in C. We implement fast Fibonacci algorithm in Java.

import java.math.BigInteger; public class Example { /* |1 1| <- we are using this row |1 0| */ static BigInteger[] Q = {BigInteger.ONE, BigInteger.ONE}; static BigInteger[] I = {BigInteger.ONE, BigInteger.ZERO}; /* F(2n+1) = F(n+1)^2+F(n)^2 F(2n) = F(n)*(2*F(n+1)−F(n)) */ static BigInteger[] squareIt(int n) { if (n == 0) return I; if (n == 1) return Q; BigInteger[] t = squareIt(n / 2); BigInteger[] res = {t[0].multiply(t[0]).add(t[1].multiply(t[1])), t[1].multiply(t[0].shiftLeft(1).subtract(t[1]))}; if(n%2==1) return new BigInteger[]{res[0].add(res[1]), res[0]}; return res; } public static void main(String[] env) { for(int i = 0; i<1000; i++) System.out.println("F("+i+") = "+squareIt(i)[1]); } }

It is really very fast, logarithmic fast. Now we try to do the same in C, we will skip BigInteger and use long. The first thing which wont work in C is array allocation, declaring them like that will create local variable. So we create function to allocate our arrays in order to return them to caller:

long * allocate(){ return (long*)malloc(2 * sizeof(long)); }

Those Q and I arrays can be global variables and we are ready to go, almost. We can not declare t as array since initializer can't be function call. Not big deal, we will use pointer to long but that introduces another problem. That pointer may point to global variables Q and I or allocated variables. Again we can check to what it points and if it doesn't point to Q or I we can call free. Already we have feeling that those arrays returned by squaring function are somehow polymorphic and in Java they were not like that. Allocating and freeing arrays on every step of recursion and checking should we free or not doesn't look right. Attempt to literally translate Java code may look something like this:

long * recurse(int i){ if(i==0) return I; if(i==1) return Q; long * t = recurse(i/2); long * r = allocate(); r[0] = t[0]*t[0]+t[1]*t[1]; r[1] = t[1]*((t[0]<<1)-t[1]); checknfree(t); if(i%2){ long * odd = allocate(); odd[0] = r[0]+r[1]; odd[1] = r[0]; free(r); return odd; } return r; }

If Q and I arrays are created using malloc we could do reassignments of initial array and free it at the end of calculation. So no global Q and I but they will be allocated on the heap and serve all recursive calls.

#include <stdio.h> #include <stdlib.h> long * allocate(int i){ long* res = (long*)malloc(2 * sizeof(long)); res[0] = 1; res[1] = i; return res; } long * recurse(int i){ if(i<2) return allocate(i); long * t = recurse(i/2); long t0 = t[0]*t[0]+t[1]*t[1]; t[1] = t[1]*((t[0]<<1)-t[1]); t[0] = t0; if(i%2){ t0 = t[0]+t[1]; t[1] = t[0]; t[0] = t0; } return t; } long square(int n){ long * result = recurse(n); long r = result[1]; free(result); return r; } int main(){ int i; for(i=0; i<93; i++) printf("F(%d) = %ld\n", i, square(i)); return 0; }

Now if we run valgrind on our program it will report:

==18896== HEAP SUMMARY:
==18896==     in use at exit: 0 bytes in 0 blocks
==18896==   total heap usage: 93 allocs, 93 frees, 1,488 bytes allocated
==18896== 
==18896== All heap blocks were freed -- no leaks are possible

Looking now at initial Java solution, it also could benefit from array reuse instead of allocating new ones on every step. Garbage collector is nice thing but not thinking at all about resource management may result in lower quality of code.

Functions, pointers, nested functions, clojures

While ago GCC introduced nested functions which are allowing easy solution of funargs problem. With funargs problem solved C can accommodate closures and provide everything what different modern languages can, except funny syntax. In order to demonstrate that we need function pointers and they are not part of modern languages derived from C. So, we start with function pointers refresher.

Function pointers

They are more cryptic than other pointers and they scare away younger generations of programmers. We will declare function and pointer to it:

int add( int i, int j) { return i + j; } int main(){ int (*fptr)(int,int) = add; printf("%d\n", fptr(2, 3)); return 0; }

We have return type, variable name in brackets and type list for parameters. We could also use address of operator during assignment. How we pass it as parameter?

int execute(int (*fptr)(int,int), int a, int b) { return fptr(a, b); } printf("%d\n", execute(fptr, 2, 3));

How we return it, write function which is returning function pointer? There is user friendly way, we declare typedef for function pointer:

typedef int (*fptra)(int,int); fptra get() { return add; } printf("%d\n", get()(2, 3));

But there is also user unfriendly way:

int (*fptr2fptr())(int, int) { return add; } int (*fptr)(int,int) = fptr2fptr(); printf("%d\n", fptr(2, 3)); printf("%d\n", (*fptr2fptr())(2, 2));

Return type of return type goes in front, inside first pair of brackets name and own parameters, inside the second pair of brackets list of parameter types of return type. And just for those who value extreme programming above all, pointer to function which returns function which returns function:

int (*(*f2f2f())(void))(int,int){ return fptr2fptr; } int (*(*f2f)())(int,int) = f2f2f(); int (*fadd)(int,int) = f2f(); printf("%d\n",fadd(4, 3));

Nested Functions

Those are GCC specifics and they are just ordinary functions but inside another function. Standard C will not let you define function within function. To demonstrate we can do trampolining of one notoriously recursive function.

int factorial(int i){ int acc = 1; void * f() { if (i < 2) return 0; acc *= i; --i; return f; } while(f()) continue; return acc; } int main() { int i; for(i = 2; i < 14; i++) printf("%d! is %d\n", i, factorial(i)); return 0; }

Here nested function is accessing variables which are host scoped and returns self or NULL. We got whole function back but we are not really using it, except to exit while loop if it is NULL. To remedy that we will dispatch those nested functions out of host function.

struct closure{ int counter; int visited; } data; int (*pgen(int i))(int){ int increase(int k){ data.counter += k; data.visited++; return data.counter; } int decrease(int k){ data.counter -= k; data.visited++; return data.counter; } if(i) return increase; return decrease; } int main(){ data.counter = 4; data.visited = 4; int (*incr)(int) = (*pgen)(1); int (*decr)(int) = (*pgen)(0); printf("counter = %d visited = %d\n", data.counter, data.visited); printf("counter = %d\n", incr(2)); printf("counter = %d\n", decr(1)); printf("counter = %d visited = %d\n", data.counter, data.visited); printf("counter = %d\n", incr(4)); printf("counter = %d\n", decr(1)); printf("counter = %d visited = %d\n", data.counter, data.visited); return 0; }

Here we have struct which is global variable, it is not really closure but just named like that, and one function generator. If we pass zero to generator we get one function back and for non zero the other one. Both nested functions now operating on global variable. In previous example we were working on variables belonging to host function, in this case if we try the same we will have problems since host's variables went out of scope.

Funarg problem

This one is related to functional languages and nested functions. If we pass nested function as argument to another function that is called downward funarg problem. Returning nested function to caller is upwards funarg problem. If any of passed or returned functions references variable from scope of declarer, those must be available to nested function so it can be executed. Passing nested function as argument to another function is not problem in C since all local variables of declarer are alive.

void execute(void(*fptr)(int), int i){ fptr(i); } void print(int(*fptr)(void)){ printf("counter = %d\n", fptr()); } int main(){ int counter = 0; void increase(int k){ counter += k; } void decrease(int k){ counter -= k; } int getter(){ return counter; } execute(increase, 3); print(getter); execute(decrease, 2); print(getter); return 0; }

Returning nested function is more problematic because declarer went out of scope. That could be addressed like in Java, if anonymous function uses some declarer's variable, that variable must be final. In C there is even more options, we can use static variables or allocate them on the heap.

int (*pgen(int i))(int){ static int counter = 0; int increase(int k){ counter += k; return counter; } int decrease(int k){ counter -= k; return counter; } if(i) return increase; return decrease; } int main(){ int (*incr)(int) = (*pgen)(1); int (*decr)(int) = (*pgen)(0); printf("counter = %d\n", incr(2)); printf("counter = %d\n", decr(1)); printf("counter = %d\n", incr(4)); printf("counter = %d\n", decr(1)); return 0; }

It is easier to use static than malloc and free. Removing static from counter declaration will result in exception during execution of program. So, funargs problem is not problem for C in GCC version. This makes C almost functional language, functional with few extras.