Embedded C Language - Data Storage and Pointers

Keyword Classification Interpretation

In C language, keywords are identifiers with special meanings and purposes, used to define variable types, control program flow, specify storage attributes, etc. Below is a simple classification interpretation of these keywords:

Storage Class Keywords: such as auto, register, static, extern, used to define the storage location and scope of variables. For example, static is used to define static variables, whose values persist between function calls.
Type Definition Keywords: such as char, int, float, double, signed, unsigned, long, short, etc., used to define basic data types.
Control Flow Keywords: such as if, else, switch, case, for, while, do, break, continue, goto, default, used to control the program execution flow.
Other Keywords: such as const used to define constants, volatile used to define variables that may be changed unexpectedly, typedef used to define new type names, etc.

Byte Order and Bit Order

Byte order and bit order are the same, using big-endian format. In big-endian format, the most significant byte of data is stored at the lowest memory address during data transmission and storage. For example, a 32-bit integer 0x12345678 is stored in big-endian format as: address 0 stores 12, address 1 stores 34, address 2 stores 56, address 3 stores 78.

Structure Alignment Modulus

The structure alignment modulus is the size of the largest member in the structure, or an integer multiple of its size. The purpose of alignment is to improve data access efficiency and avoid performance issues caused by unaligned data. For example, if a structure contains an int (4 bytes) and a char (1 byte), the alignment modulus of that structure is 4 bytes, and the total size of the structure is 8 bytes (4-byte alignment).

Type Definition

Using typedef allows the definition of new type names, improving code readability and maintainability. For example:

typedef struct student {    char name[20];    int age;    float score;} student_t;

Here, a new type student_t is defined to represent a student structure.

Enumeration Type

The enumeration type belongs to the integer type, and its enumeration constants are replaced by corresponding integer values at compile time. For example:

typedef enum color {    red,    white,    black,    green,    color_num} color_t;

Here, a color enumeration type color_t is defined, where red has a value of 0, white has a value of 1, and so on, color_num has a value of 4, indicating the number of enumeration elements.

Constant Folding

Constant folding is a technique used by the compiler to optimize constant expressions during the compilation phase. For example:

const int a = 3;const int b = a + 5;

The compiler will calculate the value of b as 8 during the compilation phase, rather than calculating it at runtime.

Left-Right Rule

The left-right rule is a method used to parse complex pointer declarations. For example:

int *(*(*f)(int))[10];

The parsing process is as follows:

Start from the innermost parentheses, f is a pointer.
Looking to the right, f is a function pointer, and the parameter type of that function is int.
Looking to the left, f points to a function that returns a pointer.
Exiting the parentheses, continue parsing; the pointer points to an array, and the element type of the array is int*, with an array size of 10.

Difference Between Arrays and Pointers

The array name represents the array type when declaring the array, while in other cases, it represents the address of the first element of the array. A pointer is a variable used to store a memory address. For example:

int arr[10];int *ptr = arr;

Here, arr is an array, and ptr is a pointer that points to the first element of the array arr.

Pointer Arrays and Array Pointers

Pointer Array: is an array where all elements are pointers. For example:

int *ptr_arr[10];

Here, a pointer array of size 10 is defined, where each element is a pointer to int.

Array Pointer: is a pointer that points to an array. For example:

int (*arr_ptr)[10];

Here, a pointer arr_ptr is defined, which points to an array of size 10 of int.

Pointers and Structures

When a structure variable is passed as a function parameter or return value, all member data of the structure is passed. In contrast, an array parameter is an address. For example:

void func(struct student s) {    // Operate on structure variable s}void func_ptr(struct student *s) {    // Operate on structure pointer s}

Function Pointers and Pointer Functions

Function Pointer: is a pointer that points to a function. For example:

int (*func_ptr)(int, int);func_ptr = &sum;

Here, func_ptr is a pointer to a function that returns an int and takes two int parameters.

Pointer Function: is a function that returns a pointer. For example:

int *func(int a, int b) {    // Return an int pointer}

Void Pointer

void* is a generic pointer type that can point to any data type. When using it, type conversion is required. For example:

void *ptr;int a = 10;ptr = &a;int *int_ptr = (int*)ptr;printf("%d", *int_ptr);

Here, ptr is a void* pointer pointing to the integer variable a, and through type conversion, it is converted to an int* pointer to access its value.

Embedded C Language – Data Storage and Pointers