Inheritance of Classes vs. Inheritance of Derived C C: Inheritance allows derived classes to inherit

R is not accessible in cylinder.

The successor of C++ allows the derived class to inherit the () of the base class.

a.partial features and allows you to add new features or redefine the properties of the base class.

b.Partial features, but non-combustible code allows for the addition of new features or the redefinition of the base class's features.

c.All features and allow you to add new features or redefine the features of the base class.

d.All features, but no new features are allowed to be added or redefined for the base class.

Correct answer: All features, and allows you to add new features or redefine the features of the base class.

In the C++ class system, the one that can be inherited by the derived class is the one that is erected ().

Construct the Fiber Potato Function.

Virtual functions. Destructors.

Friend element function. Correct answer: B

1 is because the child class inherits from the parent class, and the construction of the child class needs to rely on the parent class. Of course, the parent class should be constructed first. Make a gourd baby first build a gourd baby and his father.

2 Ibid. 3 father *p=son(duaghter)；Is this a copy constructor for a subclass? Regardless of him. This is for generic programming.

For example, there is a guy who didn't think about the big baby, the second baby and the third baby when he designed the program at the beginning, or he didn't know how many babies there would be. So how do I specify the arguments when I want to pass the objects (pointers) of this class and its subclasses, so I write:

void fun(father* p);

Okay, so if you call the fun function like this.

son *s=son(duaghter);

fun(s);== There will be a warning from the compiler, or an error. I haven't written C++ for too long, I forgot.

So the thing had to be written:

father *p=son(duaghter) 。

fun(p);

From a memory perspective, the first half of the memory occupied by the child class object is the content of the parent class.

When constructing a subclass object, of course, you should first call the constructor of the parent class, construct the first half first, and then call the constructor of the subclass to construct the part that belongs to you.

To initialize a derived class object, you need to initialize the constructor of the base class first, and you don't have to construct the object of the base class, unless you need to create a new object of the base class.

Because the derived class inherits the methods and variables of the base class, the variables it defines occupy a large amount of memory, and the methods of the base class are used, so the constructor of the base class must be initialized first.

This is a C++ polymorphism, where the parent class calls the methods that the derived class has when the pointer points to the derived class object. In this way, the pointer of the parent class has a variety of results, and the reduction is a lot.

Inheritance can reflect the universality and particularity of things.

This is an important concept of C++ object-oriented programming, inheritance can be reused, and subclasses can add functionality to the parent class.

For explicit functions, if not virtual inheritance, then every class that inherits from it has such a function.

It becomes redundant, multiple copies of the same thing.

First, in C++, there are three commonly used inheritance methods for classes, namely: public inheritance (public), private inheritance (private), and protection inheritance (protected);

Two, the difference between the three:

1. In the case of public inheritance, horizontal access and vertical access are not restricted to the public members in the base class;

2. In the case of private inheritance, horizontal access and vertical access are also inaccessible to public members in the base class;

3. When protecting inheritance, it is the same as public inheritance for vertical access, and the same as private inheritance for horizontal access;

4. For private members in the base class, they can only be accessed by member functions and friend functions in the base class, and cannot be accessed by other functions.

There are three ways to inherit:

public protected private。

The difference is that when the child class implements inheritance in one of the three ways, the members of the parent class have different access properties to the outside world.

public inheritance, and the member access properties of the parent class remain unchanged.

protected, the public member of the parent class becomes the protected property, and the access rights of other members remain unchanged.

private inheritance makes the access rights of all members of the base class in the subclass private.

public, protected, and privatepublic: The access permissions of the parent class remain unchanged, that is, public->public protected->protected private->private

protected: The public of the parent class becomes protected, and the other classes remain unchanged, i.e., public->protected protected->protected private->private

private: The public and protected of the parent class are changed to private, that is, public->private protected-> private private->private

The C derived class inherits all the features of the base class, but requires access permissions.

At the same time, the derived class can add new features or redefine the properties of the base class.

It is recommended that you take a look at the member functions declared by C++ Primer Public, and each class must have its own constructor. You can look at the basics of this. A friend is just a relationship that indicates that another function is a friend function.

In C++, a derived class inherits all the members of the base class, except for the constructor and destructor.

The friend function is not a class, it just opens a backdoor to the class.

Originally, the private members of the class cannot be accessed outside the class, but they can be inherited through the friend function. The child class inherits from the parent class, so by default, it inherits the member functions and member variables of the parent class.

When a child class is initialized, the constructor of the parent class is automatically called first. Only then do you call the constructor of the subclass when you destruct it in reverse order.

Construction starts at the very root of the class hierarchy, and in each layer, the constructor of the base class is called first, and then the constructor of the member object. Destruction is performed in the exact opposite order of the construction, which is unique, otherwise the compiler would not be able to automate the process. It cannot be inherited, it is determined by their function.

When a data member in a class becomes an object of another class, it is a combination of classes.

In other words, when an object of one class is used as a member of another class, it is a combination of classes.

Whereas, inheritance is authoritative.

1.Public inheritance

Public inheritance is characterized by the fact that both the public members of the base class and the protecting members remain in their original state as members of the derived class, while the private members of the base class remain private.

2.Private inheritance

Private inheritance is characterized by the fact that both the public and protected members of the base class are private members of the derived class and cannot be accessed by the subclasses of the derived class.

3.Protected Inheritance (protected).

Safeguard inheritance is characterized by the fact that all public and safeguard members of the base class become guardian members of the derived class and can only be accessed by its derived class member functions or friends, and the private members of the base class remain private.

Suppose A is the base class, B is a derivative of A, and C is a derivative of B.

Assuming that B is a public successor to A and C is a public successor to B, then.

B can access the public and protected class members of A, but cannot access the private members of A (so the inheritance method and the derived class cannot access the private members of the parent class, which will not be repeated below).

C has access to A's public, protected class members.

Assuming that B protection is inherited from A and C is publicly owned by B, then.

B has access to A's public, protected class members, and C has access to A's public, protected class members.

Assuming that B is privately inherited from A and C is publicly protected by B, then.

B has access to A's public, protected class members, and C does not have access to all members of A.

I don't know if you can understand that, thank you!

Inheritance and combination.

Inheritance Dark horses are horses.

Combination of mobile phone and headphones.

In order to achieve system function reuse, the common techniques of multiplexing are the infrastructure in the design pattern.

Combination? What is a combo ah?

I have summarized it myself, and it is also in the book: Shared Inheritance: 1

Shared inheritance does not change the access rights of base class members in the derived class. Under shared inheritance, the public members, protect members, and private members of the base class maintain the same access rights in the base class in the derived class. 2

Member functions defined in a derived class do not have direct access to the private members of the base class, but can only be accessed through public or protect member functions. Private inheritance:1

Both private and protect of the base class become private members in the derived class and cannot be accessed by the external functions of the derived class. 2

The member functions of the derived class do not have access to the private members of the base class, but they can access the public and protect members of the base class, and through them, the private members of the base class.

Inheritance is an important mechanism for object-oriented languages. It can be built on top of a general class. Inheritance and derivation are actually the same thing, but with different parameters, for example: a child class inherits the parent class, and the parent class derives the class.