Shulou(Shulou.com)06/01 Report--

This article mainly explains "what is the difference between C language and other programming languages". The content of the explanation in this article is simple and clear, and it is easy to learn and understand. let's study and learn "what are the differences between C language and other programming languages"?

Static memory

Memory management-storage model

The storage model determines the memory allocation and access characteristics of a variable, which is mainly determined by three dimensions in C language: 1, storage period 2, scope 3, link

1. Storage period

Storage period: the retention time of a variable in memory (life cycle)

The storage period is divided into two cases, the key is to see whether the variables will be automatically recycled by the system during the execution of the program.

1) Static in static storage period

Once allocated during program execution, it will not be automatically recycled.

In general, any variable that is not defined within a function-level block of code.

Variables decorated with the static keyword, whether they are within the code block or not.

2) automatic storage period Automatic

All variables except static storage are stored automatically, or as long as they are non-static variables defined in the code block, the system will automatically unallocate and release memory from the belly button.

2. Scope

Scope: the visibility (access or reference) of a variable in its own file that defines the variable

In the C language, there are three scopes:

1) Code block scope

Variables defined in the code block have the scope of the code. From where the variable is defined, to the end of the block of code, the variable is visible

2) function prototype scope

The variables that appear in the function prototype all have the scope of the function prototype, which extends from the definition of the variable to the end of the prototype declaration.

3) File scope

A variable defined outside all functions has a file scope, and a variable with a file scope is visible from its definition to the end of the file containing the definition

3. Link

Link: the visibility (access or reference) of a variable in all the files that make up the program

There are three different kinds of links in C:

1) external links

If a variable can be accessed anywhere in all the files that make up a program, it is said to support external links

2) Internal links

If a variable can only be accessed anywhere in the file that defines itself, the variable is said to support internal links.

3) empty link

If a variable is only private to the current block of code that defines itself and cannot be accessed by other parts of the program, the variable supports empty links.

Let's look at a code example:

[cpp] view plain copy

1. # include

two。

3. Int a = 0 position / global initialization zone

4. Char * p1; / / Global uninitialized zone

5.

6. Int main ()

7. {

8. Int b; / / b is in the stack area

9. Char s [] = "abc"; / / stack

10. Char * p2; / / p2 is in the stack area

11.

12. Char * p3 = "123456"; / / 123456\ 0 in the constant area, p3 on the stack.

13. Static int c = 0; / / Global (static) initialization zone

14.

15. P1 = (char *) malloc (10)

16. P2 = (char *) malloc (20); / / the area allocated with 10 and 20 bytes is in the heap area.

17.

18. Strcpy (p1, "123456"); / / 123456\ 0 is placed in the constant area, and the compiler may optimize it in the same place as the "123456" pointed to by p3.

19.}

Second, dynamic memory

When the program runs to the need for a dynamically allocated variable, it must request the system to obtain the required storage space for a block in the heap to store the variable. When the variable is not in use, that is, at the end of its life, display the storage space occupied by releasing it, so that the system can reallocate the space and reuse wired resources. The functions for dynamic memory allocation and release are described below.

1.1 malloc function

Malloc function prototype:

[cpp] view plain copy

1. # include

two。

Void * malloc (size_t size)

Size is the number of bytes of memory that need to be allocated dynamically. If the application is successful, the function returns the starting address of the applied memory. If the application fails, NULL is returned. Let's look at the following example:

[cpp] view plain copy

1. Int * get_memory (int n)

2. {

3. Int * p

4. P = (int *) malloc (sizeof (int))

5. If (p = = NULL)

6. {

7. Printf ("malloc error\ n")

8. Return p

9.}

10.

11. Memset (ppjin0ref nymsizeof (int))

12.}

When using this function, there are the following points to note:

1) only care about the size of the applied memory

2) A continuous piece of memory is requested. Remember to write the wrong judgment.

3) display initialization. That is, we do not know what is in this piece of memory, so we need to zero it.

1.2 free function

For the amount of memory allocated on the heap, you need to use the free function to display the release. The function prototype is as follows:

[cpp] view plain copy

# include

Void free (void * ptr)

When using free (), there are also the following points to note:

1) the starting address of the memory must be provided

When calling this function, you must provide the starting address of the memory, but you cannot provide a partial address, and it is not allowed to free part of the memory.

2) paired use of malloc and free

The compiler is not responsible for the release of dynamic memory and requires programmers to display the release. Therefore, malloc is paired with free to avoid memory leaks.

[cpp] view plain copy

Free (p)

P = NULL

P = NULL is necessary because although this piece of memory is freed, p still points to it to avoid misoperation of p next time.

3) repeated release is not allowed

Because after this piece of memory is released, it may have been allocated separately, and this area is occupied by someone else. If it is released again, it will cause data loss.

2. We often compare heaps with stacks:

2.1 Application method

Stack: automatically assigned by the system. For example, declare a local variable int b in the function; the system automatically opens up space for b in the stack

Heap: need programmer to apply and specify the size, malloc function in c, such as p1 = (char *) malloc (10)

2.2 response of the system after application

Stack: as long as the remaining space of the stack is larger than the applied space, the system will provide memory for the program, otherwise an exception will be reported that the stack will overflow.

Heap: first of all, you should know that the operating system has a linked list of free memory addresses. when the system receives an application from the program, it traverses the list to find the first node whose space is larger than the applied space. then remove the node from the list of idle nodes and allocate the space of the node to the program, in addition, for most systems The size of this allocation is recorded at the first address in this memory space, so that the delete statement in the code can release the memory space correctly. In addition, since the size of the found heap node is not necessarily equal to the size of the application, the system will automatically put the excess part back into the free linked list.

2.3 limit on the size of the application

Stack: a stack is a data structure that extends to a low address and is a continuous area of memory. This means that the address at the top of the stack and the maximum capacity of the stack are predetermined by the system, and the size of the stack is 2m (some say 1m, which is a constant determined at compile time). If the applied space exceeds the remaining space of the stack, overflow will be prompted. Therefore, there is less space that can be obtained from the stack.

Heap: a heap is a data structure that extends to a high address and is a discontiguous area of memory. This is because the system uses linked lists to store free memory addresses, which are naturally discontiguous, and the traversal direction of the linked list is from low address to high address. The size of the heap is limited by effective virtual memory in the computer system. Thus it can be seen that the space obtained by the heap is more flexible and larger.

2.4 comparison of application efficiency:

The stack is automatically allocated by the system, and the speed is fast. But programmers can't control it.

Heap is memory allocated by new, which is generally slow and prone to memory fragmentation, but it is the most convenient to use.

2.5 Storage in heaps and stacks

Stack: in a function call, the first one to enter the stack is the address of the next instruction in the main function (the next executable statement in the function call statement), followed by the parameters of the function, which in most C compilers enter the stack from right to left, followed by local variables in the function. Note that static variables are not on the stack. When this function call ends, the local variable goes off the stack first, then the parameters, and finally the pointer at the top of the stack points to the original address, that is, the next instruction in the main function, from which the program continues to run.

Heap: the size of the heap is usually stored in a byte at the head of the heap. The details in the heap are arranged by the programmer.

2.6 comparison of access efficiency

Char S1 [] = "aaaaaaaaaaaaaaa"

Char * S2 = "bbbbbbbbbbbbbbbbb"

Aaaaaaaaaaa is assigned at run time

And bbbbbbbbbbb is determined at compile time.

However, in later access, the array on the stack is faster than the string (such as the heap) pointed to by the pointer.

For example:

[cpp] view plain copy

1. # include

2. Void main ()

3. {

4. Char a = 1

5. Char c [] = "1234567890"

6. Char * p = "1234567890"

7. A = c [1]

8. A = p [1]

9. Return

10.}

Corresponding assembly code

[cpp] view plain copy

1. 0: a = c [1]

2. 00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]

3. 0040106A 88 4D FC mov byte ptr [ebp-4], cl

4. 11: a = p [1]

5. 0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]

6. 00401070 8A 42 01 mov al,byte ptr [edx+1]

7. 00401073 88 45 FC mov byte ptr [ebp-4], al

Thank you for your reading, the above is the content of "what is the difference between C language and other programming languages". After the study of this article, I believe you have a deeper understanding of the difference between C language and other programming languages. the specific use also needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.