Assignment in the World of Pointers: The Art of Targeting

Hello embedded engineers and developers of the 123microcontroller community! Welcome back to another technical deep dive with your favorite sleep-deprived engineer.

Today, we are going to explore a fundamental concept that seems incredibly simple on the surface but hides layers of complexity in the C programming language: “Assignment.”

When we write firmware for microcontrollers, turning on a port pin (e.g., PORTB = 0xFF;) is fundamentally an “assignment.” However, when we step into the realm of Pointers, using the equals sign (=) is no longer just about putting a number into a box. It involves deep mechanical concepts known as L-values, R-values, and raw memory address management. Global C programming standards explain this extensively, and today, we’re going to decode exactly how assignment works in the context of pointers. Let’s dive in!

The Mechanisms Behind Assignment

In C, an assignment is actually an “Expression,” not just a standard “Statement.” In the context of pointers, system architecture experts outline the crucial components as follows:

1. The Rule of L-value and R-value

  • L-value (Left-value): This is whatever sits on the “left side” of the = sign. It represents a “Location” or a specific place in physical memory where data can be safely stored.
  • R-value (Right-value): This is whatever sits on the “right side” of the = sign. It represents the actual “Value” or data that you want to use.
  • Connection to Pointers: When you declare a pointer like int *pi; and execute *pi = 20;, the expression *pi is a perfectly valid L-value. By dereferencing the pointer (using *), you are specifying the exact memory location at the destination, allowing the value 20 to be stored there.

2. Pointer Assignment

When you first create a pointer, it points nowhere (or to random garbage). It is the programmer’s absolute responsibility to assign a valid memory “Address” to it before use. You cannot assign a raw integer directly to a pointer. For example, pi = num; will trigger a Syntax Error (Invalid conversion). You must use the Address-of operator (&) to extract the variable’s address: pi = #.

  • Changing the pointer’s value (pi = &i2;) changes the target it points to.
  • Changing the value via dereference (*pi = 2;) changes the data at the destination.

3. Compound Assignment (+=, -=, etc.)

C provides shorthand assignment operators like a += 5;, which is equivalent to a = a + 5;.

  • The Hardware Advantage: Using += isn’t just about writing shorter code; it forces the compiler to evaluate the L-value only once. If you have a pointer aiming at a volatile hardware register, or a complex array subscript (e.g., a[ 2 * (y - 6*f(x)) ] += 1;), evaluating it only once makes the code execute significantly faster and eliminates the massive risks associated with function side effects.

4. Array Names are NOT L-values

Although an array’s name acts like a memory address (similar to a pointer), an array name is Not Modifiable. Writing a command like vector = vector + 1; is an immediate syntax error because the array’s base address is hardcoded into the memory map during compilation.

Diagram showing L-value and R-value in Pointer Assignment

Code Example: Clean Pointer Assignments

Let’s look at a practical, clean code example demonstrating correct and incorrect assignments when working with pointers in an embedded context.

#include <stdio.h>
#include <stdint.h>

int main(void) {
    int32_t num = 5;
    int32_t val = 100;

    /* 1. Pointer Assignment: Assigning a valid Address to the Pointer */
    int32_t *pi = &num;

    /* 2. L-value Assignment: Assigning data to the targeted memory location */
    *pi = 200;
    printf("num is now: %d\n", num); // Output: 200

    /* 3. Changing the Pointer's Target */
    pi = &val;
    *pi = 500;
    printf("val is now: %d\n", val); // Output: 500

    /* 4. Using Compound Assignment */
    *pi += 50; // Changes 'val' from 500 to 550 (Evaluates *pi only once)
    printf("val after compound assignment: %d\n", val); // Output: 550

    /* =========================================
     * ❌ Common Assignment Errors to Avoid
     * ========================================= */

    // int32_t *bad_ptr = num;
    // ^ ERROR! You cannot assign a raw integer as an address to a pointer.

    int32_t sensor_array[10] = {0};
    // sensor_array = pi;
    // ^ ERROR! An array name is NOT a modifiable L-value.

    return 0;
}

Best Practices & Hidden Pitfalls

Assignments in C are riddled with traps. System programmers must be hyper-aware of these critical issues highlighted by secure coding standards:

  • The = vs == Trap (The Ultimate Classic Bug): Using = (Assignment) instead of == (Comparison) inside an if or while statement (e.g., if( x = 5 )) is the most common and infuriating bug in C. This code does not check if x equals 5; it assigns 5 to x, which always evaluates to “True”, completely destroying your program’s logic without the compiler necessarily throwing an error!
  • The Menace of Uninitialized Pointers: If you declare int *a; and immediately assign data via *a = 12; (without defining where a points), you are asking for a disaster. The uninitialized pointer holds “Garbage” data. Shoving the value 12 into a random garbage address will likely corrupt system memory or trigger an immediate Segmentation Fault.
  • Shallow Copy in Structs with Pointers: If you use the = operator to copy a structure (struct_a = struct_b;) and that struct contains a pointer, only the “Address” inside the pointer is copied, not the actual data it points to. Both structs will now point to the exact same memory block! If one modifies the data, the other is affected. You must handle this carefully with Deep Copies.
  • Chained Assignment Truncation: Writing a = x = y + 3; is legal, but extremely dangerous if a and x have different Data Types. If x is an 8-bit char and a is a 32-bit int, the result will be truncated to fit into the char first, and that corrupted/truncated value is then passed into a.

Conclusion

Assignment in C is far more than just a simple equals sign. It requires a deep understanding of the relationship between L-values (physical RAM locations) and R-values (the data). Especially when working with Pointers, differentiating between assigning an address to the pointer itself versus assigning data to the pointer’s destination is a mandatory skill for writing precise, crash-free firmware.

Has anyone here ever spent a whole day debugging just to find you accidentally typed if(x = 1) instead of if(x == 1)? (Confession time: I’ve totally been there! 😆) Or do you have any neat pointer tricks? Drop by and share your experiences on our community board at www.123microcontroller.com! See you in the next article. Happy Coding!