Understanding Variable Types and Operations in C Programming

In C programming, integer variables store integer values and are divided into char, short, int, and long types based on byte space and processor unit.

### C Programming: Understanding Variable Types, Memory Addresses, and Operators
* 💡 "Integer variables are meant to store **integer values**, and floating-point variables are meant to store **floating-point values**."
* 📏 In C, integer variables are divided into `char`, `short`, `int`, and `long` types, with `char` generally storing **one byte of data**, `int` often referring to **32 bits**, and `long` types' size being **a bit flexible**.
* 🧠 "It's important to know which processor the program is for, as the size of variables is usually fixed for small and medium types, but can vary a little for **`long` types**."
* 🔢 When interpreting values, `unsigned` types are always considered as **non-negative numbers**, while negative numbers are represented using methods like **two's complement**.
* 🧠 Using a form that is comfortable and easy to remember, naming a variable in a specific space can be considered as the act of **assigning a name to that space**, and we call that act a **variable**.
* 🔌 Memory addresses are used to specify which value to **retrieve, store, or remove** from a certain location in memory, and understanding them is crucial in MCU-related programming.
* 🔣 In C, logical operations are performed based on variables, and all values other than `0` are considered **true** in logical operations.
* ➗ When performing comparison operations like equal and not equal, the result is assigned to a variable, with `**0**` representing **false** and `**1**` representing **true**.

I am separately organizing methods for [this]. So, when it comes to integer types, if we talk about this, integer variables are meant to store integer values, and floating-point variables are meant to store floating-point values. The reason they store them differently is, as briefly mentioned earlier, because the ways of storing integers and floating-point numbers are different. Now, the integer variables, when you think about what types there are, are basically divided into char type, short type, int type, and long type. In the case of char type, it generally stores one byte of data, which means it allocates one byte of space. When we say we use char type variables, we are talking about allocating one byte of space. And when we talk about type, we usually talk about byte space. Next is the int type.

It might be a bit confusing. In the case of integers, when the computer reads data from memory, there is a basic unit. For example, if it's a 32-bit processor, it brings in data in units of 32 bits. If it's a 16-bit processor, it brings in data in units of 16 bits. And if it's a 64-bit processor, it brings in data in units of 64 bits. Therefore, integers refer to bringing in data in the most basic unit that the computer handles. Generally, in our MCs, there are many cases where 32 bits, which means bytes, are used a lot these days. Recently, with 64-bit processors, if I say I use integers, it could mean 8 bytes because 64 bits are 8 bytes. Normally, we refer to 8 bytes. So, when writing a program, it is important to know which processor it is for.

According to the program, the size of the variables is usually fixed for small and medium types, but for doll and long types, the variables can vary a little, so the size can change. If it becomes like this, it can be difficult to allocate memory, and later, depending on the type and process, there may be issues with the actual variable type. Therefore, it is quite common to express them in a slightly different form. Especially with events, they tend to be more detailed. So, in the case of a variable like 'unsigned', it is often expressed in the form of 'unsigned' in the case of unsigned int 8, int underbar t, and for short, unsigned int 16 underbar, and for int, int 32 underbar. There are many cases where variable types are discussed explicitly. This is how they are explicitly represented.

It's telling us that it will be used in a signed type, and it will use this variable in size, a variable of unsigned type, and the size will be a 32-bit variable. If we call it int 16, it means that it has a 16-bit space of unsigned type to store any value. Yes, the time is 4 minutes and 6 seconds. When we talk about understanding only unsigned, in front of us, we talked about representing an integer with combinations of 0 and 1. Basically, since we only have 0 and 1, with 8 bits, we can express values from 00 to 1111. However, thinking in binary and converting it to decimal, ultimately, this ranges from 0 to 255. Because we express combinations of 0 and 1, in this way, in the form of combinations of 0 and 1.

When we express values, we can only express 0 and positive numbers. With the combination of these, when interpreting this, we interpret everything as 0 and positive numbers only. We call this unsigned, meaning that when interpreting values, we always interpret them as numbers. But when we think about computers, computers are used to replace what humans do. In the case of what humans do, it's not always possible to express only 0 and positive numbers. There are many cases where humans use negative numbers. So, the problem arises of how to represent these negative numbers with the combination of 0 and 1. Various methods have been considered to represent this, and one of the methods defined is called complement. This is not what we will deal with now, but if we think about it from an understanding perspective, the approach is a bit different.

I will interpret this and what's behind is not an absolute value, but interpreted in a slightly different form. So, when we interpret it as 2's complement, in the case of 0, now it becomes 0. Similarly, it becomes 0, and starting from here, from the front, from here, it's 0, 1 like this. Basically, the front is 0, and the rest are all 7s, or 1s, depending on the signed form, it can also be interpreted as 127. When interpreted in the two's complement form, it is also interpreted as 127. Where does it change? It starts to change from the 100 below. In the one's complement form, it is interpreted as 128, and in the signed form, it is interpreted as -128 in the negative form in front of it. And the value below here, now it should be 129. Anyway, up to this point, now in the basic language, with functions, we used to perform some operations, and functions have a type, the name of the function, output form, input form, and define them.

Next, there is a variable, so it gets stored in a specific space in memory. And this time, the types have integer and real types, and unlike other languages, we need to clearly specify the type of number we are using. We talked a bit about the types, such as type, character type, and integer type, each with different sizes. Now it's 51 minutes past the hour, so let's take a 10-minute break. From now on, I will start again. If you have any questions during the break, please chat with me, and we will talk a bit before we start. It's time to continue talking about the type of variables explicitly in C. Then, using this, we can now access the memory address, which is quite important. Later, when we talk about programming related to the MCU, this will be significant. We will discuss this a bit more later.

I think we have some time. Do you understand the concept of bits? When we access memory, we use addresses to specify which value we want to retrieve, store, or remove from a certain location. In the case of memory, data spaces are predetermined, and we access them using numbers. Each number is composed of eight bits. In fact, memory consists of continuous data spaces. When accessing these spaces, we break them down into units of eight bits, assign an address, and access them accordingly. Users interact with memory by using these addresses, but it can be confusing for people to access memory using a series of numbers because it is not intuitive and easy to forget.

Using a form that is comfortable and easy to remember, naming a variable in a specific space can be considered as the act of assigning a name to that space, and we call that act a variable. It seems like you should remember that. Next, I will talk a bit about operators. Among various operators, in the case of arithmetic operations like addition and subtraction, you can explicitly talk about them and understand them. In programming, in addition to arithmetic operations, one of the important things is logical operations. Logical operations, as the name suggests, are about determining whether something is true or false. So, when we talk about logical operations, the most basic thing is whether to interpret it as true or false. Just like we mentioned earlier, with computer systems and data systems, we have data systems.

When we talk about logic with gates, we think about how to express true and false. So, when we think about it simply, the most intuitive way to express it is to take 0 as false and 1 as true with logic gates. Therefore, in tests, true is indicated by 1, and then false is indicated by 0. This is the most basic characteristic. In our language, we basically deal with things based on variables. So, when we talk about variables earlier, what did we mention? Char and int types. Let me talk about just two things. In the case of char, we mentioned it is a unit of 8 bits, which is 1 byte, and we said int is 4 bytes. Char type is like this.

00:00 In production, it can have a value of 1, 1, 1, 1, 1, 1, 1. It can have various values like this. Then, how do we determine whether these various values are true or false? You know, if we just express it as participation in the front, we said that 0 is false and 1 is true for participation. But when storing actual data, you can store it in binary form, and the values that can be included in it are not just 0 and 1, but can go up to 255, from 0 to 1. For example, when interpreting it as participation, in the case of language, only 0 is false, which is clear. This is false, and this is true. But it's not necessarily just 1 that is true, but all values other than 0 are considered true in logical operations. When doing logical operations, all of these are considered true. For example, for a participant...

Right now, 1 is true, and then 12 is true, and then 27, things like this are also true. When these values are contained in the variables of truth and falsehood, and asked to judge true or false based on them, all of these are judged as true. So, when we have values like 0 and 2, if we had any value other than 0, it is considered true. For example, in the case of a char type, there is only one false, and there are five truths. Even in the case of an int type, now, if we need to eliminate 31 falses out of 32 values, one is false, and all other values excluding this one are considered true. So, when we think about judging all values as true except for this one false, you should consider it. However, when performing logical operations, if we perform operations like equal, not equal, and different from now on, we should use the results of these operations. We should have saved the results of these operations somewhere, and we should use that result, just like the code on the right.

It's not just a variable, it's a logic operation that determines if the values inside are the same when performing the logical operation. By performing this comparison operation, the result is assigned to the variable on the right or left. If we assign 1 to the variable on the left when it is false, since only 0 is considered false, we can put in 0. However, if we say it's 3, there is no specific value that can be put in for 3, it could be 2 or various other values that can all be considered true, so you can put in any value. In the end, you have to choose one value and put it in, and the most representative value to put in is 1. If the result of this operation is true, then 1 goes into the result variable, and if it's false, meaning they are not the same, then 0 is assigned. This is how we perform operations, not 0.

When we evaluate all values as true and receive the result of the operation, in the case of saying false for the same situation, we get 0, and if we say true, we get 2. When we look at other relational operators, the relational operator that determines if it is smaller is denoted by <, and if it is larger, it is denoted by >. Next, to express that two values are different, we use the exclamation mark followed by an equal sign. By expressing values in terms of smaller, larger, or equal, we can clearly understand and interpret these operations. It seems like you will be able to intuitively grasp the meanings and concepts, and if you have some experience in programming, you might have used the information that in mathematics we use one equal sign to indicate equality, but in programming, we use two.

The reason is that now, as seen here, in programming, we need an assignment operator to perform an operation and assign the result of the operation on the right to the left. Also, because we use the equal sign as the assignment operator, we cannot express a lot with just one equal sign we use in daily situations. So, to differentiate this assignment operator, we express equal with two equal signs. So, when we look at the code a bit, if we say that int one is 10, this means that this variable one has been used for our operation. When we use this, it reserves space in memory in bytes, and since it's an integer, it reserves space in bytes and reserves that space.

친11 2

long kim

Integer variables are meant to store integer values, while floating-point variables are for floating-point values, stored differently due to the computer's basic unit for reading data.

Char type stores one byte of data, int type's size can vary based on the processor, and long types can have variable sizes, making memory allocation and variable type issues common.

The representation of variable types can be expressed explicitly, especially with detailed events, using forms like 'unsigned int 8' and 'int32_t'.

Understanding Signed and Unsigned Variables in 32-bit Systems

Signed variables can store both positive and negative numbers using the two's complement method in a 32-bit system.

On the other hand, unsigned variables can only store non-negative numbers, using the traditional binary representation from 0 to 255.

In a 32-bit system, the range for signed variables is from -2147483648 to 2147483647, while the range for unsigned variables is from 0 to 4294967295.

Understanding Variable Types and Memory Access in C Programming

Variables in C are stored in specific memory spaces, with different types such as integer and real numbers requiring clear specification.

Memory access in C is crucial, especially in MCU programming, as it involves breaking down continuous data spaces into units of eight bits and assigning addresses to access them.

Naming a variable in a specific memory space is like assigning a name to that space, known as a variable, to make the memory access more intuitive.

In C programming, logical operations are essential for determining the truth of a statement, in addition to arithmetic operations.

The Basic Principles of Logic Gates and Variable Types

Logic gates express true and false values, typically represented as 1 for true and 0 for false.

In the case of variables like char and int, the storage of data in binary form allows for a range of values, where in logical operations, all non-zero values are considered true.

This means that in char type, there is only one false and multiple truths, and in int type, all values except 0 are considered true.

The results of logical operations like equal, not equal, and different are used and saved for further use in the code.

The Logic of Comparison Operations in Programming

Comparison operations determine the equality of values and assign the result to a variable.

The value 1 is typically assigned to the variable on the left when the comparison is false, and the most representative value to put in is 1 when the result is true.

In programming, the double equal sign is used to indicate equality, different from its use in mathematics, to differentiate it from the assignment operator.

This allows for the clear expression of operations and the assignment of results to variables in programming.