Демонстрируется использование явного

Return x;

}

Void VYVOD(avto s)

{ cout <<"MARKA AVTO:"<< s.marka << endl;

cout <<"CENA AVTO:"<< s.cena << endl;

cout <<"RASHOD NA 100 km.:"<< s.rashod << endl;

cout <<"_____________"<< endl;

}

Int main()

{ avto A1;

A1=vvod_info();

VYVOD(A1);

avto* A2;

A2=&(vvod_info()); //!!! Так можно

cout <<"MARKA AVTO:"<< A2->marka << endl;

cout <<"CENA AVTO:"<< (*A2).cena << endl;

cout <<"RASHOD NA 100 km.:"<< A2->rashod << endl;

cout <<"_____________"<< endl;

cout <<"RAZMER A1 = "<<sizeof(A1) << endl;

cout <<"RAZMER A2 = "<<sizeof(A2) << endl;

return 0;

}

В языке С++ не разрешается использовать имя структуры для объявления других объектов в том случае пока сама структура полностью не объявлена. Например, недопустимо следующее рекурсивное определение:

struct Demo_1 {

…;

Demo_1 component_k;

};

В данном случае компилятор не может определить размер типа Demo_1, а потому фиксируется ошибка.

В том случае, когда два или более объектов типа struct ссылались друг на друга, разрешается использовать предварительное объявление только имени типа.

Например:

При объявлении типа st_2

// допускается использование указателя st_1*, но недопустимо

// использованиепросто st_1.

#include <iostream>

usingnamespace std;

Int main()

{

structst _1; // это только объявление типа

struct st_2 { int h1; st_1* h2; double h3; };

struct st_1 {char* c1; float c2; st_2 c3; };

st_1 x;

x.c1=“0123456789”; x.c3.h1=-1245;

cout << x.c1 << endl << x.c2 << endl << x.c3.h1 << endl;

st _2 y;

y. h 2= newst _1; // необходимое действие

y.h1=9876; y.h2->c1=“9876543210”; y.h3=-78.77;

cout << y.h2->c1 << endl << y.h1 << endl<< y.h3 << endl;

return 0;

}

Отметим, что при определении структурного типа st _1 первая компонента с1 объявлена как имеющая тип char *, что позволяет передавать строку символов.

!!! При использовании структур необходимо учитывать, что две структуры являются разными типами, даже если у них одинаковые члены. Например:

struct st_1 { int i;};

struct st_2 { int i;}; // здесь st_1 и st_2 – разныетипы

st_1 comp1;

st _2 comp 2= comp 1; // ошибка несоответствия типов

 

    2. Массивы структур.

В языке С++ можно создавать массивы структур. Отметим, что в предыдущем параграфе было показано, что поле структуры может быть массивом. Сейчас же рассмотрим пример программы, в которой создается и обрабатывается массив структур.

// Пример программы, в которой определяется структурный тип

// avto, содержащий три поля. На основе типа avto создается

// и инициализируется одномерный массив из трех элементов.

// Демонстрируются механизм обращения к полям элементов

// массива и механизм передачи значений структурного типа

// при использовании функции.

 

#include <iostream>

usingnamespace std;

struct avto { char marka[15];

      int cena;

      double rashod;

      };

Void VYVOD(avto s)

{ cout <<"MARKA AVTO:"<< s.marka << endl;

cout <<"CENA AVTO:"<< s.cena << endl;

cout <<"RASHOD NA 100 km.:"<< s.rashod << endl;

cout <<"_____________"<< endl;

}

Int main()

{ avto x[3] = { {"Ford", 18400, 8.6},

         {"Audi", 23500, 7.5},

         {"Renault", 21300, 8.0}

      };

for (int i=0; i<3; i++) VYVOD(x[i]);

cout <<"RAZMER MASSIVA x = "<<sizeof(x) << endl;

cout <<"RAZMER ELEMENTA x[0] = "<<sizeof(x[0]) << endl;

cout <<"RAZMER x[1].marka = "<<sizeof(x[1].marka)

<< endl;

cout <<"Cena avtomobilya "<< x[2].marka <<" = "

<< x[2].cena << endl;

cout <<"Poslednij simvol v nazvanii marki poslednego"

  "avtomobilya = " << x[2].marka[6] << endl;

return 0;

}

3.Понятие объединения union.

В языке С++ можно создавать объединения(union), которые фактически представляют собой подвид структур. Так же как и структура, объединение состоит из полей, но отличительной чертой union является то, что это объединение занимает в памяти столько места, сколько необходимо для размещения наиболее объемного из всех полей. В каждый конкретный момент времени объединение может хранить значение только одного из членов.

// Пример программы, в которой определяется объединение

// Type_Сena и структурный тип avto, содержащий три поля (одно

// из которых типа union). В программе определяется массив из

// трех элементов. Вводятся три записи, и далее демонстрируются

// механизм обращения к полям элементов массива и механизм

// передачи значений структурного типа при использовании

// функции.

#include <iostream>

usingnamespace std;

union Type_Cena { int icena;

         float fcena; };

struct avto { char marka[15];

         Type_Cena cena;

         double rashod; };

Void VYVOD(avto s, int i)

{ cout <<"MARKA AVTO:"<< s.marka << endl;

if (i<2) cout <<"CENA AVTO:"<< s.cena.icena << endl;

  else cout <<"CENA AVTO:"<< s.cena.fcena << endl;

cout <<"RASHOD NA 100 km.:"<< s.rashod << endl;

cout <<"_____________"<< endl;

}

Int main()

{ avto A1[3];

cin >> A1[0].marka >> A1[0].cena.icena >> A1[0].rashod;

cin >> A1[1].marka >> A1[1].cena.icena >> A1[1].rashod;

cin >> A1[2].marka >> A1[2].cena.fcena >> A1[2].rashod;

for (int i=0; i<3; i++) VYVOD(A1[i],i);

cout <<"RAZMER MASSIVA A1 = "<<sizeof(A1) << endl;

cout <<"RAZMER ELEMENTA A1[0] = "<<sizeof(A1[0]) << endl;

cout <<"RAZMER ELEMENTA A1[2] = "<<sizeof(A1[2]) << endl;

cout <<"Cena avtomobilya "<< A1[1].marka <<" = "

<< A1[1].cena.icena << endl;

cout <<"Cena avtomobilya "<< A1[2].marka <<" = "

<< A1[2].cena.fcena << endl;

return 0;

}

4.Правила объявления класса в языке C ++.

Класс представляет собой определяемый пользователем тип данных, который обычно содержит переменные-члены и функции-члены с определенными разделенными правами доступа (!!!).

Например: (ранее мы использовали struct avto {…}, теперь определим соответствующий класс)

class avto {

char name [15];

int cena;

double rashod;

};                       

Int main()

 {           …

    avto a1;         // объявлениеобъекта a1 класса avto

a 1. cena =12600;    // будет ошибка, т.к. доступ закрыт

…}

В данном случае будет фиксироваться ошибка, поскольку при выполнении оператора присваивания a1.cena=12600 осуществляется попытка доступа к закрытой переменной-члену класса avto. В этом варианте необходимо перед charname [15] записать public:.

Итак, можно сказать, что класс – это тип, переменные которого являются объектами ( или экземплярами класса). При определении классов должен использоваться следующий синтаксис:

с lass имя_класса {

Public:

          член_класса_1; открытые члены класс

Private:

член_класса_ n +1; закрытые члены класса

};

Каждая строка вида член_класса_i представляет либо объявление переменной-члена класса, либо прототип функции-члена, либо объявление функции-члена. Отметим, что в определении класса может находиться любое количество ключевых слов public и private.

При определении класса рекомендуется объявлять закрытыми переменные-члены и объявлять открытыми функции-члены, которые обеспечивают доступ к закрытым членам класса.Среди функций-членов класса отдельно выделяют конструкторы и деструктор. Конструкторы и деструкторы подразделяются на явные и неявные.

 

 

5. Конструкторы и деструкторы класса в языке C ++.

Неявные конструкторы и деструкторы формируются компилятором автоматически. Неявный конструктор всегда автоматически запускается на выполнение в момент определения объекта и формирует “заготовку” объекта в памяти компьютера.

После этого автоматически запускается явный конструктор (при условии, что он существует). Явный конструктор позволяет “внести” программисту нужные дополнения в ранее сформированную неявным конструктором “заготовку” объекта. Разрешается предусматривать перегрузку конструкторов, что обеспечивает максимально гибкий механизм для формирования объектов.

!!! Таким образом, в классе разрешается определять несколько перегружаемых конструкторов.

Неявный деструктор всегда автоматически запускается при достижении конца блока, в котором определен соответствующий объект. Он освобождает память, занимаемую элементами объекта. В классе можно определить один явный деструктор, который автоматически вызывается перед выполнением неявного деструктора.

Чаще всего функции-члены класса, включая конструкторы и деструкторы, определяются вне тела класса. Однако допускается и внутри. Если функция-член определяется вне класса, то, во-первых, внутри класса объявляется прототип, и, во-вторых, определение функции начинается с имени класса, за которым следует оператор разрешения области видимости :: (два подряд двоеточия), а далее размещается имя функции и ее параметры.

!!! Отметим, что конструктор имеет тоже имя, что и соответствующий класс, а имя деструктора также совпадает с именем класса, но перед первым символом ставится ~ (тильда). Отметим, что в заголовках конструкторов и деструкторов отсутствует указание на тип возвращаемого значения. Механизмы вызова конструктора и деструктора отличаются от механизма вызова обычной функции-члена класса.

Class avto

{

Класса avto

   ~ avto (); // прототип явного деструктора класса avto

Private:

char marka[15];

int cena;

  doublerashod;

};//!!! В конце описания класса обязательно пишется;

// Определение явного конструктора

Avto:: avto ()

{ cout << “Vvedite marku avto: ”; cin >> marka;

cout << “Vvedite cenu avto: ”; cin >> cena;

cout << “Vvedite rashod avto: ”; cin >> rashod;

}

// Определение явного деструктора

avto::~ avto ()

{ cout << “Marka avto:” << marka;

cout << “Cena avto:” << cena;

cout << “Rashod avto: ” << rashod;

cout << "RAZMER POLYA marka = " <<sizeof(marka) << endl;

cout << "RAZMER POLYA cena = " <<sizeof(cena) << endl;

cout << "RAZMER POLYA rashod = " <<sizeof(rashod) << endl;

}

Int main ()

{ avtoA 1; // вызываются неявный, а затем явный конструкторы

cout <<"RAZMER A1 = "<<sizeof(A1) << endl;

return 0;

} // вызываются явный, а затем неявный деструкторы

 

!!! Если в текст рассмотренной выше программы внести единственное изменение, и вместо служебного слова class написать struct, то программа будет работать!!!

6.Особенность типа struct в языке C ++.

!!! В языке С++ агрегатный тип struct устроен абсолютно также, как и тип class, с тем лишь отличием, что внутри класса все элементы по умолчанию имеют тип доступа private, а внутри структуры – public.

Особенностью использования структур в С++ является, во-первых, возможность включения в структуру функций-членов, и, во-вторых, то, что некоторая часть структур может быть сокрыта. В языке С такого не было.

 

Объявление функции-члена структуры включается в объявление структуры. Для обращения к такой функции в дальнейшем можно использовать конструкцию с оператором. (точка).

 

Идея включения в состав структур функций-членов заключается в том, что функциональность, необходимая для работы с типом данных struct, должна быть прямо включена в объявление структуры.

 

Функции-члены записываются также как и обычные, но эти функции могут напрямую обращаться к переменным-членам структуры без указания имени структуры.

 

Внутри объявления типа struct можно объявить только прототип функции, а определение размещать вне описания структурного типа. В этом случае в заголовке функции необходимо использовать дополнительно имя структурного типа и оператор разрешения области видимости ::.

 

Например:    struct Demo { …

                       void reset(); …

                 };

Class avto

{ public:

  void input_avto(); // прототипметода input_avto()

  void output_avto(); // прототипметода output_avto()

private:

  char marka[15];

  int cena;

  doublerashod;

}; //!!! В конце описания класса обязательно пишется;

// Определение функции-члена (метода) input _ avto () класса avto

void avto::input_avto()

{

cout <<"START METHOD input_avto!!!"<< endl;

cout <<"Vvedite marku avto: "; cin >> marka;

cout <<"Vvedite cenu avto: "; cin >> cena;

cout <<"Vvedite rashod avto: "; cin >> rashod;

cout <<"FINISH METHOD input_avto!!!\n"<< endl;

}

// Определение функции-члена (метода) output _ avto () класса avto

void avto::output_avto()

{ cout <<"START METHOD input_avto!!!"<< endl;

cout <<"Marka avto:"<< marka << endl;

cout <<"Cena avto:"<< cena << endl;

cout <<"Rashod avto:"<< rashod << endl;

cout <<"RAZMER POLYA marka = "<<sizeof(marka) << endl;

cout <<"RAZMER POLYA cena = "<<sizeof(cena) << endl;

cout <<"RAZMER POLYA rashod = "<<sizeof(rashod) << endl;

cout <<"FINISH METHOD input_avto!!!\n"<< endl;

}

Int main()

{ avto A1; // срабатывает неявный конструктор класса avto

A1.input_avto(); // вызывается функция-член input_avto()

cout <<"RAZMER A1 = "<<sizeof(A1) << endl << endl;

A1.output_avto();// вызываетсяфункция - член input_avto()

return 0;

} // срабатывает неявный деструктор класса avto

 

 

При вызове функции main () выполняется следующая последовательность действий:

1) выполняется неявный конструктор класса avto и формируется объект A1;

2) вызывается и выполняется метод input _ avto () класса avto;

3) выводится размер в байтах объекта A1;

4) вызывается и выполняется метод output _ avto () класса avto;

5) выполняется неявный деструктор класса avto ().

 

 

8.Пример использования класса и объектов в языке C ++.

Класс представляет собой определяемый пользователем тип данных, а определяемые на основе такого типа переменные называют объектами.

Рассмотрим пример программы, в которой определяется класс avto и, на его основе демонстрируются варианты работы с тремя объектами a,b,c.

Класс avto будет иметь три поля: 1) name для размещения марки автомобиля; 2) cena для размещения цены автомобиля; 3) rashod для размещения значения расхода топлива на 100 километров пробега. Для всех трех полей предусматривается закрытый режим доступа private:.

В классе avto предусматриваются три явных перегружаемых конструктора и явный деструктор.

Первый явный конструктор не имеет параметров. Этот вариант явного конструктора в поле cena записывает 5000, а в поле name записывает Lada.

Второй явный конструктор имеет один целочисленный параметр типа int. В результате выполнения этого варианта конструктора значение параметра записывается в поле cena.

Третий явный конструктор имеет два целочисленных параметра типа int. Первый параметр определяет значение базовой цены автомобиля, а второй – повышающий коэффициент для вычисления цены автомобиля. Этот конструктор формирует окончательное значение цены и записывает его в поле cena.

Явный деструктор предусматривает вывод сообщения об уничтожении объекта, об адресе и размере поля name.

Три функции-члена с именами, начинающимися с трех символов set, обеспечивают доступ к трем закрытым (private:) полям класса и предусматривают запись в эти поля соответствующих значений.

Три функции-члена с именами, начинающимися с трех символов get, обеспечивают доступ к трем закрытым полям класса и предусматривают чтение из полей хранящихся значений.

 

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 setname(char* name1){ name=name1;}

10. void setcena(int cena1) {cena=cena1;}

11. void setrashod(double rashod1) {rashod=rashod1;}

   

12. int getcena() {return cena;}

13. char* getname() {return name;}

14. double getrashod() {return rashod;}

 

15. private:

16. char* name;

17. int cena;

18. double rashod;

19. };

 

20. avto::avto() {cena=5000; name="Lada";}

21. avto::avto(int p){cena=p;};

22. avto::avto(int p, int c) {cena=p+p*c/100;}

 

23. avto::~avto(){

24. cout <<"Object destroy! Address of name_avto is "

25. <<&name <<" Razmer "<<sizeof(name)

26. << endl; };

 

27. int main() {

28. char navto[15];

29. cout <<"Input marka avto: "; cin >> navto;

 

30. { 

31. avto a(15000); a.setcena(15000+500);

32. a.setname(navto); a.setrashod(6.5);

33. cout << a.getcena() << endl << a.getname()

34.     << endl << a.getrashod()<< endl;

35. }

 

36. avto a(12000,10),b,c;

37. a.setname(navto); a.setrashod(6.5);

38. cout << a.getcena() << endl << a.getname()

39.     << endl << a.getrashod()<< endl;

 

40. b=avto(); b.setrashod(8.0);

41. cout << b.getcena() << endl << b.getname()

42.   << endl << b.getrashod()<< endl;

 

43. c=a; c.setrashod(7.5); 

44. cout << c.getcena() << endl << c.getname()

45.  << endl << c.getrashod()<< endl;

 

46. return 0;

47. }

Объявления класса avto находится в строках с 3 по 19 включительно и заканчивается соответствующей закрывающей фигурной скобкой, за которой записывается обязательная точка с запятой.

 

В строках 5,6,7 размещены прототипы трех явных конструкторов, а в строках с 20 по 22 включительно находятся определения соответствующих перегружаемых вариантов явных конструкторов.

5. avto();  // 1-й конструктор

6. avto(int); // 2-й конструктор

7. avto(int, int); // 3-й конструктор

20. avto::avto() {cena=5000; name="Lada";}

21. avto::avto(int p){cena=p;};

22. avto::avto(int p, int c) {cena=p+p*c/100;}

Отметим, что для конструкторов не нужно указывать тип возвращаемого значения, а имя явного конструктора всегда совпадает с названием соответствующего класса. В С++ допускается перегрузка явных конструкторов (по аналогии с перегрузкой функций). В данной программе соответствующие конструкторы отличаются списком параметров. В частности, в строке 20 определяется явный конструктор без параметров, в котором поле cena получает значение 5000, а названию автомобиля в поле name записывается Lada. В строке 21 определяется еще один вариант явного конструктора, в котором полю cena присваивает передаваемое значение.

В строке 31 инструкция avtoa (15000); определяет объект a класса avto путем вызова сначала неявного конструктора, который формирует заготовку объекта, и после этого сразу же автоматически вызывается явный конструктор из 21 строки, который в поле a.cena записывает значение 15000.

31. avtoa(15000); a.setcena(15000+500);

!!! Итак, при объявлении объекта сразу же, автоматически, запускаются неявный конструктор и далее соответствующий вариант явного конструктора, при условии, что такой предусматривается.

В строке 36 с помощью сначала вызова неявного конструктора, а затем конструктора из 20 строк доопределяются объекты с именами b и c, а с помощью конструктора из 22 строки доопределяется объект a. Второй параметр этого явного конструктора в данном примере определяет процент увеличения цены автомобиля.

36. avtoa(12000,10),b,c;

!!! Обратим внимание на то, что в 31 и 36 строках определены два объекта с именами a, причем используются при этом разные варианты конструктора. В данном случае строки с 31 по 35 включительно заключены в фигурные скобки, а потому соответствующее объявление объекта a носит локальный характер. Если скобки удалить, то будет возникать ошибка, поскольку тогда в программе будет проводиться попытка определения двух объектов с одинаковыми именами.

В языке С++ допускается отсутствие соответствующих объявлений конструкторов при описании класса. В этом случае создается и используется только неявный конструктор (иногда говорят конструктор по умолчанию), который не имеет параметров. Таким образом, в программе можно изъять строки 5-7, 20-22, заменить в 31 avtoa (15000);  на avtoa;  и в 36 строке avto a (12000,10),b,c;  на avtoa,b,c; и программа должна работать.

Явный деструктор представляет собой специальную функцию-член класса, имя которой начинается с ~ (тильда) с последующим указанием имени класса. Деструктор вызывается автоматически при выходе из блока, в котором был объявлен объект. Деструктор также вызывается в том случае, когда оператор delete применяется к указателю на именующий деструктор объект или в случае, когда он необходим для удаления подобъекта уничтожаемого объекта. Если предусматривается явный деструктор, то он вызывается перед неявным деструктором, который всегда формируется для соответствующего класса. Следовательно, в приведенном примере можно убрать 8 стр., 23-26 стр. Тогда будет определен только неявный деструктор.

В нашем примере определен явный деструктор, который при его выполнении будет выдавать сообщение

Object destroy! Address of name_avto is адресполя name объекта

Razmer размер объекта

Обратим внимание на специфику выполнения конструктора в стр. 40. В языке С++ допустим оператор присваивания b = avto ();. В этом случае сначала для объекта b выполнятся явный деструктор, далее неявный деструктор, а затем вновь сначала неявным, а потом явным конструктором будет создан объект b.

40. b=avto(); b.setrashod(8.0);

В представленном примере реализованы три функции-члена, имена которых начинаются с set. Все они используются для записи значений переменным-членам класса avto. С помощью трех функций-членов, имена которых начинаются с get, можно получать соответствующие значения.

9. void setname(char* name1){ name=name1;}

10. void setcena(int cena1) {cena=cena1;}

11. void setrashod(double rashod1) {rashod=rashod1;}

12. int getcena() {return cena;}

13. char* getname() {return name;}

14. doublegetrashod() {returnrashod;}

В стр. 43 приводится пример операции присваивания c = a, которая допустима в языке С++.

43. c=a; c.setrashod(7.5); 

Рассмотрим начальный фрагмент функции main (), в котором в строках 27-28 определяется символьный массив navto [15], и далее вводится марка автомобиля.

27. int main() {

28. char navto[15];

29. cout <<"Input marka avto: "; cin >> navto;

30. { 

31. avto a(15000); a.setcena(15000+500);

32. a.setname(navto); a.setrashod(6.5);

33. cout << a.getcena() << endl << a.getname()

34.     <<endl<<a.getrashod()<<endl;

35. }

В строках 30-35 определен блок, заключенный в фигурные скобки. В 31 строке на основе второго конструктора создается объект a. Далее с помощью методов setcena(), setname(), setrashod() в строках 31-32 записываются соответствующие значения в поля cena, name, rashod. В 33-34 строках предусмотрен вывод этих значений на экран. В 35 строке блок завершается, а потому завершается существование объекта a, и в этот момент автоматически запускается сначала явный деструктор и далее неявный деструктор окончательно убирает объект из памяти.

В заключительном фрагменте функции main () демонстрируются некоторые приемы работы с тремя объектами (экземплярами класса) a, b, c.

 

36. avto a(12000,10),b,c;

37. a.setname(navto); a.setrashod(6.5);

38. cout << a.getcena() << endl << a.getname()

39. << endl << a.getrashod()<< endl;

 

40. b=avto(); b.setrashod(8.0);

41. cout << b.getcena() << endl << b.getname()

42.   << endl << b.getrashod()<< endl;

 

43. c=a; c.setrashod(7.5); 

44. cout << c.getcena() << endl << c.getname()

45.  << endl << c.getrashod()<< endl;

46. return 0;

47. }// Трижды вызываются деструкторы для объектов a,b,c

 

 

Пример реализации класса для организации обработки символьной строки.

В программе определяется класс demochar, в котором предусмотрены два явных конструктора, соответственно для обеспечения ввода строки с клавиатуры (1-ый конструктор) и для формирования строки с использованием генератора случайных значений (2-й конструктор).

В классе demochar в качестве закрытого члена определяется переменная-член (поле) st [ dlina ], а для вычисления длины этой строки предусматривается функция-член (метод) length ().

#include<iostream>

#include<stdlib.h>

#include<time.h>

usingnamespace std;

constint dlina=121;

// объявлениекласса demochar

class demochar {

public: demochar();      // прототип 1-гоконструктора

   demochar(int,int,int); // прототип 2-гоконструктора

intlength(); // прототип функции для вычисления

  // длиныстроки st класса demochar

private: char st[dlina]; 

};

// Определение 1-го конструктора, обеспечивающего ввод

// строки длиной до 120 символов с клавиатуры

Demochar::demochar()

{ bool fl=false;

do { cout <<"Vvedite stroku:"; cin >> st;

if (length()>=dlina)

      { cout <<"Error!!! Vvedena slishkom dlinnaya stroka!"; fl=true;}

      else fl=false; }

while (fl);

}

// Определение 2-го конструктора, обеспечивающего генерацию

// c помощью ГСЗстрокидлинойдо 120 символов

Int demochar::length()

{ int kl=0;

while (st[kl]!='\0') kl++;

return kl; 

}

Int main()

{ int m;

cout <<"Vvedite 0 - GSZ ili drugoe chislo "

<< "dlya vvoda s klaviaturi:"; cin >> m;

   

if (m==0)

  { cout <<"Regim GSZ:"<< endl;

      int dls,min,max;

      bool fl=false;

      do { cout <<"Vvedite dlinu stroki:"; cin >> dls;

      if (dls>=dlina)

      { cout <<"Dlina vvedena nepravilno!"<< endl;

 fl=true;}

      else fl=false; }

      while (fl);

          

cout <<"VVEDITE min,max (ot 65 do 90):";

cin >> min >> max;

      if (max<min) {int prom=min; min=max; max=prom;}

      demochar ch(dls,min,max);}

else

  {cout <<"Regim vvoda s klaviaturi:"<< endl;

 demochar ch;

   cout <<"Dlina vvedennoj stroki = "<< ch.length()

<<endl;}

return 0;

}

При запуске программы в самом начале необходимо при выборе режима работы либо ввести 0 для формирования символьной строки с помощью генератора случайных значений, либо ввести другое целое число для активизации режима ввода символьной строки с клавиатуры.

В случае выбора режима формирования строки с использованием ГСЗ необходимо будет ввести значение длины строки и диапазон кодов символов.

!!! Отметим, что любой член класса может напрямую обращаться к другому члену класса, а потому функция length () “видит” строку st, а в 1-ом конструкторе идет обращение к функции length ().

Был получен следующий результат при выполнении программы с использованием генератора случайных чисел:

 

 

Пример реализации класса для организации обработки одномерного массива целочисленных значений.

В программе определяется класс int_array, в котором предусмотрены два явных конструктора, соответственно для обеспечения ввода целочисленных значений с клавиатуры (1-ый конструктор) и для формирования одномерного целочисленного массива с использованием генератора случайных значений (2-й конструктор).

В классе int_array в качестве закрытых членов определяются поле kl_el для размещения фактического количества элементов в массиве и одномерный целочисленный массив a[max_kl]. Метод Input_kl_el() предназначен для обеспечения ввода значения поля kl_el. Метод Output() обеспечивает вывод значений элементов массива на экран. Для вычисления суммы элементов массива реализован метод Summa_el(), а для вычисления среднего арифметического среди всех элементов – SArifm_el(). Метод Sort() предназначен для формирования на основе исходного массива отсортированного по возрастанию массива. Метод Get_kl_el() обеспечивает доступ к закрытому (возвращает его значение) полю kl_el.

#include <iostream>

#include <stdlib.h>

#include <time.h>

using namespace std;

constintmax_kl=18;

 

classint_array {

public: 

int_array();             // Прототип 1-го конструктора

    int_array(int); // Прототип 2-го конструктора

voidInput_kl_el(); // Прототип функции для ввода 

                         // количества элементов массива

    voidOutput();         // Прототип функции для вывода массива

    intSumma_el(); // Прототип функции для вычисления

                                          // значения суммы элементов массива

    doubleSArifm_el(); // Прототип функции для вычисления

                         // знпчения среднего арифметического

    voidSort(int b[max_kl]); // Прототип функции сортировки

                          // массива

                  

    intGet_kl_el() {returnkl_el;} // Метод возвращает

// кол-воэлементов

 

private: intkl_el;

              int a[max_kl]; 

};

 

// Определение 1-го конструктора, обеспечивающего ввод

// с клавиатуры целочисленного массива (до 18 элементов)

int_array::int_array()

{  Input_kl_el();

    for(inti=0; i<kl_el; i++)

    { cout<< "Vvvedite " <<i<< " element: ";

    cin>> a[i]; }

}

 

// Определение 2-го конструктора, обеспечивающего генерацию

// c помощью ГСЗ целочисленного массива (до 18 элементов)

int_array::int_array(int prom)

{  Input_kl_el();

    intmin,max;

    cout<< "VVEDITE min,max: ";

    cin>> min >> max;

    if (max<min) {prom=min; min=max; max=prom;}

        

    srand((unsigned) time(NULL));

    for(inti=0; i<kl_el; i++) a[i]=rand()%(max-min+1)+min;

}

 

voidint_array::Input_kl_el()

{  boolfl=false;

    do { cout<< "Vveditekolichestvoelementovmassiva: ";

cin>>kl_el;

    if ((kl_el< 1) || (kl_el>max_kl))

                       { cout<< "Oshibka v kolichestve"

<<" elementovmassiva!!!" <<endl;

              fl=true;}

              elsefl=false; }

    while (fl);

}

 

voidint_array::Output()  // Метод класса выводит массив на экран

{      

    for(inti=0; i<kl_el; i++) cout<< a[i] << "; ";

    cout<<endl;

}

 

intint_array::Summa_el()

{

    int sum=0;

    for(inti=0; i<kl_el; i++) sum+=a[i];

    return sum;

}

 

doubleint_array::SArifm_el()

{

    return (double)Summa_el()/kl_el;

}

 

voidint_array::Sort(int b[max_kl])

{ for (inti=0; i<kl_el; i++) b[i]=a[i];

 

// Сортировка с помощью прямого выбора

    for (int i=0; i < kl_el-1; i++)

              for (int j=i+1; j <kl_el; j++)

                       if (b[i]>b[j])

{int prom=b[i]; b[i]=b[j]; b[j]=prom;}

}

 

int main()

{  int x[max_kl];

 

intregim;

    cout<< "Vvedite 0 - GSZ ilidrugoechislodlyavvoda"

<< "s klaviaturi: ";

    cin>>regim;

        

if (regim==0)

              {      

cout<< "Regim GSZ ->" <<endl;

                       int_arraymassiv(0);

                       cout<< "Massiv -> "; massiv.Output();

                       cout<< "Summa elementov = " <<massiv.Summa_el()

<<endl;

                       cout<< "Sredneearifm = " <<massiv.SArifm_el()

<<endl;

                           

                       massiv.Sort(x);

                       for (inti=0; i<massiv.Get_kl_el(); i++)

cout<< x[i] << "; ";

                       cout<<endl;

              }

              else

              {      

cout<< "Regimvvoda s klaviaturi:" <<endl;

                       int_arraymassiv;

                       cout<< "Massiv -> "; massiv.Output();

                       cout<< "Summa elementov = " <<massiv.Summa_el()

<<endl;

                       cout<< "Sredneearifm = " <<massiv.SArifm_el()

<<endl;

                           

                       massiv.Sort(x);

                       for (inti=0; i<massiv.Get_kl_el(); i++)

cout<< x[i] << "; ";

                       cout<<endl;

              }

return 0;

}

 

В программе внутри функции main() в самом ее начале определяется массив int x[max_kl];, в котором в дальнейшем будут размещены отсортированные значения массива из объекта с именем massiv. Затем определяется целочисленная переменная intregim; и вводится ее значение. Если для переменной regim введено целочисленное значение 0, то выполняется та часть программы, в которой с помощью 2-го конструктора формируется объект massiv класса int_array, а иначе объект massiv класса int_array формируется с помощью 1-го конструктора.

 

Отметим, что в обоих случаях после формирования объекта massiv предусматривается выполнение следующих операций:

1) вывод сформированного целочисленного массива на экран с помощью метода Output();

2) вывод суммы элементов массива на экран методом Summa_el();

3) вывод среднего арифметического методом SArifm_el();

4) сортировка сформированного массива с помощью метода Sort();

5) вывод отсортированного массива на экран с использованием цикла for.

Инициализация объектов.

Ранее было показано, что в языке С++ значения переменных-членов класса можно непосредственно определять в теле явного конструктора. На самом же деле механизм вызова конструктора реализован в два этапа:

1) инициализация; 2) вызов тела конструктора.

Значения переменным-членамкласса можно задавать как на этапе инициализации, так и внутри тела конструктора. Отметим, что часто логически правильнее устанавливать значения переменных-членов на этапе инициализации. В этом случае записывается имя конструктора, в круглых скобках при необходимости указывается список параметров, затем после закрывающей круглой скобки ставится двоеточие, далее идет список инициализации, в котором элементы отделяются запятыми, а потом в фигурных скобках размещается тело конструктора.

#include<iostream>

usingnamespace std;

 

class avto {

public:

avto(): cena(18500),

        rashod(7.2) { name="FORD";} // 1-йконструктор

   

avto(int p): cena(p),

            rashod(8.5) {name="OPEL";} // 2-йконструктор

avto(int p, int c): cena(p+p*c/100),

       rashod(6.5) {name="SKODA";} // 3-йконструктор

~