Ask for advice, a pointer of class C.

I took a hard look at your question today.

That is true. base *p stands for p as a pointer to the base class type. This is condition one.

p=&obj1 represents p as the base class pointer to the subclass object. It's okay. Here's an example:

The base class is "people".

A subclass is a "student" derived from a "person".

So p stands for the type "person", so point p to "student", which of course is possible, because the student inherits the type of the base class "person".

Other words. The pointer p of the base class type points to the object obj1 of the subclass type. Together with condition one, it constitutes a necessary condition for the realization of polymorphism.

So if you call a virtual function in the base class with p, you can implement polymorphism (provided that there is a cover function of the virtual function in the subclass), which means that the cover function in the child class object is called according to the subclass object that p points to.

First of all, in C++, the conversion of pointers between inherited relationships is generally done with a secure transformation dynamic cast.

Second, in an insecure conversion, the compiler won't help with checks, so there will be no errors at compile time. If the print of the subclass does not involve member functions or member variables that are not contained in the base class, there will be no error when running. However, if there is a subclass of custom elements, an error will be reported.

Besides, it's a very strange way for you to write like this. Why does the base class call the subclass's functions? If you mean to use polymorphism, it should be.

base* obj4 = new first_d(4);

obj4->print();print() is a virtual function.

This is the first d print().

The pointer to the base class can point to the part of the derived class object that inherits from the base class, which we call polymorphism.

If both your obj2 and obj3 prints inherit to the base class, then the call is valid.

It can be defined like this. In the loop, the scope of the variable is in the two {} of the loop, so it is not defined repeatedly. If the definition is repeated, the compiler will report an error.

1.Definition.

Type: * Pointer Variable;

The type determines the size of the memory space to which it is pointed.

A pointer variable is also a variable that has its own memory space, which is stored on top of another variable's memory space.

You can use typedef aliases to reduce some of the hassle of defining variables, such as typedef int* pointer;

2.Operate.

1) Take the address.

int* p; int x; p = x;p points to the address of x, the type of p is int*, and the type of x is also int*

2) Indirect access.

For general pointer variables, the access format is: *Pointer Variables

The pointer variable of the structure type, the access format is: (*pointer variable).Structure Members or Pointer Variables - >Structure Members

3) Assignment. Any type of pointer can be assigned to a pointer variable of type void *, while a pointer variable of type non-void * can only accept assignments of the same type.

4) Pointer operations.

A pointer plus or minus an integer value: Data Type * Pointer Variable; int a;"Pointer Variables" +a; It can be understood as a change in the subscript in the array, "Pointer Variable" = Pointer Variable + (a*sizeof).

Subtract two pointers of the same type: the result is an integer value, which corresponds to the number of elements in the storage space, which can be used to find the size of the array.

5) The output of the pointer.

Pointer variable of type non-char*: cout<