- •1.Краткий обзор агрегатного типа struct.
- •Intcena;
- •Int main()
- •Int cena;
- •Void vyvod(avto s)
- •Int main()
- •3.Понятие объединения union.
- •Void vyvod(avto s, int I)
- •Int main()
- •Intcena;
- •Int main()
- •Int cena;
- •Intmain()
- •Void reset(); …
- •Void Demo::reset() // определениефункции reset( )
- •9.Пример реализации класса для организации обработки символьной строки.
- •Int demochar::length()
- •Int main()
- •10.Пример реализации класса для организации обработки одномерного массива целочисленных значений.
- •11.Инициализация объектов.
- •Int main()
- •12Указатель this.
- •13.Постоянные функции-члены класса.
- •3. Class avto {
- •15. Int main()
- •14.Массив объектов.
- •3. Class avto {
- •24. Int main() {
- •15.Статические переменные-члены и функции-члены класса.
- •17. Staticint GetSumCena() { return SumCena; };
- •19. Staticint SumCena;
- •16 Дружественные функции.
- •8. Friendvoid GetFields(avto&);
- •17 Класс, содержащий переменную-член типа класс.
- •3. Class Date_Avto {
- •16. Class avto {
- •30. Int main()
- •18 Сложность больших программных систем.
- •19 Пять признаков сложной системы.
- •20 Роль декомпозиции, абстракции, иерархии при построении сложных систем.
- •21 Объектная модель.
- •Ood основывается на объектно-ориентированной декомпозиции;
- •25Пример программы с наследованием классов.
- •3. Class avto {
- •18. Class gruz_avto : public avto {
- •36. Int main(){
- •26 Переопределение функций-членов внутри производного класса.
- •3. Class avto {
- •18. Class gruz_avto : public avto {
- •30. Int main()
- •5.Classint_Matrix// класс для обработки целочисленной матрицы
- •45. Int main()
- •Int main()
- •2. Usingnamespace std;
- •3. Int main()
- •18. Return 0;
- •Int main()
- •20. F.Write((char*)&s,sizeof(s));
- •7. Intcena;
- •21. F.Write((char*)&s,sizeof(s)); };
- •22. F.Close();
- •25. F.Seekg(sizeof(s), ios_base::beg);
- •26. F.Read((char*)&s,sizeof(s));
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);