Several small issues worth analyzing in C ++

Several small issues worth analyzing in C ++

I think C ++ ininner should be able to answer or identify the following three small questions. We hope that we can mine more information through questions, not just solve problems. What I like most: limited capabilities, so I hope to discuss them together and point out errors.

In addition, I have encountered a problem that I think it is necessary to record. I will write it down and talk about it. Therefore, each article may not be a single topic.

1. Let's take a look at a simple question. The following inheritance class is available:

 
 

  
  
Class Person
  
  
{
  
  
Public:
  
  
Void Walk () // "Walk" of ordinary people"
  
  
{
  
  
Cout <"Person: Walk I am an Ordinary People." <endl;
  
  
};
  
  
};
  
  
 
  
  
Class Student: public Person
  
  
{
  
  
Public:
  
  
Void Walk () // student's "Walk"
  
  
{
  
  
Cout <"Student: Walk I am a student." <endl;
  
  
};
  
  
};
 
 

You are not sure whether the Walk () function is a non-virtual function. Please explain the following code:

 
 

  
  
Student s; 
  
  
Person* pp = &s; 
  
  
pp->Walk(); 
  
  
 
  
  
Student* ps= &s; 
  
  
ps->Walk(); 
 
 

The result is as follows:

Analysis: Walk () is a non-virtual function and is limited by static binding. Therefore, the type of pp and ps determines the called version. Here, I also want to explain the following: Understanding interface inheritance and implementation inheritance. The purpose of declaring a non-virtual function is to make the derived class inherit the function interface and a mandatory implementation. Therefore, do not redefine the inherited non-virtual function.

2. the following problem is actually about static binding and dynamic binding, but it does not seem so obvious.

 
 

  
  
Class Shape
  
  
{
  
  
Public:
  
  
Enum ShapeColor {Red, Green, Blue}; // shape color
  
  
 
  
  
Virtual void Draw (ShapeColor color = Red) const = 0;
  
  
};
  
  
 
  
  
Class Circle: public Shape
  
  
{
  
  
Public:
  
  
Virtual void Draw (ShapeColor color) const
  
  
{
  
  
Cout <"I am Circle: Draw .";
  
  
Cout <"My color =" <color <endl;
  
  
}
  
  
};
  
  
 
  
  
Class Rectangle: public Shape
  
  
{
  
  
Public:
  
  
Virtual void Draw (ShapeColor color = Green) const // The default parameter value is changed
  
  
{
  
  
Cout <"I am Rectangle: Draw .";
  
  
Cout <"My color =" <color <endl;
  
  
}
  
  
};
 
 

I mainly want to talk about two problems.

1) when you call the following code, please explain what will happen.

 
 

  
  
Circle cr; // (1) Compilation fails
  
  
Cr. Draw ();
  
  
Shape * ps = & cr; // (2)
  
  
Ps-> Draw ();
 
 

Yes. (1) it is wrong to call an object without specifying a parameter. (2) The result is as follows: color = 0 indicates Red, which you should know.

Analysis: objects are called for static binding. You must specify the parameter value because static binding does not inherit the default parameter value from base class. Dynamic binding can inherit parameter values from base class. Note: Here I will not emphasize the concept of dynamic binding and static binding, but the following must be static binding:

 
 

  
  
Circle cr;
  
  
Circle * ps = & cr; // This is still static binding, and the static type is Circle *. Compilation fails.
  
  
Ps-> Draw ();
 
 

2) for the second question, please explain the following call results.

 
 

  
  
Shape* ps1 = new Rectangle; 
  
  
ps1->Draw(); 
  
  
Shape* ps2 = new Circle; 
  
  
ps2->Draw(); 
 
 

The following is a gratifying result:

You mean, you have changed the default value of Draw to 1 Green in Rectangle. Why is it ineffective?

Analysis: the default value of Rectangle: Draw is GREEN, but the static type of ps2 is Shape *. Therefore, the default value of this call is from Shape class.

If you want to change the Rectangle: Draw parameter, you can call it to provide the parameter ):

 
 

  
  
Shape* ps4 = new Rectangle; 
  
  
ps4->Draw(Shape::Green); 
  
  
Shape* ps5 = new Circle; 
  
  
ps5->Draw(Shape::Green); 
 
 

This problem is to remind you that virtual functions are dynamically bound, and the default parameter value is static binding. Therefore, the default parameter value should not be redefined.

3. Why does multi-inheritance contain multiple virtual table pointers instead of one?

This question was raised by the interviewer when I saw a classmate's experience in the interview. I tried to answer it. I don't know if I am not here. Please add and correct it.

A: under multi-inheritance, the compiler implements n-1 virtual tables for a derived class. n indicates the number of base classes on the previous layer, assume that each base class has at least one virtual function. Otherwise, the compiler will not add vptr and vtbl to it. Therefore, the number of virtual tables naturally has many pointers instead of one.

In this case, I don't know why it is unreasonable. The interviewer may ask, "why do I need multiple virtual tables? Cannot a virtual table row be created ?"

This is a task done by the compiler vendor. The standards are not standardized. C ++'s father has developed such a compiler prototype. by increasing the volume of vtbl, each slot has not only one pointer, but also an offset to adjust the point of this pointer.

The disadvantage of doing so is that all virtual function pointers in vtbl contain such an offset. If you do not need to adjust this direction, you must add the offset when calling the function, the offset value is 0 at this time. In addition, the expansion of each slot volume in vtbl. These are efficiency issues.

In fact, many trunk technologies are used to adjust the point of this. Compilation is required to achieve high efficiency. In addition, the sun compiler concatenates multiple virtual tables into one, and each table contains the pointer of the next table through the offset method). In this way, a pointer is needed.

I have limited understanding. I don't know if this is the case?