13.Постоянные функции-члены класса.
В языке С++ программист имеет возможность объявить с помощью служебного слова const метод, который будет являться постоянным. Такой метод не может изменить значение ни одного из членов класса.
При объявлении постоянного метода ключевое слово const размещается в заголовке после закрывающей круглой скобки.
1. #include<iostream>
2. usingnamespace std;
3. Class avto {
4. public:
5. void
SetName(char*
name1) const{name=name1;}
6. void
SetCena(int
cena1) const{cena=cena1;}
7. void
SetRashod(double
rashod1) const{rashod=rashod1;}
8. int GetCena() const {return cena;}
9. char* GetName() const {return name;}
10. double GetRashod() const {return rashod;}
11. private: char* name;
12. int cena;
13. double rashod;
14. };
15. Int main()
16. {
17. avto F;
18. F.SetName("Toyota"); F.SetCena(23100); F.SetRashod(7.3);
19. cout << F.GetName() << endl << F.GetCena() << endl
20. <<F.GetRashod() << endl;
21. return 0;
22. }
В этом примере нельзя в качестве постоянного объявлять ни один из методов Set (см. строки 5-7), поскольку они ориентированы на изменение значений полей класса avto. Отметим, что разрешается (и считается правилом хорошего тона) объявить постоянными методы GetName(),GetCena() и Getrashod(). Эти методы только возвращают значения соответствующих полей класса avto.
Рекомендуется объявлять функции постоянными, если они не производят изменение содержимого объекта. Такой подход позволяет компилятору выявлять ошибки на ранней стадии, а это в конечном итоге значительно быстрее и дешевле, чем искать их самостоятельно.
14.Массив объектов.
В программе может возникать необходимость в использовании массива объектов. Программист имеет возможность при определении массива объектов использовать только неявный конструктор, а при необходимости можно каждый отдельный элемент массива инициализировать с помощью перегружаемого явного конструктора.
Рассмотрим пример, в котором определяется уже знакомый класс avto, содержащий 3 варианта явного конструктора и явный деструктор. В программе создается массив из четырех объектов avtoa[4]. Демонстрируется механизм инициализации элементов массива с помощью трех вариантов конструкторов.
1. #include<iostream>
2. usingnamespace std;
3. Class avto {
4. public:
5. avto(); // 1-йконструктор
6. avto(int); // 2-йконструктор
7. avto(int, int); // 3-й конструктор
8. ~avto(); // деструктор
9. void SetRashod(double rashod1) {rashod=rashod1;}
10. int GetCena() const {return cena;}
11. char* GetName() const {return name;}
12. double GetRashod() const {return rashod;}
13. private:
14. char* name;
15. int cena;
16. double rashod;
17. };
18. avto::avto() {cena=8700; name="Lada";}
19. avto::avto(int p){cena=p; name="Niva";}
20. avto::avto(int p, int c) {cena=p+p*c/100; name="Fiat";}
21. avto::~avto(){
22. cout <<"Object destroy! Address of CENA is "<<
23. &cena <<" Razmer "<<sizeof(name) << endl;};
24. Int main() {
25. avto a[4] = {avto(4500,10), avto(), avto(3500),avto()};
26. avto c = avto(7500); c.SetRashod(11.2);
27. a[0].SetRashod(6.5);
28. cout << a[0].GetCena() << endl << a[0].GetName()
29. << endl << a[0].GetRashod()<< endl;
30. a[1]=avto(1450,10); a[1].SetRashod(8.0);
31. cout << a[1].GetCena() << endl << a[1].GetName()
32. << endl << a[1].GetRashod()<< endl;
33. a[2]=c;
34. cout << a[2].GetCena() << endl << a[2].GetName()
35. << endl << a[2].GetRashod()<< endl;
36. a[3]=a[0]; a[3].SetRashod(7.5);
37. cout << a[3].GetCena() << endl << a[3].GetName()
38. <<endl<<a[3].GetRashod()<<endl;
39.return 0;
40. }
Описание класса avto представлено в строках с 3 по 17 включительно. В строках 5-8 записаны объявления прототипов 3 явных конструкторов и прототип явного деструктора. Кроме того, в 9-12 строках предусмотрены определения 4 методов, из которых 3 постоянных.
5. avto(); // 1-й конструктор
6. avto(int); // 2-й конструктор
7. avto(int, int); // 3-й конструктор
8. ~avto(); // деструктор
9. void SetRashod(double rashod1) {rashod=rashod1;}
10. int GetCena() const {return cena;}
11. char* GetName() const {return name;}
12. double GetRashod() const {return rashod;}
В 18-20 строках непосредственно определяются 3 явных конструктора. В 21-23 строках определяется явный деструктор класса avto.
18. avto::avto() {cena=8700; name="Lada";}
19. avto::avto(int p){cena=p; name="Niva";}
20. avto::avto(int p, int c) {cena=p+p*c/100; name="Fiat";}
21. avto::~avto(){
22. cout << "Object destroy! Address of CENA is " <<
23. &cena << " Razmer " << sizeof(name) << endl;};
Функция main() определяется в строках с 24 по 40 включительно. В 25 строке объявляется и инициализируется массив из четырех объектов.
25. avto a[4] = {avto(4500,10), avto(), avto(3500),avto()};
Отметим, что в инициализирующей части количество инициализирующих значений не может превышать число элементов массива, однако может быть меньше.
В 26 строке определяется объект c типа avto с помощью 2-го конструктора. С помощью метода SetRashod() определяется значение соответствующего поля объекта.
26. avto c = avto(7500); c.SetRashod(11.2);
В 27-29 строках продемонстрирована работа с нулевым элементом массива.
27. a[0].SetRashod(6.5);
28. cout << a[0].GetCena() << endl << a[0].GetName()
29. << endl << a[0].GetRashod()<< endl;
В начале 30 строки стоит операция a[1]=avto(1450,10); В процессе ее выполнения сначала запускается деструктор, который удаляет из памяти объект a[1], а затем запускается 3 конструктор класса avto.
В 33 и 36 строках продемонстрирована возможность выполнения соответствующих операций присваивания значений полям объектов.
33. a[2]=c;
36. a[3]=a[0]; a[3].SetRashod(7.5);
