One of the interview questions Series

1 Programming Basics
1.1 understanding of basic concepts: the difference between const char *, char const *, and char * const is almost the same as that in each C ++ interview.
In fact, there are only three declarative methods that are very similar and easy to remember.
Bjarne provides a mnemonic method in his C ++ Programming Language: reads a declaration from The right to The left.
Const char * const cp; (* read as pointer)
Cp is a const pointer to char
Const char * p;
P is a pointer to const char;
Char const * p;
Similar to C ++, because the const * operator does not exist in C ++, const can only belong to the previous type.

2. pointer c
Int * p [n]; ----- pointer array. Each element is a pointer to integer data.
Int (*) p [n]; ------ p is the pointer to a one-dimensional array, which has n integer data.
Int * p (); ---------- the function returns a pointer pointing to the returned value.
Int (*) p (); ------ p is the pointer to the function.

3. array out-of-bounds
What are the following errors or effects after the program is executed:
# Deprecision MAX 255
Int main ()
{
Unsigned char a [Max], I;
For (I = 0; I <= max; I ++)
A [I] = I;
}
Answer: max = 255. The subscript range of array a is 0 .. MAX-1, this is one of the two, when I loop to 255, the execution in the loop: A [255] = 255; this statement itself is no problem,
However, when the for (I = 0; I <= max; I ++) Statement is returned, the unsigned char value range is (0 .. 255), after I ++, I is 0 again .. infinite Loop.
Note: The char type is a byte with a value range of [-128,127] and unsigned char [0,255].

4. What is the fundamental difference between strcpy and strcpy? C ++: memset, memcpy
# Include "memory. H"
Memset is used to set all memory spaces to a specific character. It is generally used to initialize the defined string as ''or '/0 ';
Example: Char A [100]; memset (A, '/0', sizeof ());

Memcpy is used for memory copying. You can use it to copy any data type object and specify the length of the copied data;
For example, char a [100], B [50]; memcpy (B, A, sizeof (B); If sizeof (a) is used ), b's memory address overflows.

Strcpy can only copy strings. It ends copying when '/0' is encountered. For example, char a [100], B [50]; strcpy (A, B );
If strcpy (B, A) is used, check whether the length of the string in A (before the first '/0') exceeds 50 bits. If it exceeds, this will cause memory address overflow of B.

Strcpy
Prototype: extern char * strcpy (char * dest, char * src );
Usage: # include
Function: Copies the string ending with NULL indicated by src to the array indicated by dest.
Note: The memory areas specified by src and dest cannot overlap and dest must have sufficient space to accommodate src strings.
Returns the pointer to dest.

Memcpy
Prototype: extern void * memcpy (void * dest, void * src, unsigned int count );
Usage: # include
Function: copy count bytes from the memory area indicated by src to the memory area indicated by dest.
Note: the memory areas specified by src and dest cannot overlap. The function returns a pointer to dest.

Memset
Prototype: extern void * memset (void * buffer, char c, int count );
Usage: # include
Function: sets the first count byte of the memory area referred to by buffer to character c.
Note: The pointer to the buffer is returned.

5. What is ASSERT () ()
ASSERT () is a macro that is often used when debugging a program. When the program is running, it calculates the expressions in parentheses. If the expression is FALSE (0), the program reports an error and terminates the execution.
If the expression is not 0, execute the following statement. This macro is often used to determine whether a program contains clearly illegal data,
If a program is terminated to avoid serious consequences, it is easy to find errors. For example, variable n should not be 0 in the program. If it is 0, an error may occur,
You can write a program like this:
......
ASSERT (n! = 0 );
K = 10/n;
......
ASSERT is valid only in the Debug version. If it is compiled into the Release version, it is ignored.
Assert () has similar functions. It is a function specified in the ansi c standard. An important difference between ASSERT and assert is that it can be used in the Release version.

6. ("pause"); pause the program, press any key to continue, the screen will print, "press any key to continue ..... "Eliminating the need to use getchar (); system

7. What is the difference between the C ++ class and the struct in C?
The classes in c ++ have the Member protection function and the Inheritance and polymorphism oo features, while the struct in c does not
The default access permission of classes in c ++ is private, while that of struct is public.

8. What are the usage and functions of destructor and virtual functions?
A destructor is also a special class member function. It does not return a type, has no parameters, cannot be called at will, and is not overloaded. Only when the life cycle of the Class Object ends,
Resources allocated in the constructor are automatically called and released by the system. During running, the ability to call that function can be determined based on its type is called polymorphism, or later Association.
In addition, destructor usually finish the work before the object is undo, such as memory reclaim,
The function of a virtual function is to enable the subclass to use functions of the same name to overload the parent function, and automatically call the subclass overload function when calling the function. If it is a pure virtual function, it is purely
There is a uniform name when the subclass is overloaded.

9. What is the difference between global variables and local variables? How is it implemented? How does the operating system and compiler know?
The life cycle of a global variable is the time when the entire program is run, while the life cycle of a local variable is the time period when a local function or process is called.
The compiler uses different memory allocation methods during compilation. The global variables are allocated after the main function is called. If the global variables are static variables, they are allocated before the main function.
It is initialized. Local variables are dynamically allocated in the user stack (or we recommend that you check the activity record in the compilation principle)

10. How many digits of the system is there? How is it implemented on the data bus? 8086
The 8086 system is a 16-bit system, and its data bus is a 20-bit system.

1.2 Program Design
1. Compile a recursive algorithm for finding the nth factorial problem in C language:
Long int fact (int n)
{
Int X;
Long int y;
If (n <0)
{
Printf ("error! ");
}
If (n = 0)
Return 1;
X = n-1;
Y = fact (X );
Return (N * y );
}
2. Binary Search Algorithm:
1) Implementation of recursive methods:
Int bsearch (elemtype A [], elemtype X, int low, int high)
/* Find the data element x in array a with the next row of low and the upper bound of high */
{
Int mid;
If (low> high) Return-1;
Mid = (low + high)/2;
If (x = A [Mid]) return mid;
If (x else return (bsearch (A, X, Mid + 1, high ));
}
2) Non-recursive method implementation:
Int bsearch (elemtype A [], keytype key, int N)
{
Int low, high, mid;
Low = 0; high = n-1;
While (low <= high)
{
Mid = (low + high)/2;
If (A [Mid]. Key = Key) return mid;
Else if (a [Mid]. Key else high = mid-1;
}
Return-1;
}
3. recursively calculate the values of the following recursive functions (Fibonacci ):
F (1) = 1
F (2) = 1
F (n) = f (n-1) + f (n-2) n> 2
Solution:
Int F (int n)
{
Int I, S, S1, S2;
S1 = 1;/* S1 is used to save the F (n-1) value */
S2 = 1;/* S2 is used to save F (n-2) value */
S = 1;
For (I = 3; I <= N; I ++)
{
S = S1 + S2;
S2 = S1;
S1 = s;
}
Return (s );
}
4. Swap two numbers without the third memory:
Int a = ......;
Int B = ......;
A = a + B;
B = a-B;
A = a-B;

5. Bubble Sorting:
Void BubbleSort (elemtype x [], int n)
{
Int I, j;
Elemtype temp;
For (I = 1; I for (j = 0; j {
If (x [j]. key> x [j + 1]. key)
{
Temp = x [j];
X [j] = x [j + 1];
X [j + 1] = temp;
}
}
}

8. Class knowledge
C ++
# Include
Class human
{
Public:
Human () {human_num ++ ;};
Static int human_num;
~ Human ()
{
Human_num --;
Print ();
}
Void print ()
{
Cout <"Human num is:" <}
Protected:
PRIVATE:
};
Int human: human_num = 0;
Human F1 (Human X)
{
X. Print ();
Return X;
}
Int main (INT argc, char * argv [])
{
Human H1;
H1.print ();
Human H2 = F1 (H1 );
H2.print ();
Return 0;
}
Output:
1
1
0
0
-1
-2
----------------------------
Analysis:
Human H1; // call the constructor, --- hum_num = 1;
H1.print (); // output: "Human is 1"
Human H2 = F1 (H1); // when you call F1 (H1) again, because the function parameters are passing objects by value, the default copy constructor is called,
It does not apply to hum_num ++, so hum_num is still = 1, So X. Print () Output: "Human is 1"; when introducing the F1 function, destroy X,
Call the Destructor (human_num --) and output: "Human is 0" (because the function returns a human object, the default constructor is called,
Create a temporary object (human_num = 0;), assign the temporary object to H2, and call the default constructor (human_num = 0); h2.print (); // output: human is 0;
// After exiting the main () function, destroy H2, call the Destructor (human_num --), output "human_num is-1", and then destroy H1, call the Destructor (--) and output "human_num is-2"

1.3 message mechanism for Windows
1. Windows Message Mechanism
Windows is a message-driven system. Windows messages provide communication between applications and Windows systems.
The functions that the application wants to implement are triggered by messages and completed by response and processing of messages.
There are two types of message queues in Windows: system message queues and application message queues. All input devices on the computer are monitored by windows.
When an event occurs, Windows first puts the entered message into the system message queue, and then copies the message to the corresponding application message queue.
The message processing program of the application checks the Message Queue repeatedly, and sends each detected message to the corresponding window function.
This is the process that an event must go through from occurrence to arrival of a window function.
It must be noted that messages are not preemptible. Regardless of the priority of events, they are always processed in sequence according to the arrival Order (except for some system messages ),
In this way, some real-time external events may not be processed in a timely manner.
2. Windows Message Mechanism
Messages in Windows are placed in the message queue of the corresponding process. It can be obtained through GetMessage. For general messages, this function returns a non-zero value,
However, for WM_QUIT messages, zero is returned. You can use this feature to end the program. After obtaining the message, you must convert the message before distributing the message.
The so-called conversion refers to the conversion of the keyboard code, the so-called distribution refers to the distribution of messages to the corresponding window, the corresponding window to process messages, so that the corresponding form of messages
The processing function is called. Two functions can implement these two functions: TranslateMessage and DispatchMessage.
In addition, it should be noted that when we click the close button to close the window, the program does not exit automatically, but sends a WM_DESTROY message to the program.
(In fact, the process is like this. First, send the WM_CLOSE message to the program. The default handler is to call DestroyWindow to destroy the form, thus triggering the WM_DESTROY message ),
In this case, we need to respond to this message in the form. to exit the program, we need to send the WM_QUIT message to the Program (implemented through PostQuitMessage ).
If you want to call your own message processing function for a form, you can use SendMessage to send messages to yourself.
As mentioned above, most (note most) messages are transmitted as follows: first put in the process's message queue, and then get the GetMessage. After conversion,
Distribute to the corresponding window. This type of message becomes a stored message. A stored message is basically the result of user input. It uses the following keys (for example, WM_KEYDOWN and WM_KEYUP messages ),
The characters (WM_CHAR), the mouse movement (WM_MOUSEMOVE), and the mouse button (WM_LBUTTONDOWN) generated by the Press key are given.
A stored message also contains a clock message (WM_TIMER), an update message (WM_PAINT), and an exit message (WM_QUIT ).
However, some messages are directly sent to windows, which are called non-stored messages. For example, when winmain calls createwindow,
Windows will create a window and send a wm_create message to the window message processing function during processing. When winmain calls showwindow, Windows will
The window message processing function sends wm_size and wm_showwindow messages. When winmain calls updatewindow, Windows sends the message processing function to the window.
Wm_paint message.

2. network knowledge
2.1. OSI and TCP/IP
1. OSI Layer-7 network structure (functions and features)
1) physical layer: provides physical connections for the data link layer, and transmits bits on it in a serial manner, that is, the unit of transmitted data is bits.
In addition, this layer also has the electrical and physical features of the device to determine the connection.
2) data link layer: responsible for transmitting frame-based data through detection, traffic control, re-transmission, and other means on the line between network nodes. To achieve this,
Each frame must contain synchronization, address, error control, traffic control, and other control information.
3) network layer: In order to send data groups from the source (Source System) to the destination (Target System), the task at the network layer is to select an appropriate route and exchange node,
The packet information transmitted from the source transport layer can be correctly identified by the address and delivered to the corresponding transport layer to complete the network addressing function.
4) Transport Layer: the transport layer is the interface layer connecting the high and low layers. The unit of data transmission is a packet. When the packet is long, it is divided into several groups and then handed over to the network layer for transmission.
The transport layer is the most critical layer in the computer network protocol hierarchy. The above layers no longer manage information transmission issues.
5) Session Layer: This layer provides synchronous management services for transmitted packets. Establish, organize, and coordinate interactions between application processes that communicate with each other in two different systems. For example,
Determine whether it is duplex or half duplex.
6) presentation layer: the main task of this layer is to transform the abstract syntax of the transmitted data into the transfer syntax, that is, to convert different representations within different computers into network communication
Standard representation. In addition, data encryption (or decryption) and body compression (or restoration) are also tasks of the presentation layer.
7) Application Layer: This layer is directly oriented to users and is the highest level in OSI. Its main task is to provide users with application interfaces, that is, to provide file transfer between different computers,
Access and management, email content processing, and virtual terminal functions that interact with different computers over the network.
2. TCP/IP (functions and features)
1) network interface layer: This is the lowest layer of TCP/IP protocol, including multiple Logical Link Control and media access protocols. The function of the network interface layer is to receive IP data packets and pass
A specific network for transmission, or receives physical frames from the network, extracts IP datagram and transfers it to the Internet layer.
2) Internet layer (IP layer): This layer includes the following protocols: IP (Internet Protocol), ICMP (Internet Control Message Protocol, Internet Control Message Protocol ),
ARP (Address Resolution Protocol), RARP (Reverse Address Resolution Protocol,
Reverse Address Resolution Protocol ). This layer is responsible for communication between computers in the same or different networks and mainly processes datagram and routing.
In the IP layer, ARP is used to convert an IP address to a physical address, RARP is used to convert a physical address to an IP address, and ICMP is used
Reports errors and transfer control information. The IP protocol is at the core of the TCP/IP protocol group.
3) Transport Layer: This layer provides two Protocols: TCP (Transport Control Protocol) and UDP (User datagrams Protocol), both established on the IP Protocol.
TCP provides reliable connection-oriented services and UDP provides simple connection-free services. The transport layer provides end-to-end communication between applications,
The main functions are data formatting, data validation, and loss retransmission.
4) Application Layer: the application layer of TCP/IP is equivalent to the Session Layer, presentation layer, and application layer of the OSI model. It provides users with a set of common application layer protocols,
Including Telnet, SMTP, and DNS. In addition, user applications are included in the application layer, all of which are dedicated programs built on TCP/IP protocol groups.
3. Differences between the OSI reference model and the TCP/IP Reference Model:
1) there are 7 layers of OSI model and 4 layers of TCP/IP;
2) OSI is prior to the protocol, so it does not favor any specific set of protocols and is more universal. However, some functions do not know which layer to store, so they have to be added to some child layers;
TCP/IP appears after the Protocol, only a description of the existing protocol, so the two work very well together; but it is not suitable for other protocol stacks, it is not easy to describe other non-TCP/IP networks;
3) the network layer in OSI supports connection-free and connection-oriented communication at the same time, but only connection-oriented communication at the transport layer. In TCP/IP, the network layer only supports connection-free communication,
The Transport Layer supports two types of communication at the same time;
4) when technology changes, the OSI model is easier to replace than the protocols in the TCP/IP model.

4. Please explain in detail the definition of the IP protocol. At which layer, what is the main function? What about TCP and UDP?
Solution: three protocols are used together with the IP protocol:
ARP-Address Resolution Protocol
RARP-Reverse Address Resolution Protocol
ICMP-Internet Control Packet protocol ICMP
IP protocol-Internet Protocol
IP address and IP Header

2.2. vswitches and vrouters
1. What are the implementation principles of vswitches and vrouters? At which level is the implementation implemented?
Some intermediate devices (or intermediate systems) are used to connect networks. ISO is called relay Systems. Based on the level of the relay system,
There can be the following five relay systems:
1) the physical layer (that is, the first layer and layer L1) repeater system ).
2) data link layer (Layer 2, layer L2), that is, bridge or bridge ).
3) the network layer (Layer 3, layer L3) relay system, that is, the router ).
4) the mixture of bridges and routers the router has the functions of bridges and routers.
5) a relay system above the network layer, that is, a gateway ).
When the relay system is a forwarder, it is generally not called network interconnection, because it only expands a network, and it is still a network. High-level gateways are complex,
Currently, it is rarely used. Therefore, network interconnection generally refers to the network in which vswitches and vrouters are interconnected. This article describes the differences between vswitches and vrouters.

2. What is the difference between vswitches and vrouters on the second layer:
Traditional switches are developed from bridges and belong to the OSI Layer 2 (data link layer device. It selects routes through the station table based on MAC address addressing, and establishes and maintains the station table.
The switch automatically performs this operation.
A router is a layer-3 network-layer device of OSI. It is addressing based on IP addresses and is generated through the route table routing protocol. Routing Protocol for the Internet:
IGP and EGP

3. What is the difference between layer-3 vswitches and vrouters:
Before the emergence of layer-3 switching technology, there was almost no need to distinguish routing devices from routers. They were exactly the same: Providing routing functions is working on routers,
However, layer-3 switches are now fully capable of implementing most of the functions of traditional routers.
To sum up, the switch is generally used for the LAN-WAN connection, the switch belongs to the bridge, is the data link layer equipment, some switches can also realize the third layer of the exchange.
A vro is used for Wan-WAN connections. It can resolve forwarding groups between different networks and act on the network layer. They only accept input groups from one line,
And then forward it to another line. These two lines may belong to different networks and adopt different protocols. In comparison, vro functions are more powerful than vswitches,
However, the speed is relatively slow and the price is high. The layer-3 switch can broadcast applications because it has both the ability of forwarding packets at the switch line speed and the good control function of the router.

3. high-quality programming C/C ++
1. Enter the if statement for bool, float, and comparison between pointer variables and "zero value. (10 points)
Write the if statement for comparing bool flag with zero value. (3 points)
Standard answer:
If (FLAG)
If (! Flag)
The following statement is a poor style, with no score.
If (flag = true)
If (flag = 1)
If (flag = false)
If (flag = 0)

Write the if statement for comparing float X with "zero value. (4 points)
Standard answer example:
Const float EPSINON = 0.000001;
If (x> =-EPSINON) & (x <= EPSINON)
// Do not use "=" or "! = "And numbers
Comparison, you should try to convert it to "> =" or "<="
Class form.
The following is an incorrect statement without scoring.
If (x = 0.0)
If (x! = 0.0)

Write the if statement for comparing char * p with "zero value. (3 points)
Standard answer:
If (p = NULL)
If (p! = NULL)
The following statement is a poor style, with no score.
If (p = 0)
If (p! = 0)
If (p)
If (!)
II. The following is a 32-bit C ++ program in Windows NT. Calculate the value of sizeof (10 points)
Char str [] = "Hello ";
Char * p = str;
Int n = 10;
Calculate
Sizeof (str) = 6 (2 points)
Sizeof (p) = 4 (2 points)
Sizeof (n) = 4 (2 points)
Void * p = malloc (100 );
Calculate
Sizeof (p) = 4 (2 points)
// Here it is still 4, that is, no matter whether p is allocated space or not, the calculation is only the length of p.
// Note the difference between sizeof and strlen. For str, the result of sizeof (str) is 6, and the result of strlen (str) is 5.
Iii. Short answer (25 points)
1. What is the use of ifndef/define/endif in the header file? (5 points)
A: prevent this header file from being repeatedly referenced.

2. What is the difference between # include and # include "filename. h? (5 points)
A: For # include, the compiler searches for filename. h from the standard library path.
For # include "filename. h", the compiler searches for filename. h from the user's working path.

3. What is the purpose of const? (Please specify at least two types) (5 points)
A: (1) const constants can be defined. (2) const can modify the parameters, return values, and even definitions of functions. Something modified by const
Both are protected by force to prevent unexpected changes and improve program robustness.

4. Why should I add the extern "C" to the function called by the C compiler after being compiled in the C ++ program "? (5 points)
A: The C ++ language supports function overloading. The C language does not support function overloading. Name of the function in the library after being compiled by C ++
Different from C. Assume that the prototype of a function is void foo (int x, int y). After the function is compiled by the C compiler, its name in the library is _ foo,
The C ++ compiler generates names such as _ foo_int_int. C ++ provides a C connection exchange with the specified symbol extern "C" to solve the name matching problem.

5. Briefly describe the advantages and disadvantages of the following two for loops (5 points)
For (I = 0; I {
If (condition)
DoSomething ();
Else
DoOtherthing ();
}
If (condition)
{
For (I = 0; I DoSomething ();
}
Else
{
For (I = 0; I DoOtherthing ();
}
Advantage: simple program
Disadvantage: More N-1 logic judgment is performed, and
Interrupted the loop "Pipeline" job to make Compilation
Cannot optimize the loop, reducing the efficiency
Rate.
Advantage: High Cycle Efficiency
Disadvantage: The program is not concise
4. Questions about memory (5 points for every question, 20 points in total)
Void GetMemory (char * p)
{
P = (char *) malloc (100 );
}
Void Test (void)
{
Char * str = NULL;
GetMemory (str );
Strcpy (str, "hello world ");
Printf (str );
}
What are the results of running the Test function?
A: The program crashes.
Because GetMemory cannot transmit dynamic memory,
Str in the Test function is always NULL.
Strcpy (str, "hello world"); will crash the program.
Char * GetMemory (void)
{
Char p [] = "hello world ";
Return p;
}
Void Test (void)
{
Char * str = NULL;
Str = GetMemory ();
Printf (str );
}
What are the results of running the Test function?
A: It may be garbled.
Because GetMemory returns "stack memory"
Pointer, the pointer address is not NULL, but its original
The first content has been cleared, and the new content is unknown.
Void GetMemory2 (char ** p, int num)
{
* P = (char *) malloc (num );
}
Void Test (void)
{
Char * str = NULL;
GetMemory (& str, 100 );
Strcpy (str, "hello ");
Printf (str );
}
What are the results of running the Test function?
A: (1) hello output; (2) Memory leakage

Void Test (void)
{
Char * str = (char *) malloc (100 );
Strcpy (str, "hello ");
Free (str );
If (str! = NULL)
{
Strcpy (str, "world ");
Printf (str );
}
}
What are the results of running the Test function?
A: Tampering with content in the dynamic memory area is difficult to pre-empt.
Material, very dangerous.
Because free (str); after that, str becomes a wild pointer,
If (str! = NULL) the statement does not work.

5. Compile the strcpy function (10 points)
It is known that the prototype of the strcpy function is
Char * strcpy (char * strDest, const char * strSrc );
Here, strDest is the destination string and strSrc is the source string.
(1) do not call the string library functions of C ++/C. Compile the strcpy function.
# Include
# Include
# Include
# Include

Char * Mystrcpy (char * strDest, const char * strSrc)
{
Char * ptr;
If (strdest = NULL | strsrc = NULL)
Exit (-1 );
PTR = strdest;
While (* strsrc! = '/0 ')
{
* Strdest = * strsrc;
Strdest ++;
Strsrc ++;
}
* Strdest = '/0 ';
Return PTR;
}

(2) Why should strcpy copy the content of strsrc to strdest?
A: To implement a chained expression. // 2 points
For example, int length = strlen (strcpy (strdest, "Hello World "));

6. Compile string-like constructor, destructor, and assignment function (25 points)
The prototype of the known class string is:
Class String
{
Public:
String (const char * str = NULL); // common Constructor
String (const String & other); // copy the constructor
~ String (void); // destructor
String & operator = (const String & other); // value assignment function
Private:
Char * m_data; // used to save strings
};
Compile the preceding four functions of String.
Standard answer:
Class String
{
Public:
String (const char * str = NULL); // common Constructor
String (const String & other); // copy the constructor
~ String (void); // destructor
String & operator = (const String & otherStr); // value assignment function
Private:
Char * m_data; // used to save strings
};

String ::~ String (void )//
{
Delete [] m_data;
// Because m_data is an internal data type, it can also be written as delete m_data;
}

// String Constructor
String: String (const char * str )//
{
If (str = NULL)
{
M_data = new char [1]; // It is better if NULL can be added
* M_data = '/0 ';
}
Else
{
Int length = strlen (str );
M_data = new char [length + 1]; // It is better if NULL can be added.
Strcpy (m_data, str );
}
}

// Copy the constructor
String: String (const String & other )//
{
Int length = strlen (other. m_data );
M_data = new char [length + 1]; // It is better if NULL can be added.
Strcpy (m_data, other. m_data );
}

// Value assignment function
String & String: operator = (const String & other )//
{
// (1) Check the auto-assigned Value
If (this = & other)
Return * this;
// (2) release the original memory resource
Delete [] m_data;
// (3) allocate new memory resources and copy the content
Int length = strlen (other. m_data );
M_data = new char [length + 1]; // It is better if NULL can be added.
Strcpy (m_data, other. m_data );
// (4) return the reference of this object
Return * this;
}