When we first met with pointers in C ++ (cm. Pointers in C++. Part 1 ) there can be a simplified representation, that the pointers can point only to individual variables embedded (scalar) C ++ type, and that this is just one more, an alternative form of access to such variables. In such an application pointers would welcome addition language, but with a very limited capacity.
A closer examination of C ++ pointers, we find, the pointer may be the address of accommodation (point at) any permissible object program: structure, class object, array, functions, or again, a pointer to an object, or a pointer to a pointer, and so on… This makes the pointer almost the most powerful tool in the programmer C ++ ... but also the most dangerous in terms of possible hidden errors.
Consider these options more. The easiest option is to use pointers to complex objects (class objects and structures). But such use of pointers opens up broad prospects in C ++, as we shall see.
So, we already know, that the class definition does not create any new database objects in the program - it is only a description of a template, new data type, according to which will create real objects data.
While creating (advertisement) New data objects, we can calculate the address of these objects and assign them to pointers to objects this class. Write a simple program, operations to be carried out with pointers to objects some class (file ex1.cc):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | #include <iostream> using namespace std; class my { // наш собственный класс private: int number; public: my( int numb ) : number( numb ) {}; void show( void ) { cout << "my number is " << number << endl; } }; int main( int argc, char **argv, char **envp ) { my m1( 10 ), m2( 15 ), m3 ( 25 ); // 3 объекта нового класса my *pm1 = &m1, *pm2 = &m2, *pm3 = &m3; // 3 указателя на эти же объекты m1.show(); m2.show(); m3.show(); pm1->show(); pm2->show(); pm3->show(); return 0; } |
Here we see a relatively new topics in our design:
1 | my( int numb ) : number( numb ) {}; |
This constructor new class my, but with a parameter creation. When you call it calls the superclass constructor (number(numb)), giving it the same value. The following parentheses {} frame empty block code, which means, that nothing more needs to be done over and above the call the parent constructor.
Remembering, that the entire sequence of the constructors of all parent classes – call (in reverse order of succession) when calling engendered by the class constructor, but this only for designers without parameters. In the case of parameterized constructors rodieley you will have to call the clearly.
But we will digress from the subject of our discussion… And now it's time to compile and see the execution of the program we have received:
Nothing fundamentally new, and all this is much like the, we would work with pointers to variables of type double, let us say.
Recall, in addition, what operator new to dynamically create a new object:
and) It causes the dynamic memory control manager and allocates a new volume for placement of the object;
b) causes constructor the corresponding class (data type) for the initial markup (initialization) dedicated memory. Slightly modify your example (file ex2.cc):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | #include <iostream> using namespace std; class my { private: int number; public: my( int numb ) : number( numb ) {}; void show( void ) { cout << "my number is " << number << endl; } }; int main( int argc, char **argv, char **envp ) { my m1( 10 ), m2( 15 ), m3 ( 25 ); my *pm1 = new my( 10 ), *pm2 = new my( 15 ), *pm3 = new my( 25 ); pm1->show(); pm2->show(); pm3->show(); delete pm1; delete pm2; delete pm3; return 0; } |
Building and Running:
It is still there have been no radical changes ..., but pay attention to the, that the program (and it could be arbitrarily large program) declared and no not used explicitly objects - The program operates only pointers to objects.
And, finally, we get closer to the techniques in the use of pointers to objects, which makes it the most powerful indicators of the work tool with classes and objects in C ++. Namely: Virtualization member functions and class polymorphism.
concept polymorphism (variability of form, the diversity) – one of the main C ++ development on its predecessor, the C. It is, that the progenitor of a whole family inherited classes announces some of its functions, methods like virtual. A different classes inherited these features methods redefined differently.
It means, that different derived classes (related) function method with the same name will be performed somewhat different way, depending on the class to which it is used.
To demonstrate this technique on the example. Create (file ex3.cc) class, describing in general any figures on the flat plane (it can be elements of a 2D game scenario):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | #include <iostream> #include <math.h> using namespace std; class figure { // абстрактный класс protected: double x, y; // центр: x, y double r; // масштаб фигуры public: figure( double r ) { x = y = 0.0; this->r = r; } // далее - 3 чистые (пустые) виртуальные функции: virtual const char *title( void ) = 0; virtual double area( void ) = 0; virtual double perimeter( void ) = 0; void show( void ) { cout << "фигура " << title() << ": площадь=" << area() << ", периметр=" << perimeter() << endl; }; }; |
Here we have an example of, in C ++ called abstract class: class, which defines at least one virtual function with the definition of the form:
1 | virtual double area( void ) = 0; |
In the illustrated class features such as much 3. Naturally, that create an object abstract class impossible, there are functions, which the body is not defined. Trying to declare objects of this class will cause a syntax error. But from such a class, you can inherit, create derivative classes, who will inherit the general properties of a generic abstract (for example, coordinates x and Y the center of the figure and its size r).
define 3 derivatives from figure class: a circle, square and an equilateral triangle:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | class circle : public figure { // класс всех кругов public: circle( double r ) : figure( r ) {}; const char *title( void ) { return "круг"; }; virtual double area( void ) { return M_PI * r * r; }; virtual double perimeter( void ) { return 2. * M_PI * r; }; }; class square : public figure { // класс всех квадратов public: square( double r ) : figure( r ) {}; const char *title( void ) { return "квадрат"; }; virtual double area( void ) { return r * r; }; virtual double perimeter( void ) { return 4. * r; }; }; class triangle : public figure { // класс всех равносторонних треугольников public: triangle( double r ) : figure( r ) {}; const char *title( void ) { return "треугольник"; }; virtual double area( void ) { return sqrt( 3. ) * r * r / 4.; }; virtual double perimeter( void ) { return 3. * r; }; }; |
Now we are ready to create a program, for which they were built all these preparations: create any number different 2D geometrical objects, on which can perform uniform (virtual) actions, regardless of their different natures:
1 2 3 4 5 6 7 | int main( int argc, char **argv, char **envp ) { figure *fgs[] = { new circle( 3 ), new square( 3 ), new triangle( 3 ) }; int n = sizeof( fgs ) / sizeof( fgs[ 0 ] ); for( int i = 0; i < n; i++ ) fgs[ i ]->show(); for( int i = 0; i < n; i++ ) delete fgs[ i ]; return 0; } |
In this very simple example illustrates the, what in object model C ++ language called Polymorphisms. And this property is one of the most powerful tools of expression of C ++. And this technique is always realized through pointers to objects (figure*).
That will look like a compilation and execution of our example (ex3.cc) at the terminal of the Linux operating system when using the GCC compiler with the C ++ language (it will once again confirms, that programming in C ++ in the least dependent on the operating system):
Once again we turn to the code shown in Example, and once again fix the very important fact, that C ++ pointers always typified: Index can not be "a pointer to something". The C ++ language – it is the language with strong Name typing. The type of the pointer is: a pointer to the variable type indicates it, such as "pointer to double». Pointers to different types are incompatible with each other on assignment and comparison.
Technology virtual functions and polymorphism are so central to the whole philosophy of C ++, that require a separate detailed consideration. About this talk in one of the following lessons.
On this topic – pointer indicates the beginning of the memory area (stores the address). And there is nothing more to write about it, tk. using the pointer you just take the value at that address, and leads him to the correct type (any).
If and to disclose the topic – IMHO it is necessary to write about it, what problems solved pointers (without touching the PLO, tk. then this theme is almost not disclosed) and write based on pointers vs reference (topic has been disclosed in Myers, You can take it basis).
But how are you then turned sharply you polymorphism. It's not bad, but nick, who read only your website is now little understood. Before, describing the classes you did not write about virtual functions, and even about the inheritance. And then suddenly fell to the reader all this and abstract classes.
At the end of the article you describe polymorphism – I think it's worth a separate article. But before you write an article about “Class inheritance in C++” (This last theme in your plan on the main page)
author – not the admin site )) Let us forgive him this, since it does not re-read all our articles
I agree. First about pointers, and then some fig about polymorphism. Somehow everything is too piled up.
I agree. Recent articles from the class section are difficult.
Tell, and who is admin? Lily and Igor? I always thought, that the name of the administrator writes Igor.
A, that means the strings? In the first listing
pm1->show();
pm2->show();
pm3->show();
class object (type) my – m1.
A pointer to this object – pm1.
m1.show() – method call (functions) show() class for my object m1.
pm1->show() – call exactly the same method show() my class through pointer object m1.
Actually, m1 – it is one object, and pm1 – a pointer to a completely different object of the same class (the Heap).
it is in Listing 2.
1p1rlh