Question

I have written a straightforward C code that uses an engine to run two different algorithms depending on user input. It uses function pointers to the algorithm methods and objects. There is a nasty memory bug somewhere that I can not track down, so maybe I am allocating memory in the wrong way. What is going wrong?

Below is (the relevant parts of) a minimal working example of the code.

main.c

#include "engine.h"

int main()
{
  char *id = "one";

  Engine_t eng;

  Engine_init(&eng);
  Engine_select_algorithm(eng, id);
  Engine_run(eng);
}

engine.h

typedef struct _Engine *Engine_t;

engine.c

#include "engine.h"
#include "algorithm_one.h"
#include "algorithm_two.h"

typedef struct _Engine
{ 
  void *p_algorithm;

  void (*init)(Engine_t);
  void (*run)(Engine_t);

} Engine;

void Engine_init(Engine_t *eng)
{
  *eng = malloc(sizeof(Engine));

  (*eng)->p_algorithm = NULL;
}

void Engine_select_algorithm(Engine_t eng, char *id)
{
  if ( strcmp(id, "one") == 0 )
    {
      eng->init = Algorithm_one_init;
      eng->run  = Algorithm_one_run;
    }
  else if ( strcmp(id, "two") == 0 )
    {
      eng->init = Algorithm_two_init;
      eng->run  = Algorithm_two_run;
    }
  else
    {
      printf("Unknown engine %s.\n", id); exit(0);
    }

  eng->init(eng);
}

void Engine_run(Engine_t eng)
{
  eng->run(eng);
}

void Engine_set_algorithm(Engine_t eng, void *p)
{
  eng->p_algorithm = p;
}

void Engine_get_algorithm(Engine_t eng, void *p)
{
  p = eng->p_algorithm;
}

algorithm_one.h

typedef struct _A_one *A_one_t;

algorithm_one.c

#include "engine.h"
#include "algorithm_one.h"

typedef struct _A_one
{ 
  float value;
} A_one;

void Algorithm_one_init(Engine_t eng)
{
  A_one_t aone;
  aone = malloc(sizeof(A_one));
  aone->value = 13.0;

  //int var = 10;

  Engine_set_algorithm(eng, &aone);
}

void Algorithm_one_run(Engine_t eng)
{  
  A_one_t aone;
  Engine_get_algorithm(eng, &aone);

  printf("I am running algorithm one with value %f.\n", aone->value);
  // The code for algorithm one goes here.
}

The code for algorithm_two.h and algorithm_two.c are identical to the algorithm one files.

There must be a memory bug involved, because the code runs as given, but if I uncomment the

//int var = 10;

line in algoritm_one.c the code crashes with a segmentation fault.

Answer 1

You pass the wrong thing to Engine_set_algorithm. You are passing the address of a local variable rather than the address of the algorithm. You need to write:

Engine_set_algorithm(eng, aone);

And also Engine_get_algorithm is wrong. You are passed a pointer by value and modify that pointer. So the caller cannot see that modification. You need it to be:

void Engine_get_algorithm(Engine_t eng, void **p)
{
  *p = eng->p_algorithm;
}

I think your code would be easier if you defined a type to represent an algorithm. That type would be just a void*, but it would make the code much easier to read. What’s more, I would make Engine_get_algorithm return the algorithm.

algorithm Engine_get_algorithm(Engine_t eng)
{
    return eng->p_algorithm;
}

void Engine_set_algorithm(Engine_t eng, algorithm alg)
{
    eng->p_algorithm = alg;
}