🚀 Learn BLE on Linux (BlueZ) – Programming Part 1
Hands-on Bluetooth Low Energy course. Special price: ₹399
Enroll Now on Udemy →Computed Fields in Structures
Store samples, then let a loop fill in totals, averages and grades. A practical look at derived fields in C structures for embedded C programming.
Some structure members hold data you measured; others hold data you calculated. Learning to manage derived fields in C structures is a core skill in embedded C programming, where a record often carries raw readings plus a total, an average and a status flag. In this lecture of our free C programming course we build a battery pack monitor: every cell stores four voltage samples, and one function computes everything else. It is a compact free C tutorial for nested arrays, loops and threshold logic.
What You Will Learn
- The difference between stored members and derived fields in C structures
- How to place an array inside a structure and loop over it
- How to use designated initializers to fill only the members you know
- How to write an ordered threshold ladder that assigns a grade
- When to store a computed value and when to recompute it on demand
Prerequisites
Finish the previous lecture on passing an array of structures to functions. You also need loops, if / else if chains and integer division.
Stored Members and Derived Fields in C Structures
A stored member is written once by whoever produces the data: a sensor driver, a parser, a test fixture. A derived field is a pure function of other members. Keeping both in the same structure is convenient because the record travels as one unit, and any function that receives the record has everything it needs to display or decide.
Design the Structure First
Our cell record keeps an identifier, four millivolt samples and three derived members. The sample count is a macro so the loop bound and the array size can never disagree.
#define SAMPLES 4
struct cell {
int id;
int mv[SAMPLES]; /* stored: four voltage samples in millivolts */
int total; /* derived */
int avg; /* derived */
char grade; /* derived */
};
Derived Fields in C Structures: Computing in a Loop
The grading rule is a ladder. Test the highest threshold first, because each later test only runs when the earlier ones failed. Reverse the order and every cell would match the lowest rule.
| Average (mV) | Grade | Meaning |
|---|---|---|
| 4100 or more | A | Healthy, near full |
| 3900 to 4099 | B | Good |
| 3600 to 3899 | C | Getting low |
| Below 3600 | D | Recharge or replace |
#include <stdio.h>
#define SAMPLES 4
#define CELLS 5
struct cell {
int id;
int mv[SAMPLES];
int total;
int avg;
char grade;
};
static char grade_for(int avg_mv)
{
if (avg_mv >= 4100) return 'A';
if (avg_mv >= 3900) return 'B';
if (avg_mv >= 3600) return 'C';
return 'D';
}
static void evaluate(struct cell pack[], int n)
{
for (int i = 0; i < n; i++) {
pack[i].total = 0; /* never trust the caller's value */
for (int j = 0; j < SAMPLES; j++)
pack[i].total += pack[i].mv[j];
pack[i].avg = pack[i].total / SAMPLES;
pack[i].grade = grade_for(pack[i].avg);
}
}
static void report(const struct cell *c)
{
printf("cell %d total=%-6d avg=%-5d grade=%c\n",
c->id, c->total, c->avg, c->grade);
}
int main(void)
{
struct cell pack[CELLS] = {
{ .id = 1, .mv = {4150, 4162, 4155, 4149} },
{ .id = 2, .mv = {3980, 3975, 3990, 3985} },
{ .id = 3, .mv = {3650, 3640, 3660, 3655} },
{ .id = 4, .mv = {3300, 3290, 3310, 3305} },
{ .id = 5, .mv = {4105, 4098, 4110, 4102} }
};
evaluate(pack, CELLS);
for (int i = 0; i < CELLS; i++)
report(&pack[i]);
return 0;
}
Build and Run
$ gcc -std=c17 -Wall -Wextra -o ex22 ex22.c
$ ./ex22
cell 1 total=16616 avg=4154 grade=A
cell 2 total=15930 avg=3982 grade=B
cell 3 total=14605 avg=3651 grade=C
cell 4 total=13205 avg=3301 grade=D
cell 5 total=16415 avg=4103 grade=A
Walk Through Cell 1
The samples are 4150, 4162, 4155 and 4149. Their sum is 16616. Dividing by four gives 4154, which is at least 4100, so the ladder returns A. Cell 5 averages 4103 and also earns an A, even though it sits very close to the boundary. That sensitivity is why boundary values deserve a test of their own.
Designated Initializers
The syntax { .id = 1, .mv = {...} } names the members being set. Everything you leave out, here total, avg and grade, is zero-initialised by the language. Designated initializers survive later edits to the structure: if someone inserts a new member in the middle, positional initializers silently shift, but named ones keep working.
Why reset total inside the function? The function assigns pack[i].total = 0 before accumulating. If it relied on the caller’s initial value, a second call to evaluate() would add the samples to the old total and double it. Functions that fill derived fields must be repeatable.
Keeping Derived Fields in C Structures Consistent
The biggest risk with derived fields in C structures is a stale value. Suppose a driver overwrites mv[2] after evaluate() has run. The stored total and grade now describe data that no longer exists, and nothing in the language warns you. Three habits prevent this. First, funnel all writes to the stored samples through one setter function that calls the recompute step afterwards. Second, name the derived members clearly, perhaps with a comment saying “derived, do not write”. Third, when the structure crosses a module boundary, document which module owns the computation. Teams that skip these habits end up debugging grades that disagree with their own samples.
A related trick is the validity flag: add a small int valid member, clear it whenever a sample changes, and set it inside evaluate(). Readers can then refuse to trust a record whose flag is zero. The cost is one more byte per record, which is a fair price for a guarantee in safety-related embedded C programming.
Store It or Recompute It?
| Approach | Advantage | Drawback |
|---|---|---|
| Store derived fields | Fast reads, record is self-contained | Can go stale if a sample changes later |
| Recompute on demand | Never stale, smaller structure | Extra CPU work every time |
On a small microcontroller with a slow clock, computing once per sampling cycle and storing the answer is usually the better trade. If samples change often and are read rarely, recomputing wins. Whatever you choose, document it next to the structure.
Common Mistakes With Derived Fields in C Structures
Integer division truncates. A total of 16619 divided by 4 gives 4154, not 4154.75. If you need the fraction, keep the total and compute in a wider or floating type, or scale values before dividing.
- Total overflow on 16-bit targets: on a device where
intis 16 bits the limit is 32767, so just eight samples near 4000 mV would overflow; uselongoruint32_tfor totals - Wrong ladder order: testing the lowest threshold first makes every cell match it
- Loop bound mismatch: hard-coding 4 in one place and 5 in another reads past the array; always use the macro
- Forgetting to call evaluate: printing before computing shows zeros
Best Practices, Performance and Security
Checklist
- Write one function per job: compute in
evaluate(), print inreport() - Pass records to printing helpers as
constpointers - Use fixed-width types like
uint32_tfor totals on embedded targets - Never let sample values from an external source index an array unchecked
Summary: Derived Fields in C Structures
- Derived fields in C structures are filled by code, not by the data source
- Reset accumulators inside the computing function so it can be called again
- Order threshold ladders from the strictest test to the loosest
- Designated initializers keep your tables readable and safe against layout changes
Next, we will sort an array of structures and see why swapping whole records is expensive.
With these habits you can handle derived fields in C structures confidently, whether the record describes a battery cell, a motor phase or a network packet. The same three-step shape, store the raw data, compute once, then report, scales from this small example to production firmware, and it is a good template to reuse in your own embedded C programming projects.
Frequently Asked Questions
Can a structure contain an array in C?
Yes. The array lives inside the structure and is copied along with it when the structure is assigned or passed by value.
What happens to members I leave out of an initializer?
They are set to zero, which for integers means 0 and for characters means the null byte.
Should derived fields be stored in the structure?
Store them when reads are frequent and the source data changes rarely. Otherwise compute them when needed.
Why is my average wrong by a small amount?
Integer division discards the remainder. Use a larger scale or floating point if you need the fraction.
Is this pattern used in real firmware?
Constantly: battery monitors, sensor hubs and telemetry packets all combine raw samples with computed summaries.
Learn Embedded C Programming for Free
Every lecture in this free embedded C course ships with original code you can compile today.

2 Comments