Скачать или смотреть Creating a Generic Function in C: Simplifying Code Duplication in Embedded Systems

Learn how to create a more manageable function structure in C while adhering to MISRA standards, without introducing redundancy that could impact safety.
---
This video is based on the question https://stackoverflow.com/q/62792624/ asked by the user 'SimpleThings' ( https://stackoverflow.com/u/7169923/ ) and on the answer https://stackoverflow.com/a/62829020/ provided by the user 'Lundin' ( https://stackoverflow.com/u/584518/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: C-languge: Creating a generic function out of two similiar functions which have different return values

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Creating a Generic Function in C: Simplifying Code Duplication in Embedded Systems

In embedded systems programming, especially in safety-critical applications, we often find ourselves repeating similar code patterns, which can lead to poor maintainability and potential errors. This article explores how to effectively consolidate two similar functions with different return types into a more generic solution, while adhering to best practices in coding standards like MISRA.

The Problem Overview

You might encounter scenarios where you have two functions that, while accepting different input types and returning different output types, have identical logic. Let's take the following two functions as examples:

Function_One_u4: Accepts two uint8 parameters and returns a uint8.

Function_Two_u16: Accepts two uint16 parameters and returns a uint16.

Both functions utilize a switch-case structure to determine the output based on a common mode parameter, yet the return values differ significantly:

[[See Video to Reveal this Text or Code Snippet]]

Creating a generic function might seem like a reasonable approach to eliminate code duplication. However, C does not naturally support templates like other languages do.

Solution Approach

Avoiding Complex Generic Programming

In safety-critical systems, you should be cautious with generic programming for two reasons:

Code Coverage: All execution paths must be tested. Merging functions can obscure which paths are executed, complicating debugging.

Determinism: Safety-critical software must behave predictably. Generic solutions can introduce ambiguity in behavior and error handling.

Refactoring into a More Manageable Function

Instead of merging functionalities into a generic function template, consider adding an additional parameter that handles different types. Here's a revised approach:

[[See Video to Reveal this Text or Code Snippet]]

Key Adjustments

Unified Function: A single function now handles both types through the utype parameter.

Improved Readability: The use of a single result variable simplifies return statements.

Compliance with Standards: This approach adheres to MISRA standards, promoting code safety and preventing type mismatch errors.

Important Considerations

Safety in Multicast: Ensure type safety when casting between uint8_t and uint16_t while keeping the value within permissible limits.

Static Analysis: Always run your code through a static analyzer to check for compliance with MISRA guidelines.

Conclusion

While it may seem convenient to switch to a generic programming model in C, especially within safety-critical applications, it is crucial to maintain clarity and determinism in your logic. By adopting structured parameter handling, you can eliminate redundancy while adhering to the strict requirements of maintainability and safety in embedded systems.

By incorporating these recommendations, you will enhance code clarity and ensure your application runs safely and efficiently in safety-critical environments.