allocating memory to a pointer of an array of structures

This pointer

codificacion **matcod;

is uninitialized and has an indeterminate value. So dereferencing it like *matcod results in undefined behavior.

Maybe you mean the following

codificacion *matcod;
matcod = malloc( 256 * sizeof( *matcod ) );

Or something like the following

codificacion *p;
codificacion **matcod = &p;
*matcod=malloc(256*sizeof((*matcod)[0]));

For example if you have a function defined like

void f( codificacion **matcod )
{
    *matcod=malloc(256*sizeof((*matcod)[0]));
    //...
}

then it can be called like

codificacion *matcod;
f( &matcod );

You are probably expected to write a function that takes a pointer to a pointer to this array of structures as an argument. So codificacion **matcod is the argument of the function, not a local undefined variable which causes undefined behavior when you dereference it to store the address of the allocated array.

Here is a modified version:

typedef struct codif {
    unsigned char simbolo;
    int nbits;
    unsigned int codigo;
} codificacion;

int allocate_array(codificacion **matcod) {
    *matcod = malloc(256 * sizeof((*matcod)[0]));
    return *matcod != NULL;
}

And call this function passing the address of an actual pointer:

    codificacion *mat;
    if (!allocate_array(&mat)) {
        printf("allocation error\n");
    }

You should always declare your variables with something. Compilers will not always zero-out uninitialized variables. I'm also a big fan of using calloc when declaring arrays -- it's a stylistic choice, but especially with arrays of pointers, ensures everything is zeroed out. Uninitialized data can be hell to debug.

codificacion **matcod = NULL;
matcod = calloc(256, sizeof(codificacion*));

Note that we have created a 256 element array of pointers, not whole structs, and because ** is an array of pointers to structs and not an array of structs you then need to allocate each struct:

for(int index=0; index<256; index++)
  matcod[index] = malloc(sizeof(codificacion));

You would then reference your elements with matcod[index]->nbits.

Now, what you should do is just implement a flat array of structs and then pass the pointer to that around. Using static allocation, you even get to avoid the calloc call.

codificacion matcod_array[256] = { 0 };
codificacion *matcod = (codificacion *)&matcod_array;

Because you're only passing a pointer to an array of structs as opposed to a pointer to an array of pointers to single structs, you would then reference elements in the array using matcod[index].nbits.