Reply with “Embedded Base” to get more learning materials for free

When writing code, we assign an initial value to variables to prevent uncertainty in their initial values due to the compiler. For numeric type variables, they are often initialized to 0, but how should other types of variables, such as char, pointer, etc., be initialized?

Initialization of Numeric Variables

Integer and floating-point variables can be initialized at the time of definition, generally initialized to 0.1int inum = 0;2float fnum = 0.00f;3double dnum = 0.00;

Initialization of Character Variables

Character variables can also be initialized at the time of definition, generally initialized to '\0'.1char ch = '\0';

String Initialization

There are many methods for string initialization; I will briefly introduce three. Since a string is essentially an array of characters, the ultimate goal of its initialization is to initialize each character in the character array to '\0'.

Method 1: Use an empty string"".

char str[10] = “”;

Method 2: Use memset.

char str[10];memset(str, 0, sizeof(str));

Method 3: Write a loop.

char str[10];for(int i = 0; i < 10; i++){ str[i] = ‘\0’;}The second initialization method is recommended, which is to use memset for initialization.

Many people have a vague understanding of the memset function, knowing that it can initialize many types of variables but not understanding its principle. Here is a brief explanation: memset fills by bytes. First, look at the following code:

int num；memset(&num, 0, sizeof(int));printf(“step1=%d\n”, num);memset(&num, 1, sizeof(int));printf(“step2=%d\n”, num);

Before discussing, let’s look at the output results

chenyc@DESKTOP-IU8FEL6:~/src$ gcc -o memset memset.c -gchenyc@DESKTOP-IU8FEL6:~/src$ ./memsetstep1 = 0step2 = 16843009chenyc@DESKTOP-IU8FEL6:~/src$

Seeing this output, is it different from what you imagined?

step1 = 0 is understandable, but step2 = 16843009 is confusing for many. According to common sense, shouldn’t it be = 1? This is what I want to say: memset fills by bytes. We know that int is 4 bytes (each byte has 8 bits), represented in binary as:00000000 00000000 00000000 00000000

According to the principle of byte filling, the result of step1 is that all 4 bytes are filled with 0, so the result remains 0:

00000000 00000000 00000000 00000000

While step2 fills each byte with 1 (note that it is each byte, not each bit), so the corresponding result should be:

00000001 00000001 00000001 00000001

Everyone can convert the above binary number to decimal and see if it is 16843009. So strictly speaking, the memset function itself does not have the function of initialization; it is purely a byte-filling function, and people have extended its use to initialization.

There is a small trick in string initialization. We know that a string is essentially a character array, so it has two characteristics:

The string is continuous in memory,
The string ends with '\0'. Therefore, when initializing, we always prefer to allocate memory with a length of the string plus 1.

char year[4+1];memset(year, 0, sizeof(year));strcpy(year,“2018”);

Pointer Initialization

Generally, pointers are initialized to NULL.int *pnum = NULL;int num = 0;pnum = &num;Pointers are both loved and hated. Generally, integers, strings, etc., can be used directly after initialization, but if a pointer is initialized to NULL and not allocated memory for that pointer, it can lead to unpredictable errors (the most common is a segmentation fault caused by dereferencing a null pointer).In dynamic memory management, since the memory for variables is allocated on the heap, functions like malloc, calloc, etc., are used to request dynamic memory, and after use, it needs to be released promptly. After releasing dynamic memory, the pointer should be set to null, which is often overlooked.char *p = NULL; p=(char *)malloc(100); if(NULL == p){ printf(“Memory Allocated at: %x\n”,p); }else{ printf(“Not Enough Memory!\n”); } free(p); p = NULL; // This line to set the pointer to null is essential; otherwise, it is likely to operate on this wild pointer unknowingly, leading to serious issues.Many people often make a mistake. We know that when a pointer is passed as an argument, it degenerates into an array, so many think of using memset to initialize that pointer:void fun(char *pstr){ memset(pstr, 0, sizeof(pstr)); …}This writing is incorrect. Regardless of whether pointers can be initialized with memset, pointers first store a 4-byte address, so sizeof(pstr) will always be = 4, making such initialization meaningless.

Structure Initialization

Structure initialization is relatively simple, generally using memset method.typedef struct student{ int id; char name[20]; char sex;}STU;STU stu1;memset((char *)&stu1, 0, sizeof(stu1));Regarding the length issue of initializing structures, that is, the third parameter of memset, generally, passing the data type and variable name has the same effect. In the above example, the following writing is equivalent:memset((char *)&stu1, 0, sizeof(STU));However, for initializing arrays of structures, the length needs to be noted. Using the above example for illustration:STU stus[10];memset((char *)&stus, 0, sizeof(stus)); // Correct, the array itself is continuous in memory, so sizeof gives the byte length of the array.memset((char *)&stus, 0, sizeof(STU)); // Incorrect, only the first STU structure is initialized, and the other 9 STU elements are not initialized.memset((char *)&stus, 0, sizeof(STU)*10); // Correct, the effect is the same as the first one.Some people habitually write the second parameter of memset in the following form:memset((char *)&stu1, 0x00, sizeof(stu1));As long as you understand that memset fills by bytes, you will know that this writing is also correct and has no issues.

Disclaimer: The content of this article is sourced from the internet, and the copyright belongs to the original author. If there are any copyright issues, please contact for removal.

How to Initialize Variables in Embedded Programming?

Initialization of Numeric Variables

Initialization of Character Variables

String Initialization

Pointer Initialization

Structure Initialization

Leave a Comment Cancel reply

Initialization of Numeric Variables

Initialization of Character Variables

String Initialization

Pointer Initialization

Structure Initialization

Related posts

Leave a Comment Cancel reply