C Memory Allocation

Source: Internet
Author: User

C Memory Allocation

1. program code area: stores the binary code of the function body.

2. Global Data zone: the global data zone is divided into three areas.

Global variables and static variables are stored in one partition. The initialized global variables and static variables are in one area. uninitialized global variables and uninitialized static variables are in another adjacent area. Constant data is stored in another region. The data is released by the system after the program ends. The BSS segment is usually a memory area used to store uninitialized global variables in the program. BSS is short for Block Started by Symbol.

3. STACK: the compiler automatically allocates and releases the stack, stores function parameter values, and local variable values. The operation method is similar to the stack in the data structure.

4. Heap zone: Generally, it is assigned and released by the programmer. If the programmer does not release the stack, it may be recycled by the OS at the end of the program. Note that it is different from the heap in the data structure. The allocation method is similar to the linked list.

5. Command Line Parameter area: stores the value of command line parameters and environment variables.

For whether local string constants are stored in the global constant zone or stack zone, different compilers have different implementations. You can check it in assembly language. However, in the vc Environment, Local constants are stored in the stack like local variables, and global constants and character constants are stored in the text constant area. TC is in the constant area.

Example:

Int a = 0; // static storage area (initialization Area)

Char * p1; // static storage area (uninitialized Area)

Void example ()

{

Int B; // Stack

Char s [] = "abc"; // Stack

Char * p2; // Stack

Static int c = 0; // static storage area (initialization Area)

// The allocated 10-byte and 20-byte areas are on the stack.

P1 = (char *) malloc (10 );

P2 = (char *) malloc (20 );

}

 

In the embedded system, there are two types of memory: ROM and RAM. The program is solidified into ROM, And the variables and stacks are located in RAM. constants defined by const are also put into ROM.

Note:UseDefining constants in const can save space and avoid unnecessary memory allocation..

# Define PI 3.14159 // constant macro

Const double g_pi = 3.14159; // g_pi is not put into ROM at this time

......

Double a = g_pi; // at this time, the memory is allocated to g_pi and will not be allocated later!

Double B = PI; // macro replacement during compilation and Memory Allocation

Double c = g_pi ;//No memory allocation

Double d = PI; // macro replacement, memory allocation again!

 

In linux: You can compile and generate an assembly file using the-c parameter. For example:
Gcc-c *. c
Gcc *. o-Map test.txt-o test. elf
Compile the test.txt file with the compiler. You will see the information about the bss segment, data segment, and text segment, but there is no information about the stack segment. Run the objdump command to view the information. o information after disassembly of the file, or use gcc-S *. c. view each. S file.

 

Article 2. Memory planning types

1) Conventional Memory occupies the top position in the Memory allocation table, from 0 kb to 640KB (address limit 00h ~ 109 FFFFH), a total of KB of capacity. Because it is at the beginning of the Memory and in the DOS manageable Memory area, we also call it Low Dos Memory (Low DOS Memory) or Base Memory ), the programs that use this space include BIOS, DOS Operating System, drivers of peripheral devices, interrupt vector table, some resident programs, idle available memory space, and general application software. space execution.

2) High Memory (UM) is the abbreviation of Upper Memory. It is a layer of Memory (640KB ~ 1024KB ). 3) High-end Memory Area (HMA) is short for High Memory Area. It is a 64KB memory ranging from kb to KB. It is a high-end memory zone and its address is H ~ 10 ffefh or above, the CPU address in real address mode is addressed in Segment: OFFSET (Segment address: OFFSET) mode, and the maximum logical memory space for addressing is (FFFF: FFFF ), 10 FFEFH.
(4) EMB is an Extended Memory block(extended Memory block scale-in. The Extended Memory (epm1_compliance with ems1_(for example, emm386.exe), and the Extended Memory (EXM) used later must follow XMS specifications (for example, Himem. sys ). Extended memory refers to memory space larger than 1 MB. Its address is continuously expanded from H. The extended memory depends on the addressing capability of the CPU.

 

1. Memory Allocation Method

There are three memory allocation methods:

(1) distribution from the static storage area. The program has been allocated when it is compiled, and the program exists throughout the entire runtime. For example, global variables and static variables.

(2) create a stack. When a function is executed, the storage units of local variables in the function can be created on the stack. When the function is executed, these storage units are automatically released. Stack memory allocation computation is built into the processor's instruction set, which is highly efficient, but the memory capacity allocated is limited.

(3) allocate from the stack, also known as dynamic memory allocation. When the program runs, it uses malloc or new to apply for any amount of memory. The programmer is responsible for releasing the memory with free or delete. The lifetime of the dynamic memory is determined by us. It is very flexible to use, but the problem is also the most.

2. Common memory errors and Countermeasures

Memory Errors are very troublesome. The compiler cannot automatically detect these errors, which can be captured only when the program is running. Most of these errors do not have obvious symptoms, but they are often invisible and increase the difficulty of error correction. Sometimes the user finds you angrily, but the program has not encountered any problems. When you leave, the error occurs again. Common memory errors and their countermeasures are as follows:

* If the memory allocation is unsuccessful, it is used.

New programmers often make this mistake because they do not realize that memory allocation will fail. A common solution is to check whether the pointer is NULL before using the memory. If the pointer p is a function parameter, use assert (p! = NULL. If you use malloc or new to apply for memory, you should use if (p = NULL) or if (p! = NULL.

* Although the memory allocation is successful, it is referenced before initialization.

There are two main causes for this mistake:

First, there is no idea of initialization;

Second, the default memory initial values are all zero, leading to incorrect reference initial values (such as arrays ). There is no uniform standard for the default initial values of the memory. Although sometimes it is zero, we prefer to trust it without any trust. Therefore, no matter which method is used to create an array, do not forget to assign the initial value. Even the zero value cannot be omitted, so do not bother.

* The memory allocation is successful and initialized, but the operation is beyond the memory boundary.

For example, when an array is used, the subscript "more than 1" or "less than 1" is often performed. Especially in for loop statements, the number of loops is easy to make a mistake, resulting in array operations out of bounds.

* Forgot to release the memory, causing memory leakage.

A function containing such errors loses a piece of memory every time it is called. At the beginning, the system had sufficient memory and you could not see the error. Once a program suddenly died, the system prompts: memory is exhausted.

Dynamic Memory application and release must be paired. The usage of malloc and free in the program must be the same, otherwise there must be an error (the same applies to new/delete ).

* The memory is released but it is used again.
 
There are three scenarios:

(1) The object calling relationship in the program is too complex, so it is difficult to figure out whether an object has released the memory. At this time, we should re-design the data structure to fundamentally solve the chaos of Object Management.

(2) The return Statement of the function is incorrect. Be sure not to return the "Pointer" or "Reference" pointing to "stack memory" because the function body is automatically destroyed when it ends.

(3) After the memory is released using free or delete, the pointer is not set to NULL. As a result, a "wild pointer" is generated ".

[Rule 1] after applying for memory with malloc or new, check whether the pointer value is NULL immediately. Prevents the use of memory with NULL pointer values.

Rule 2: Do not forget to assign initial values to arrays and dynamic memory. Avoid using uninitialized memory as the right value.

Rule 3: avoid overrunning the subscript of an array or pointer. Be careful when "more than 1" or "less than 1" is performed.

[Rule 4] dynamic memory application and release must be paired to prevent memory leakage.

[Rule 5] after the memory is released with free or delete, the pointer is immediately set to NULL to avoid "wild pointer ".

3. Comparison of pointers and Arrays

In C/C Programs, pointers and arrays can be replaced in many places. This creates an illusion that the two are equivalent.

An array is either created in a static storage area (such as a global array) or on a stack. The array name corresponds to (rather than pointing to) a piece of memory, and its address and capacity remain unchanged during the lifetime, only the content of the array can be changed.

A pointer can point to any type of memory block at any time, and its feature is "variable". Therefore, we often use pointers to operate dynamic memory. Pointers are far more flexible than arrays, but they are more dangerous.

The following uses a string as an example to compare the features of pointers and arrays.

3.1 modify content

In the example 3-1, the size of character array a is 6 characters, and its content is hello. The content of a can be changed, for example, a [0] = 'x '. The pointer p points to the constant string "world" (in the static storage area with the content of world). The content of the constant string cannot be modified. In terms of syntax, the compiler does not think that the statement p [0] = 'X' is inappropriate, but this statement attempts to modify the content of the constant string and causes a running error.

  1. Char a [] = "hello ";
  2. A [0] = 'X ';
  3. Cout <a <endl;
  4. Char * p = "world"; // note that p points to a constant string
  5. P [0] = 'X'; // the compiler cannot find this error.
  6. Cout <p <endl;

Copy code

Example 3.1 modify the array and pointer content

3.2 content replication and Comparison

The array name cannot be directly copied or compared. In Example 7-3-2, if you want to copy the content of array a to array B, you cannot use statement B = a. Otherwise, a compilation error is generated. Use the standard library function strcpy for replication. Similarly, if the content of B and a is the same, it cannot be determined by if (B = a). The standard library function strcmp should be used for comparison.

Statement p = a does not copy the content of a, but assigns the address of a to p. To copy the content of a, you can first use the library function malloc to apply for a memory with a capacity of strlen (a) 1 character, and then use strcpy to copy the string. Similarly, the statement if (p = a) compares not the content but the address, and should be compared using the database function strcmp.

  1. // Array...
  2. Char a [] = "hello ";
  3. Char B [10];
  4. Strcpy (B, a); // B = a cannot be used;
  5. If (strcmp (B, a) = 0) // if (B = a) cannot be used)
  6. ...
  7. // Pointer...
  8. Int len = strlen ();
  9. Char * p = (char *) malloc (sizeof (char) * (len 1 ));
  10. Strcpy (p, a); // do not use p =;
  11. If (strcmp (p, a) = 0) // do not use if (p =)
  12. ...

Copy code

Example 3.2 copying and comparing the array and pointer content

3.3 computing memory capacity

The sizeof operator can be used to calculate the array capacity (number of bytes ). In Example 7-3-3 (a), the value of sizeof (a) is 12 (don't forget ''). The pointer p points to a, but the value of sizeof (p) is 4. This is because sizeof (p) obtains the number of bytes of a pointer variable, which is equivalent to sizeof (char *) rather than the memory capacity referred to by p. C/C language cannot know the memory capacity referred to by the pointer unless you remember it when applying for memory.

Note: When an array is passed as a function parameter, the array will automatically degrade to a pointer of the same type. In Example 7-3-3 (B), sizeof (a) is always equal to sizeof (char *) regardless of the size of array *).

  1. Char a [] = "hello world ";
  2. Char * p =;
  3. Cout <sizeof (a) <endl; // 12 bytes
  4. Cout <sizeof (p) <endl; // 4 bytes

Copy code

Example 3.3 (a) calculates the memory capacity of arrays and pointers

  1. Void Func (char a [1, 100])
  2. {
  3. Cout <sizeof (a) <endl; // 4 bytes instead of 100 bytes
  4. }

Copy code

Example 3.3 (B) the array degrades to a pointer

4. How does the pointer Parameter Pass the memory?

If the function parameter is a pointer, do not expect this pointer to apply for dynamic memory. In Example 7-4-1, the GetMemory (str, 200) Statement of the Test function does not enable str to obtain the expected memory. str is still NULL. Why?

  1. Void GetMemory (char * p, int num)
  2. {
  3. P = (char *) malloc (sizeof (char) * num );
  4. }
  5. Void Test (void)
  6. {
  7. Char * str = NULL;
  8. GetMemory (str, 100); // str is still NULL
  9. Strcpy (str, "hello"); // running error
  10. }

Copy code

Example 4.1 try to apply for dynamic memory with pointer Parameters

The fault lies in the GetMemory function. The compiler always needs to make a temporary copy for each parameter of the function. The copy of the pointer parameter p is _ p, and the compiler makes _ p = p. If the program in the function body modifies the content of _ p, the content of parameter p is modified accordingly. This is why pointers can be used as output parameters. In this example, _ p applied for a new memory, but changed the memory address indicated by _ p, but p was not changed at all. Therefore, the GetMemory function cannot output anything. In fact, each execution of GetMemory will leak a piece of memory, because the memory is not released with free.

If you have to use the pointer parameter to request memory, you should use "pointer to Pointer" instead. See example 4.2.

  1. Void GetMemory2 (char ** p, int num)
  2. {
  3. * P = (char *) malloc (sizeof (char) * num );
  4. }
  5. Void Test2 (void)
  6. {
  7. Char * str = NULL;
  8. GetMemory2 (& str, 100); // note that the parameter is & str, not str
  9. Strcpy (str, "hello ");
  10. Cout <str <endl;
  11. Free (str );
  12. }

Copy code

Example 4.2 apply for dynamic memory with a pointer pointing to the pointer

Because the concept of "pointer to Pointer" is not easy to understand, we can use function return values to transmit dynamic memory. This method is simpler. See example 4.3.

  1. Char * GetMemory3 (int num)
  2. {
  3. Char * p = (char *) malloc (sizeof (char) * num );
  4. Return p;
  5. }
  6. Void Test3 (void)
  7. {
  8. Char * str = NULL;
  9. Str = GetMemory3 (100 );
  10. Strcpy (str, "hello ");
  11. Cout <str <endl;
  12. Free (str );
  13. }

Copy code

Example 4.3 use function return values to transmit dynamic memory

Although it is easy to use the function return value to pass dynamic memory, some people often use the return statement wrong. It is emphasized that the return statement should not be used to return the pointer pointing to the "stack memory" because the function exists in it automatically disappears at the end, as shown in example 4.4.

  1. Char * GetString (void)
  2. {
  3. Char p [] = "hello world ";
  4. Return p; // the compiler will give a warning
  5. }
  6. Void Test4 (void)
  7. {
  8. Char * str = NULL;
  9. Str = GetString (); // str content is junk
  10. Cout <str <endl;
  11. }

Copy code

Example 4.4 return Statement returns a pointer to "stack memory"

Use the debugger to track Test4 step by step. After executing the str = GetString statement, str is no longer a NULL pointer, but the str content is not "hello world" but garbage.
What if I rewrite example 4.4 to example 4.5?

  1. Char * GetString2 (void)
  2. {
  3. Char * p = "hello world ";
  4. Return p;
  5. }
  6. Void Test5 (void)
  7. {
  8. Char * str = NULL;
  9. Str = GetString2 ();
  10. Cout <str <endl;
  11. }

Copy code

Example 4.5 return Statement returns a constant string

Although the function Test5 runs without errors, the design concept of the function GetString2 is incorrect. Because "hello world" in GetString2 is a constant string located in the static storage zone, it remains unchanged during the lifetime of the program. No matter when GetString2 is called, it returns the same read-only memory block.

5. Eliminate "wild pointer"

The "wild pointer" is not a NULL pointer, but a pointer to the "junk" memory. Generally, NULL pointers are not incorrectly used, because if statements are easy to judge. However, the "wild Pointer" is very dangerous, and the if statement does not work for it. There are two main causes of "wild pointer:

(1) pointer variables are not initialized. When a pointer variable is created, it does not automatically become a NULL pointer. Its default value is random, which means it is random. Therefore, the pointer variable should be initialized at the same time when it is created, either set the pointer to NULL or set it to direct to the legal memory. For example

  1. Char * p = NULL;
  2. Char * str = (char *) malloc (100 );

Copy code

(2) After the pointer p is free or deleted, It is not set to NULL, which makes people mistakenly think p is a valid pointer.

(3) pointer operations go beyond the scope of variables. This situation is hard to prevent. The example program is as follows:

  1. Class
  2. {
  3. Public:
  4. Void Func (void) {cout <"Func of class A" <endl ;}
  5. };
  6. Void Test (void)
  7. {
  8. A * p;
  9. {
  10. A;
  11. P = & a; // note the life cycle of
  12. }
  13. P-> Func (); // p is a "wild pointer"
  14. }

Copy code

When the function Test executes the statement p-> Func (), object a has disappeared, and p points to a, so p becomes a "wild pointer ". But the strange thing is that I did not encounter any errors when running this program, which may be related to the compiler.

6. Why new/delete?

Malloc and free are standard library functions in C/C, and new/delete are operators in C. They can be used to apply for dynamic memory and release memory.

For non-Internal data objects, maloc/free alone cannot meet the requirements of dynamic objects. The constructor must be automatically executed when the object is created, and the Destructor must be automatically executed before the object is extinct. Since malloc/free is a library function rather than an operator and is not controlled by the compiler, it is impossible to impose the tasks of executing constructor and destructor on malloc/free.

Therefore, the C language requires a new operator that can complete dynamic memory allocation and initialization, and a delete operator that can clean up and release memory. Note that new/delete is not a database function. First, let's take a look at how malloc/free and new/delete implement dynamic memory management of objects. See example 6.

  1. Class Obj
  2. {
  3. Public:
  4. Obj (void) {cout <"Initialization" <endl ;}
  5. ~ Obj (void) {cout <"Destroy" <endl ;}
  6. Void Initialize (void) {cout <"Initialization" <endl ;}
  7. Void Destroy (void) {cout <"Destroy" <endl ;}
  8. };
  9. Void UseMallocFree (void)
  10. {
  11. Obj * a = (obj *) malloc (sizeof (obj); // apply for dynamic memory
  12. A-> Initialize (); // Initialization
  13. //...
  14. A-> Destroy (); // clear the job
  15. Free (a); // releases the memory.
  16. }
  17. Void UseNewDelete (void)
  18. {
  19. Obj * a = new Obj; // apply for dynamic memory and initialize
  20. //...
  21. Delete a; // clear and release the memory
  22. }

Copy code

Example 6 How to Use malloc/free and new/delete to manage the dynamic memory of Objects

The class Obj function Initialize simulates the constructor function, and the function Destroy simulates the destructor function. In UseMallocFree, because malloc/free cannot execute constructor and destructor, you must call the member functions Initialize and Destroy to complete initialization and clearing. The UseNewDelete function is much simpler.

Therefore, we should not attempt to use malloc/free to manage the memory of dynamic objects. We should use new/delete. Because the internal data type "object" does not have a process of construction and analysis, malloc/free and new/delete are equivalent to them.

Since the new/delete function completely covers malloc/free, why does C not remove malloc/free? This is because C programs often call C functions, and C Programs can only use malloc/free to manage dynamic memory.

If you use free to release the "new Dynamic Object", this object may cause program errors because it cannot execute the destructor. If you use delete to release the "dynamic memory applied by malloc", theoretically, the program will not go wrong, but the program is poorly readable. Therefore, new/delete must be paired, and the same applies to malloc/free.

7. What should I do if the memory is exhausted?

If a large enough memory block cannot be found when applying for dynamic memory, malloc and new will return a NULL pointer, declaring that the memory application failed. There are usually three ways to handle the "memory depletion" problem.

(1) judge whether the pointer is NULL. If yes, use the return statement to terminate the function immediately. For example:

  1. Void Func (void)
  2. {
  3. A * a = new;
  4. If (a = NULL)
  5. {
  6. Return;
  7. }
  8. ...
  9. }

Copy code

(2) judge whether the pointer is NULL. If yes, use exit (1) to terminate the entire program. For example:

  1. Void Func (void)
  2. {
  3. A * a = new;
  4. If (a = NULL)
  5. {
  6. Cout <"Memory Exhausted" <endl;
  7. Exit (1 );
  8. }
  9. ...
  10. }

Copy code

(3) set exception handling functions for new and malloc. For example, in Visual C, you can use the _ set_new_hander function to set your own exception handling function for new, or enable malloc to use the same exception handling function as new. For more information, see the C user manual.

The above (1) (2) method is the most common. If a function needs to apply for dynamic memory in multiple places, the method (1) is insufficient (it is troublesome to release the memory) and should be handled in the way (2.

A lot of people cannot bear to use exit (1). They asked, "Can the operating system solve the problem by itself without writing error handling programs ?"

No. In case of a "memory depletion" event, generally applications are no longer saved. If you do not use exit (1) to kill the program, it may kill the operating system. The truth is: if you do not kill a gangster, the gangster will commit more crimes before he dies.

There is a very important phenomenon to tell you. For 32-bit applications, no matter how malloc and new are used, it is almost impossible to cause "memory depletion ". I wrote a test program in Visual C under Windows 98. See example 7. This program will run endlessly and will not be terminated at all. Because the 32-bit operating system supports "virtual storage" and the memory is used up, the hard disk space is automatically replaced. I only heard the sound of the hard drive. Window 98 was so tired that it didn't respond to the keyboard or mouse.

I can conclude that for 32-bit or more applications, the "memory used up" error handler is useless. Now, Unix and Windows programmers are happy with this: the error handler does not work, and I will not write it, saving a lot of trouble.

I don't want to mislead readers. I must emphasize that without error handling, the quality of the program will be poor, and never be compromised.

  1. Void main (void)
  2. {
  3. Float * p = NULL;
  4. While (TRUE)
  5. {
  6. P = new float [1000000];
  7. Cout <"eat memory" <endl;
  8. If (p = NULL)
  9. Exit (1 );
  10. }
  11. }

Copy code

Example 7 try to exhaust the operating system memory

8. Usage of malloc/free

The following is a prototype of the malloc function:

  1. Void * malloc (size_t size );

Copy code

Use malloc to apply for an integer-type memory with a length. The program is as follows:

  1. Int * p = (int *) malloc (sizeof (int) * length );

Copy code

We should focus on two elements: "type conversion" and "sizeof ".

* The type returned by malloc is void *. Therefore, you must explicitly convert the type when calling malloc and convert void * to the required pointer type.

* The malloc function does not recognize the type of memory to be applied for. It only cares about the total number of bytes in the memory. We usually cannot remember the exact number of bytes for int, float, and other data types. For example, the int variable is 2 bytes in a 16-bit system and 4 bytes in a 32-bit system, and the float variable is 4 bytes in a 16-bit system, it is also 4 bytes in 32 bits. It is best to use the following program for a test:

  1. Cout <sizeof (char) <endl;
  2. Cout <sizeof (int) <endl;
  3. Cout <sizeof (unsigned int) <endl;
  4. Cout <sizeof (long) <endl;
  5. Cout <sizeof (unsigned long) <endl;
  6. Cout <sizeof (float) <endl;
  7. Cout <sizeof (double) <endl;
  8. Cout <sizeof (void *) <endl;

Copy code

Using the sizeof operator in malloc's "()" is a good style, but be careful when we sometimes get dizzy and write p = malloc (sizeof (p )) such a program.

* The prototype of function free is as follows:

  1. Void free (void * memblock );

Copy code

Why isn't the free function as complicated as the malloc function? This is because the pointer p type and the memory capacity it refers to are known in advance, and the statement free (p) can correctly release the memory. If p is a NULL pointer, no matter how many times the free p operation will fail. If p is not a NULL pointer, the free operation on p will cause a program running error.

9. Usage of new/delete

The new operator is much easier to use than the malloc function, for example:

  1. Int * p1 = (int *) malloc (sizeof (int) * length );
  2. Int * p2 = new int [length];

Copy code

This is because new has built-in sizeof, type conversion, and type security check functions. For non-Internal data objects, new completes initialization while creating dynamic objects. If an object has multiple constructors, the new statement can also have multiple forms. For example

  1. Class Obj
  2. {
  3. Public:
  4. Obj (void); // a constructor without Parameters
  5. Obj (int x); // constructor with a parameter
  6. ...
  7. }
  8. Void Test (void)
  9. {
  10. Obj * a = new Obj;
  11. Obj * B = new Obj (1); // The initial value is 1.
  12. ...
  13. Delete;
  14. Delete B;
  15. }

Copy code

If you use new to create an object array, you can only use the non-parameter constructor of the object. For example

  1. Obj * objects = new Obj [100]; // create 100 Dynamic objects

Copy code

Cannot be written

  1. Obj * objects = new Obj [100] (1); // create 100 dynamic objects and assign initial value 1

Copy code

When releasing an object Array Using delete, do not lose the symbol '[]'. For example

  1. Delete [] objects; // correct usage
  2. Delete objects; // incorrect usage

Copy code

The latter is equivalent to delete objects [0], and 99 Other objects are missing.

10. Some experiences

I know a lot of C/C programmers with good technology. Few people can pat their chests and say they are familiar with pointer and memory management (including myself ). When I first learned the C language, I was so stupid that I didn't use a pointer when I was developing the first application software (about 10 thousand lines of C code). I used arrays to replace pointers. It was not a solution to avoid pointers. Later I changed the software and reduced the amount of code to half of the original one.

My lessons are:

(1) The more you are afraid of pointers, the more you need to use pointers. If pointer is not used correctly, it is definitely not a qualified programmer.

(2) You must develop the habit of gradually tracing programs using the debugger. Only in this way can you discover the essence of the problem.

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.