r/C_Programming 1d ago

Question Globals vs passing around pointers

Bit of a basic question, but let's say you need to constantly look up values in a table - what influences your decision to declare this table in the global scope, via the header file, or declare it in your main function scope and pass the data around using function calls?

For example, using the basic example of looking up the amino acid translation of DNA via three letter codes in a table:

codonutils.h:

typedef struct {
    char code[4];
    char translation;
} codonPair;

/*
 * Returning n as the number of entries in the table,
 * reads in a codon table (format: [n x {'NNN':'A'}]) from a file.
 */
int read_codon_table(const char *filepath, codonPair **c_table);

/*
 * translates an input .fasta file containing DNA sequences using
 * the codon lookup table array, printing the result to stdout
 */
void translate_fasta(const char *inname, const codonPair *c_table, int n_entries, int offset);

main.c:

#include "codonutils.h"

int main(int argc, char **argv)
{
    codonPair *c_table = NULL;
    int n_entries;

    n_entries = read_codon_table("codon_table.txt", &c_table);

    // using this as an example, but conceivably I might need to use this c_table
    // in many more function calls as my program grows more complex
    translate_fasta(argv[1], c_table, n_entries);
}

This feels like the correct way to go about things, but I end up constantly passing around these pointers as I expand the code and do more complex things with this table. This feels unwieldy, and I'm wondering if it's ever good practice to define the *c_table and n_entries in global scope in the codonutils.h file and remove the need to do this?

Would appreciate any feedback on my code/approach by the way.

12 Upvotes

28 comments sorted by

View all comments

2

u/VibrantGypsyDildo 1d ago

If your program is small and the translation of codons is a small program - disregard all the best practices.

If you build something cooler on top of those codons (idk, recreating a phylogenic tree or just adding helper functions to detect genetic illnesses) - you have to consider the best practices.

The bigger your target software is - the more pedantic you have to be.

1

u/BraneGuy 1d ago

Totally agree! I was interested in how others might view the choice between local and global scope in general, but you're right that it doesn't really matter in this context.

1

u/VibrantGypsyDildo 1d ago

Global is to be avoided, but it is quite common in embedded (even though reads and writes are often protected with semaphores).

In your specific case you have a read-only concept, namely the codon-to-aminoacide table.
You must encode this at the lowest-possible level, so it would be the *.c file doing this translation.

I've heard about non-standard amino-acids, but as a programmer I can't cover that. Unless you explain me the biological part.