C/C ++ interview questions

1. Differences between linked lists and Arrays

A From the Logic Structure

A-1. The array must have a fixed length (number of elements) defined in advance, cannot adapt to the dynamic increase or decrease of data. When the data increases, the number of elements defined previously may exceed the limit. When the data decreases, the memory is wasted.

A-2. linked list dynamic storage allocation, can adapt to the dynamic increase or decrease of data, and can easily insert, delete data items. (When inserting or deleting data items in an array, you must move other data items)

B. From the memory storage perspective

B-1. (Static) array allocates space from the stack, convenient and fast for programmers, but less freedom

B-2. linked list from the heap to allocate space, the degree of freedom but the application management is more troublesome.

2. Differences Between Stack and stack

I. prerequisites-program memory allocation

The memory occupied by a C/C ++ compiled program is divided into the following parts:

1. STACK: the stack zone is automatically allocated and released by the compiler (compiler), and stores the function parameter values and local variable values. The operation method is similar to the stack in the data structure.

2. Heap-generally assigned and released by the programmer. If the programmer does not release the heap, 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.

3. Global (static)-the storage of global variables and static variables is put together, and the initialized global variables and static variables are in one area, uninitialized global variables and uninitialized static variables are in another adjacent area. -The system is released after the program ends.

4. Text Constant Area-constant strings are placed here. The program is released by the System

5. program code area-stores the binary code of the function body.

Ii. Example Program

This is written by a senior. It is very detailed.

// Main. cpp

Int A = 0; global initialization Zone

Char * P1; uninitialized globally

Main ()

{

Int B; stack

Char s [] = "ABC"; stack

Char * P2; stack

Char * P3 = "123456"; 123456/0 is in the constant zone, and P3 is on the stack.

Static int C = 0; Global (static) initialization Zone

P1 = (char *) malloc (10 );

P2 = (char *) malloc (20); the allocated 10-byte and 20-byte areas are in the heap area.

Strcpy (P1, "123456"); 123456/0 is placed in the constant area, and the compiler may optimize it to the "123456" that P3 points.

}

Ii. Theoretical knowledge of heap and stack

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:

The programmer needs to apply and specify the size,

In C, the malloc function is like p1 = (char *) malloc (10 );

Use the new operator in C ++, such as P2 = (char *) malloc (10 );

But note that P1 and P2 are in the stack.

2.2 system response after application

STACK: as long as the remaining space of the stack exceeds the applied space, the system will provide the program with memory. Otherwise, an exception will be reported, prompting stack overflow.

Heap: First, you should know that the operating system has a linked list that records idle memory addresses. When the system receives a program application, it will traverse the linked list, find the heap node with the first space greater than the requested space, delete the node from the idle node linked list, and allocate the space of the node to the program. In addition, for most systems, the size of the allocation will be recorded at the first address in the memory space, so that the delete statement in the code can correctly release the memory space. In addition, because the size of the heap node is not necessarily equal to the applied size, the system automatically places the excess part in the idle linked list.

2.3 Application size limit

STACK: in windows, a stack is a data structure extended to a low address and a continuous memory area. This statement indicates that the stack top address and the maximum stack capacity are pre-defined by the system. In Windows, the stack size is 2 MB (OR 1 MB, in short, it is a constant determined during compilation. If the requested space exceeds the remaining space of the stack, overflow will be prompted. Therefore, the space available from the stack is small.

Heap: the heap is a data structure extended to the high address and a non-sequential memory area. This is because the system uses the linked list to store the idle memory address, which is naturally discontinuous, And the traversal direction of the linked list is from the low address to the high address. The heap size is limited by the valid virtual memory in the computer system. It can be seen that the space obtained by the heap is flexible and large.

2.4 comparison of application efficiency:

The stack is automatically allocated by the system, which is faster. But programmers cannot control it.

The heap is the memory allocated by new, which is generally slow and prone to memory fragments. However, it is most convenient to use.

In addition, in windows, the best way is to use virtualalloc to allocate memory. Instead of heap or stack, it is to reserve a fast memory in the address space of the process, although it is the most inconvenient to use. However, it is fast and flexible.

Storage content in 2.5 heap and stack

STACK: when calling a function, (1) the first entry to the stack is the address of the next instruction in the main function (the next executable statement in the function call statement). (2) then there are various parameters of the function. In most C compilers, the parameters are from right to left in the stack, (3) and then local variables in the function. Note: static variables are not included in the stack.

After this function call is completed, (1) the local variables first go out of the stack, (2) then the parameters, (3) the top pointer of the last stack points to the address of the initial storage, that is, the next instruction in the main function, where the program continues to run.

Heap: Generally, the heap size is stored in one byte in the heap header. The specific content in the heap is arranged by the programmer.

2.6 comparison of access efficiency

Char S1 [] = "aaaaaaaaaaaaa ";

Char * S2 = "bbbbbbbbbbbbbbbbb"; // aaaaaaaaaaa is assigned at the runtime, while bbbbbbbbbbbbb is determined at the Compilation Time;

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

For example:

# Include

Void main ()

{

Char A = 1;

Char C [] = "1234567890 ";

Char * P = "1234567890 ";

A = C [1];

A = P [1];

Return;

}

Corresponding assembly code

10: A = C [1];

00401067 8A 4D F1 mov Cl, byte PTR [ebp-0Fh]

0040106a 88 4D FC mov byte PTR [ebp-4], Cl

11: A = P [1];

0040106d 8B 55 EC mov edX, dword ptr [ebp-14h]

00401070 8A 42 01 mov Al, byte PTR [edX + 1]

00401073 88 45 FC mov byte PTR [ebp-4], Al

The first type reads the elements in the string directly into the CL register, while the second type reads the pointer value into EDX. Reading the characters based on edX is obviously slow.

2.7 summary:

The difference between stack and stack can be seen from the following metaphor: using Stack is like eating at a restaurant, just ordering food (sending an application), paying for it, and eating (using it ), when you are full, you don't have to worry about the preparation work, such as cutting and washing dishes, washing dishes, and so on. His advantage is that it is fast, but his degree of freedom is small. Using heap is like making your favorite dishes. It is troublesome, but it suits your taste and has a high degree of freedom.

What is the difference between the deep-Priority Search Algorithm and the extended-priority search algorithm?

Generally, the depth-first search method does not retain all nodes. Extended nodes are deleted from the database. In this way, the number of nodes stored in the database is the depth value, so it occupies less space. Therefore, when there are many nodes in the search tree and other methods are prone to memory overflow, deep priority search is an effective solution.

The breadth-first search algorithm generally needs to store all the nodes generated. The storage space occupied is much larger than the depth-first search. Therefore, in programming, overflow and memory saving must be considered. However, the breadth-first search method generally does not have backtracing operations, that is, the inbound and outbound operations, so the running speed is faster than the depth-first search.