In the world of C programming, the clarity and maintainability of your code often hinge on a seemingly simple yet crucial aspect: naming conventions. From variables to functions, constants to macros, the names you choose can significantly impact how easily others (and your future self) understand and work with your code.
While the C language itself doesn’t enforce any specific rules for naming, decades of programming practice have given rise to widely accepted conventions. These conventions are not merely about aesthetics—they are about fostering consistency, improving readability, and reducing errors in complex projects.
Whether you’re a seasoned programmer refining your craft or a beginner stepping into the C language for the first time, understanding and adopting effective naming conventions is an essential skill. In this article, we’ll explore the most common naming styles in C, the rationale behind them, and practical tips to help you write cleaner, more professional code.
Modules
In C, the concept of „modules” typically refers to files (like .c and .h files) that encapsulate related functions, data, and structures. Naming conventions for module files are essential to ensure clarity and consistency across a project. Because the C language is often used for multi-platform development (e.g., Unix and Windows), some naming conventions cause problems across operating systems and are also error-prone due to the possibility of similar names. Here are common naming conventions for module names in C:
- Module names must be lowercase only, with no spaces. Underscores and numbers are allowed.
- Module names should be unique, or at least the major part of the name.
- Module names should describe their purpose or functionality clearly and concisely (e.g. string_parser.h)
- Module names should avoid abbreviations unless they are universally understood (e.g., calc_utils.c).
- For larger projects or libraries, it’s common to add a prefix to module names to avoid collisions with other libraries or system headers (e.g., spi_utils.h, spi_common.h).
- Module name can’t share the same name as Standard Library header file (e.g., stdio.h or math.h)
- Each module usually has an associated
.c(implementation) and.h(header) file with the same base name (e.g., memory_manager.c and memory_manager.h). - The header file should contain a preprocessor include guards against multiple inclussion ( usually with the same name as file, more about it you can read in dedicated article).
Data types
In C programming, naming conventions for data types are essential for improving code readability, maintainability, and consistency. These conventions apply to custom data types such as typedef aliases, struct, union, enum, and even standard types in some projects. Here are the common conventions:
- New structures, union and enumerations shall be named using a „typedef” keyword.
- The names for data types such as structures, unions, and enumerations should contain only lowercase letters, internal underscores, and end with the meaningful suffix (e.g., „_t” for typedef, „_s” for struct type, „_u” for unions and „_e” for enumerations
- The names of public data types should begin with a prefix that includes the module name
- Enumerators within enum types are usually written in uppercase with words separated by underscores (UPPERCASE_SNAKE_CASE)
- Avoid single-character names or overly generic names that may lead to confusion (e.g., „Data”)
Variables
Variable naming conventions in C help improve code readability, maintainability, and debugging efficiency. While C doesn’t enforce specific rules, adopting consistent conventions is a best practice
- Use variable names that clearly describe their purpose for example „student_age”
- The most common convention in C is snake_case, where words are lowercase and separated by underscores
- Avoid cryptic abbreviations; use full, meaningful words unless the abbreviation is well-known for example „max_value” instead of „mx_val”
- For constants, use all uppercase letters with underscores separating words for example „#define MAX_BUFFER_SIZE 1024” or „const int MAX_TERIES = 5;”
- For boolean variables you can useprefixes for example „is_valid” or „has_errors”
- Good idea is to use some prefixes according to variable type for example for global variable use a „g_” prefix and for static variable „s_”
- Do not use names that conflict with C reserved keywords or standard library functions.
Functions
Naming conventions for functions in C are essential to improve code readability, maintainability, and understanding in collaborative projects. While C doesn’t enforce strict rules, there are common conventions widely followed by developers:
- Avoid using a name that is used as keyword of any standard C or C++ version like „include”, „interrupt”, „inline”, „true”, „false” etc.
- Don’t use names that overlap with functions from standard library like „strlen”, „atoi”, „memset” etc.
- Don’t use underscore as a begin for the name.
- Avoid using names longer than 31 characters
- Use lowercase letters with underscores separating words for example „int get_max_value(int a, int b)”.
- Function names should start with verbs to indicate the action performed for example „compute_average”.
- Use project or module prefix. This helps avoid name collisions and indicates the module or subsystem the function belongs to
- When possible avoid abbreviations for example use „compute_sum” instead of „cmp_sum”.
- Use prefix according to function purpose for example „init” or „create” prefic for tthe initalizer functions. For „cleanup” function you can as „destroy” or „free” prefixes. Getter and Setters functions usually have „get” or „set” as part of the name.
Abbreviations
Aabbreviations are allowed and commonly used in C programming, but they should be used judiciously to maintain code readability and clarity. The use of abbreviations in names follows specific conventions to avoid confusion and ensure consistency. Here are the best practices and naming conventions for abbreviations in C:
- Use abbreviations that are widely understood or self-explanatory within the context of the project (e.g., „init” for initialize, or „cfg” for configuration).
- Avoid obscure or overly shortened abbreviations like „nzx” (unclear meaning).
- Consistency is important so if you decide to use „cfg” to shorten the word „configuration”, use the same abbreviation consistently throughout the project to avoid confusion. (e.g. don’t mix it with use of „conf” instead of previously used „cfg”)
Here is a list of abbreviations for most common names used in embedded. Don’t treat it as a rule, it’s more of a convenience. You always should use acronyms that make the most sens to you or your team.
| Initialize | init |
| Configuration | cfg |
| Number | num |
| Count | cnt |
| Length | len |
| Maximum | max |
| Minimum | min |
| Value | val |
| Pointer | ptr |
| Temporary | tmp |
| Request | req |
| Response | resp |
| Buffer | buf |
| File Descriptor | fd |
| Input/Output | io |
Summary
Choosing the right modules, variable or functions names is crucial for writing clean and maintainable C code. By following well-established naming conventions, that was covered in this article you can create code that’s easier to read, debug, and collaborate on.
In this guide we explored key best practices such as using descriptive and meaningful names and the snake_case format. We also highlighted the importance of avoiding cryptic abbreviations in favour of clear and familiar expressions. We also covered the use of UPPERCASE for constants and the use of helpful prefixes such as is_ for booleans, ptr for pointers and g_ for global variables.
By steering clear of reserved keywords and staying consistent throughout your project, you’ll make your C code cleaner, more professional, and a joy for others to work with. If you want to elevate your C coding, start by mastering these simple naming conventions!
Learn More