Если у вас возникли сложности с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой - мы готовы помочь.
Предоплата всего
Подписываем
Цель задания – изучение приёмов объектного программирования с использованием классов, объектов, конструкторов, деструкторов.
Класс представляет собой тип, определяемый пользователем, и в простейшем случае имеет вид:
сlass имя_класа{
//члены класса
};
Объект – это экземпляр класса или переменная типа класс. Класс задаёт целую категорию объектов
Список членов класса включает данные-члены (далее – данные), представляющие объект, и функции-члены (далее – функции), выполняющие действия над ними. Все объекты имеют общие функции, но каждый объект создаёт и поддерживает свои собственные данные.
По умолчанию все данные и функции класса являются закрытыми (private), т.е. доступны только в пределах класса. Чтобы сделать их доступными вне класса, используется модификатор public. Обычно данные класса объявляются как private, а функции – как public:
class Samp{
int n, m; // private-данные
public:
init(); // public-функции
};
Для создания объекта испольуют имя класса как спецификатор типа данных:
Samp ob1; // создание объекта ob1 класса Samp
Доступ к закрытым членам класса осуществляется через открытые функции класса. К открытым членам класса можно обращаться, используя имя объекта и операцию точка (.):
ob1.init(); // вызов функции init()
Функции класса определяют как обычные функции, но перед именем функции пишется имя класса и операция разрешения области видимости (::):
Samp::init(){ // определение функция init() класса Samp
n = 10; m = 20;
}
Определение функции класса может находиться и внутри описания класса. Такие функции называются inline-функциями.
Дружественные функции – это функции, которые не являются членами класса, но имеет доступ к закрытым членам класса (но только через объект). Отличительным признаком дружественной функции является ключевое слово friend. Дружественная функция задаётся и вызывается как обычная функция, может быть дружественной более чем одному классу, может быть членом одного класса и дружественной другому.
Конструктор – это специальная функция класса, которая вызывается автоматически при создании объекта и предназначена для его инициализации. Конструктор должен иметь тоже имя, что и класс, должен быть открытым членом класса, может быть перегружен, может иметь параметры, но не может возвращать значение, даже типа void. Если класс не содержит ни одного конструктора, конструктор по умолчанию создаётся компилятором как функция без параметров и с пустым телом.
Конструктор по умолчанию – это конструктор, который совсем не имеет параметров или у которого все параметры заданы как аргументы по умолчанию (их можно задавать только в прототипе конструктора внутри определения класса). Класс может иметь только один конструктор по умолчанию.
Деструктор – это функция класса, которая вызывается автоматически при удалении объекта. Имя деструктора начинается c символа тильды (~), непосредственно за которым следует имя класса. Деструктор не может иметь параметров, не может возвращать значение, его нельзя перегружать. Класс должен иметь только один деструктор или ни одного, в этом случае он создаётся компилятором как пустая функция (без параметров и с пустым телом).
// Пример 1.1. Определение класса для нахождение суммы, произведения
// двух целых чисел, создание объекта, использование конструктора.
#include <iostream.h>
class Chisla{ // класс Chisla
int a, b; // данные a и b класса
public:
Chisla(int x, int y); // конструктор с параметрами
int sum(); // функция sum() – для выч. суммы
int mult(); // функция mult() – для выч. произведения
show(); // функция show() – для вывода чисел
};
Chisla:: Chisla (int x, int y){ // определение конструктора
a = x; b = y; // инициализация a, b
}
int Chisla::sum(){ // определение функции sum()
return a + b;
}
int Chisla::mult(){ // определение функции mult()
return a * b;
}
Chisla::show(){ // определение функции show()
cout<<" a = "<<a<<” b = “<<b<<endl;
}
main(){ // функция main()
system (“cls”); // для очистки экрана
int n, m;
int s, pr;
cout<<"vvedi chisla: ";
cin>>n>>m; //ввод чисел
Chisla ob(n, m); // создание объекта ob типа Chisla
ob.show(); // вызов функции show()
s = ob.sum(); // вызов функции sum()
pr = ob.mult(); // вызов функции mult()
cout<<”summa = “<<s<<” mult = “<<pr<<endl;
// можно вызов функций вставлять в cout
// cout<<”summa = “<<ob.sum()<<” mult = “<<ob.mult()<<endl;
system(“pause”); // задержка экрана
}
// Пример 1.2. Определение класса для нахождение суммы цифр
// заданного натурального числа.
#include <iostream.h>
class Cifra{ // класс Cifra
long chislo;
int sum;
public:
Cifra(long n); // конструктор
summa(); // функция получения суммы цифр числа
show(); // функция вывода суммы цифр числа
};
Cifra::Cifra(long n){ // определение конструктора
chislo = n; // инициализация переменной chislo
}
Cifra::summa(){ // определение функции summa()
sum = 0;
long rab = chislo;
while(rab){ // цикл для выделения цифр числа
sum = sum + rab % 10; // и их суммирования
rab = rab / 10;
}
}
Cifra::show(){ // определение функции show()
cout<<"summa cifr= "<<sum<<endl;
}
int main(){ // функция main()
system (“cls”);
long n;
cout<<"vvedi chislo: ";
cin>>n; // например, введём 31456
Cifra ob(n); // создание объекта ob типа Cifra
ob.summa(); // вызов функции summa()
ob.show(); // summa cifr = 19
system(“pause”); // задержка экрана
return 0;
}
// Пример 1.3. Определение класса для нахождения суммы цифр
// натуральных чисел из диапазона от n до m
#include <iostream.h>
class Cifra{
long n, m; // определение диапазона чисел
int sum;
public:
Cifra (long x, long y); // конструктор
summa(); // функция для суммы цифр числа
show(int a); // функция вывода суммы цифр числа
};
Cifra::Cifra(long x, long y){ // определение конструктора
n = x; m= y; // инициализация n, m
}
Cifra::summa(){ // определение функции summa()
for(long i = n; i < m; i++){
sum = 0;
long rab = i;
while(rab){ // цикл для выделения цифр числа
sum=sum+rab%10; // и их суммирования в реоеменной
rab/=10; // класса sum
}
show(i);
}
}
Cifra::show(int i){ // определение функции show()
cout<<"summa cifr chicla "<<i<<" = "<<sum<<endl;
}
int main(){ // функция main()
long n, m;
cout<<"vvedi chisla diapazona: ";
cin>>n>>m; //ввод чисел для диапазона
Cifra ob(n, m); // создание объекта ob типа Cifra
ob.summa(); // вызов функции summa()
system(“pause”); // задержка экрана
return 0;
}
// Пример 1.4. Определить, образуют ли цифры заданного натурального
// числа возрастающую последовательность. Создать класс.
#include <iostream.h>
class poslCifr{ // класс poslCifr
int a;
public:
poslCifr(int n);
show();
vozr();
};
poslCifr:: poslCifr (int n){ // определение конструктора
a = n; // инициализация
}
poslCifr::show(){
cout<<" a= "<<a<<endl;
}
poslCifr::vozr(){
int r = a; int flag = 0;
int cpr, csl; // переменные для запоминания цифр
cpr = r%10; r = r / 10;
while (r>0){
csl = r%10;
if(csl > cpr){flag = 1; break;} // знак > так как выделение цифр
r = r / 10; // начинается с последней цифры
cpr = csl;
}
if(flag == 0)cout<<"uporaydocheni"<<endl;
else cout<<"no uporaydocheni"<<endl;
}
int main(){ // функция main()
int chislo;
cout<<"vvedi chislo: ";
cin>>chislo; //ввод числа
poslCifr ob(chislo); // создание объекта ob
ob.show(); // вызов функции show()
ob.vozr(); // вызов функции vozr()
system("pause"); // задержка экрана
return 0;
}
Определить класс для решения задач вычислительного характера, предусмотрев в нём функции для инициализации, ввода, вывода данных класса, функции для доступа к членам класса и для работы с объектами данного класса. Написать программу, которая демонстрирует использование созданного класса.
и найти сумму цифр числа, кратных k.
Цель задания – получение практических навыков создания и использования классов в случае, когда членами класса являются мссивы.
Массивы являются наиболее часто используемыми структурами данных, представляющими собой совокупность элементов одного и того же типа. Наиболее часто в программах применяются одномерные и двумерные массивы (матрицы), но язык С++ позволяет работать и с многомерными массивами.
Одномерный массив представляет собой совокупность однотипных элементов, имеющих одно имя (имя массива), при этом доступ к каждому элементу массива осуществляется по имени массива и индексу элемента. Индекс первого элемента всегда 0, далее следуют 1, 2, и т.д.
int b[10]; // объявление массива b из 10 целых чисел
int a[5] = {1, 2 ,3, 4, 5}; // объявление и иинициализация массива
int c = a[2]; // c = 3
for(int i = 0; i < 5; i++) // доступ к элементам массиваa удобнее
cout<<a[i]<<’ ‘; // всего осуществлять, пользуясь циклом for
// или *(a+i), т. к. имя массива является указателем на начало массива
Любой доступ к элементу массива, осуществляемый индексированием, может быть выполнен с помощью указателя. При этом обычно программа работает быстрее, а во многих случаях имеет место экономия памяти. Адресация элементов массива с помощью указателей выполняется следующим образом:
int a[4]; int *pa; // указатель pa на тип int
pa = a; // pa присваивается адрес массива a
for(int i = 0; i < 4; i++)
cout<<*pa++<<’ ‘; // доступ к элементам массива
// или cout<<*(pa+i); или cout<<pa[i];
Отметим, что прибавление к указателю единицы обеспечивает переход к следующему элементу массива, а также то, что имя массива является константным указателем, поэтому его нельзя изменять, но можно присваивать указателям соответствующего типа.
Чаще всего одномерные массивы используются для создания символьных строк. В С++ строка определяется как массив значений типа char, который завершается нулевым символом (‘\0’). Доступ к элементам строки осуществляется так же, как доступ к элементам любого массива.
char[] = “123456”; // инициализация строки
gets(str); // ввод строки
cout<<"stroka== "<<str<<endl; // вывод строки
for(i = 0; str[i]; i++);
cout<<str[i]; // доступ к элементам строки
Двумерный массив (матрица) – представляет собой массив одномерных массивов. Каждый элемент массива имеет два индекса – номер строки и номер столбца, которые указываются в отдельных квадратных скобках. Например:
int b[3][4]; // объявление двумерного массива
int a[2][2] = {{1, 2}, // явная инициализация 0-й строки
{3, 4}}; // явная инициализация 1-й строки
for(int i = 0; i < 3; i++) // запонение и обработку матриц производят,
for(int j = 0; j < 4; j++) // пользуясь вложенными циклами
cout<<a[i][j]<<’ ‘; // доступ к элементам массива или *(a[i]+j)
Статические массивы – это массивы с фиксированной размерностью, элементы таких массивов занимают сплошой участок в памяти компьютера и располагаются последовательно друг за другом, причём элементы двумерного массива размещаются по строкам. Для создания, просмотра и обработки массивов используются циклы (для двумерных массивов – вложенные).
Динамические массивы – это массивы, для которых выделяется память и определяется размер во время выполнения программы. Создаётся динамический массив с помощью операции new и указателя. После завершения использования массива выделенную под массив память освобождают с помощью операции delete. Явно инициализировать динамические массивы нельзя.
Создание одномерного динамического массива:
int n; cin>>n; // ввод размерности массива n
int *p; // объявление указателя p на целый тип
p= new int[n]; // выделение памяти для массива
delete [] p; // удаление выделенной памяти
for(int i = 0; i < 4; i++)
cout<<p[i]<<’ ‘; // доступ к элементам массива с индексом i
// или *(p+i)
Если с помощью операции new невозможно выделить требуемый объём памяти, то операция new возвратит нулевой указатель. ого массива с индексом i допускаются выражения.
Создание динамической строки :
char *pstr; cin>> len;
pstr = new char[len];
delete [] pstr; // удаление строки
Создание двумерного динамического массива из n строк и m столбцов:
int n, m; int ** p; // указатель p на массив указателей
cin>>n; cin>>m;
p = new *int[n]; // память под массив указателей на строки
for(int i; i < n; i++)
p [i] = new int[m]; // выделение памяти для каждой строки
for(int i = 0; i < 3; i++) // доступа к элементам массива
for(int j = 0; j < 4; j++)
cout<< p [i][j]<<’ ‘ // или *( p [i] + j) или *(*( p + i) + j)
Удаление двумерного динамического массива происходит в несколько этапов:
for(int i = 0; i < n; i++) // удаление одномерных массивов (строк)
delete [] p[i];
delete [] p; // удаление массива указателей на строки
Следует помнить, что выделенная память для двумерного динамического массива не представляет собой сплошной участок, поскольку она выделяется несколькими операциями new.
// Пример 2.1. Определение класса для работы с одномерным массивом
// (статическим). Нахождение суммы элементов массива.
#include <iostream.h>
const int max_n = 50;
class Massiv{ // определение класса Massiv
int a[max_n]; // объявление массива a
int n; // размерность массива
int sum; // сумма элементов массива
public:
Massiv(int k); // конструктор с параметром
summa(); // функция нахождение суммы элементов массива
show(); // функция вывода массива
};
Massiv::Massiv(int k){ // определение конструктора
n = k; // инициализация n
for(int i = 0; i < n; i++) // инициализация массива
a[i] = random(n); // случайными числами
}
Massiv::summa(){ // определение функции summa()
sum = 0;
for(int i = 0; i < n; i++)
sum = sum + a[i];
}
Massiv::show(){ // определение функции show()
cout<<"Massiv a: ";
for(int i = 0; i < n; i++){
cout.width(4); cout<<a[i]<<" ";
}
cout<<endl;
cout<<"Summa elementov massiva a= "<<sum<<endl;
}
main(){
int kol;
cout<<"Vvedi chislo elementov:"; cin>>kol;
Massiv ob(kol); // создание объекта ob типа Massiv
ob.summa(); // вызов функции summa()
ob.show(); // вызов функции show()
system("pause"); // задержка экрана
}
Результат:
Vvedi chislo elementov:6
massiv a: 2 4 0 2 0 0
Summa elementov massiva a = 8
// Пример 2.2. Определение класса для работы с одномерным массивом
// (динамическим). Нахождение суммы элементов массива.
#include <iostream.h>
class Massiv{ // определение класса Massiv
int n;
int *p; // указатель на тип int
int sum;
public:
Massiv(int k); // конструктор
~Massiv(){delete [] p;} // деструктор определён в классе
summa();
show();
};
Massiv::Massiv(int k){ // определение конструктора
n = k; // инициализация n
p = new int[n]; // выделение динамической памяти под массив
if(!p){
cout<<"no memory"<<endl;
exit(1);
}
for(int i = 0; i < n; i++) // инициализация массива
p[i] = random(n);
}
Massiv::summa(){ // определение функции summa()
sum = 0;
for(int i = 0; i < n; i++)
sum = sum + p[i];
}
Massiv::show(){ // определение функции show()
cout<<"Massiv=="<<endl;
for(int i = 0; i < n; i++){
cout.width(4);
cout<<p[i]<<" ";
}
cout<<"\n Summa elementov massiva = "<<sum<<endl;
}
main(){
int kol;
cout<<"Vvedi chislo elementov:"; cin>>kol;
Massiv ob(kol); // создание объекта ob типа Massiv
ob.summa();
ob.show();
system("pause"); // задержка экрана
}
Результат:
Vvedi chislo elementov:7
Massiv==
3 2 1 4 4 0 1 6
Summa elementov massiva = 21
// Пример 2.3. Определение класса для работы с двумерным статическим // массивом. Нахождение максимального элемента в каждой строке.
#include <iostream.h>
const int max_n = 10;
class Matr{ // определение класса Matr
int a[max_n][max_n]; // матрица a
int b[max_n]; // одномерный массив b
int n; // число строк в матрице a
int m; // число столбцов в матрице a
public:
Matr(int k, int l); // конструктор
max_strok(); // функция поиска максимального элемента
show_matr(); // функция вывода матрицы
show_mas(); // функция вывода массива
};
Matr::Matr(int k, int l){ // определение конструктора
n = k; m = l;
for (int i = 0;i < n; i++) // инициализация матрицы
for (int j = 0; j < m; j++)
a[i][j] = random(n*m);
}
Matr::max_strok(){ // определение функции max_strok()
int max;
for(int i = 0; i < n; i++){
max = a[i][0];
for (int j = 0; j < m; j++)
if( a[i][j] > max) max = a[i][j];
b[i] = max; // максимальный элемент cтроки –> b[i]
}
}
Matr::show_matr(){ // определение функции show_matr()
cout<<"Matrix== "<<endl;
for (int i = 0; i < n; i++){
for (int j = 0; j < m; j++){
cout.width(4); cout<<a[i][j]<<" ";
}
cout<<endl;
}
}
Matr::show_mas(){ // определение функции show_mas()
cout<<"Massiv b== "<<endl;
for (int i = 0; i < n; i++)
cout<<b[i]<<" ";
cout<<endl;
}
main(){ // функция main()
int n, m;
cout << "Vvedi kolichestvo strok i stolbcov "; cin>>n>>m;
Matr ob(n, m); // создание объекта ob типа Matr
ob.show_matr();
ob.max_strok(); ob.show_mas();
system("pause"); // задержка экрана
}
Результат:
Vvedi kolichestvo strok i stolbcov: 3 4
Matrix==
2 1 0 2
0 0 0 0
0 2 2 0
Massiv b==
2 0 2
// Пример 2.4. Определение класса для работы с динамическим
// двумерным массивом. Использование деструктора.
#include <iostream.h>
#include <stdlib.h>
class Matr{
int **a; // указатель на массив указателей
int n, m; // размерности матрицы
public:
Matr(int k, int l); // конструктор
~Matr(); // деструктор
void show_matr(); // функция вывода матрицы
};
Matr::Matr(int k, int l){ // определение конструктора
n = k; m = l;
a = new int*[n]; // память под массив указателей
if(a == NULL){
cout<<"No memory"<<endl;
exit(1);
}
for(int i = 0;i < n; i++){ // цикл для выделения памяти
a[i] = new int[m]; // для каждой строки матрицы
if(a[i] == NULL){
cout<<"No memory"<<endl;
exit(1);
}
for(int j = 0; j < m; j++) // заполнение i-ой строки
*(a[i]+j) = random(100); // или a[i][j] = random(100);
}
}
Matr::~Matr(){ // определение деструктора
for(int i = 0; i < n; i++)
delete [] a[i]; // удаление строк
delete [] a; // удаление массива указателей
}
void Matr::show_matr(){ // определение show_matr()
cout<<"Matrix== "<<endl;
for (int i = 0; i < n; i++){
for (int j = 0; j < m; j++){
cout.width(4);
cout<<a[i][j]<<" ";
}
cout<<endl;
}
}
main(){
int n, m;
cout<<"Vvedi n, m: "; cin>>n>>m;
Matr ob(n, m); // создание объекта ob типа Matr
ob.show_matr(); // вызов функции show_matr()
system("pause"); // задержка экрана
}
Результат:
Vvedi n, m: 3 4
Matrix==
40 20 12 76
88 72 92 12
13 60 77 19
// Пример 2.5. Определение класса для работы с символьным массивом
#include <iostream.h>
class Stroka{
char* str;
int len;
public:
Stroka (char* s);
void show();
};
Stroka::Stroka(char* s){
len=strlen(s);
str=s;
str[0]='x';
}
void Stroka::show(){
cout<<"str== "<<str<<endl;
cout<<"len== "<<len<<endl;
}
main(){
char s[11];
cout<<" Vvedi stroku"<<endl;
gets(s);
cout<<" v main stroka=="<<s<<endl;
// strcpy(s, "1234566");
Stroka ob(s);
ob.show();
system("pause"); // задержка экрана
}
// Пример 2.6. Определение класса для работы с
// динамическим символьным массивом
#include <iostream.h>
class Stroka{
char* str;
int len;
public:
Stroka (char* s);
~Stroka();
show();
};
Stroka::Stroka(char* s){
len = strlen(s);
str=new char[len+1];
strcpy(str, s);
str[0] = 'x';
}
Stroka::~Stroka(){
delete []str;
}
Stroka::show(){
cout<<"show str== "<<str<<endl;
cout<<"show len== "<<len<<endl;
}
main(){
int n = 10;
char *s = new char[n];
cout<<"vvedi stroku: ";
gets(s);
// strcpy(s, "1234566");
Stroka ob(s);
ob.show();
cout<<"v main s== "<<s<<endl;
delete []s;
system("pause");
}
Определить класс для решения задач, использующих одномерные массивы или двумерные массивы предусмотрев в нём функции для инициализации, ввода, вывода переменных, массивов, объявленных в классе, функции для доступа к членам класса и для работы с объектами данного класса. Написать программу, которая демонстрирует использование созданного класса для работы с одномерными массивами или двумерными массивами (статическими, динамическими).
Цель задания – изучение приёмов объектного программирования для работы с массивами объектов, указателями на объекты и массивы объектов.
Массив объектов создаётся аналогично массиву переменных стандартного типа:
myClass a[4]; // одномерный массив объектов a типа myClass
myClass b[2][4]; // двумерный массив объектов b типа myClass
Если класс содержит конструктор, массив объектов может быть проинициализирован, причём конструктор будет вызван столько раз, сколько элементов содержит массив:
myClass ob[4] = {1, -2, 5, 6};
Известно, что доступ к членам объекта осуществляется с помощью операции “точка” (.). Однако доступ к члену объекта можно получить и через указатель на этот объект. В этом случае используется операция стрелка (->):
myClass ob; // объект типа myClass
myClass *uk; // указатель на тип myClass
uk = &ob; // указателю присваивается адрес объекта ob
ob.set(10); // вызов функции через операцию “точка”
uk–>set(10); // вызов функции через операцию “стрелка”
При работе с массивом объектов также можно использовать указатели:
myClass ob[5]; // массив объектов типа myClass
myClass *p; // указатель на тип myClass
p = ob; // указатель на нулевой элемент массива объектов ob
p++; // указатель на следующий элемент массива
p--; // указатель на предыдущий элемент массива
С++ содержит специальный указатель this, который автоматически передаётся любой функции класса при её вызове и указывает на объект, генерирующей вызов. При этом *this представляет сам объект. Дружественным функциям указатель this не передаётся.
Динамический объект можно создать с помощью указателя и операцию new:
Samp*uk = new Samp(4, 6);
При размещении объекта автоматически вызывается его конструктор, и объекту передаются значения 4 и 6.
Для разрушения динамического объекта используется операция delete, который может помещаться в деструкторе: delete uk;
Динамический массив объектов создаётся аналогично обычному динамическому масcиву:
Samp *p; // указатель на тип Samp
p = new Samp[4]; // одномерный динамический массив объектов
Конструктор будет вызван четыре раза, если он присутствует в классе.
Динамический массив объектов нельзя явно инициализировать, поэтому наряду с другими конструкторами в классе должен присутствовать конструктор по умолчанию.
Для освобождения памяти, занимаемой динамическим массивом объектов, используется операция delete. Например, для удаления динамически размещённого одномерного массива объектов следует использовать следующую форму операции delete:
delete [ ] p;
Определить класс, предусмотрев в нём функции для инициализации, ввода, вывода переменных членов класса, функции для доступа к членам класса. Сформировать динамический массив объектов данного класса и определить функции для работы с созданным массивом. Написать программу, которая с помощью меню демонстрирует использование функций созданного класса.
// Пример 4.1. Создается класс Student. Формируется динамический массив
// объектов данного класса. При тестировании программы на экран выводится:
// сформированный список студентов; список студентов заданного факультета;
// список студентов для заданных факультета и курса.
#include <cstring.h>
#include <iostream.h>
#include <iomanip.h>
struct date{ // структура - дата рождения
int mon;
int year;
};
const size=10;
class Student{ // класс Student
char fam[size];
date t;
char fac[size];
int kurs;
public:
Student();
char* getfac();
int getkurs();
show();
};
Student::Student(){
cout << "Input fam\n"; cin >> fam;
cout << "Input date of birthday\n";
cout << "Month:" << endl; cin >> t.mon;
cout << "Year:" << endl; cin >> t.year;
cout << "Input facultet\n"; cin >> fac;
cout << "Input kurs\n"; cin >> kurs;
}
//======= show =================
Student::show(){
cout<<"| "<<setw(9)<<fam<<" | "<<setw(4)<<t.mon<<" | ";
cout<<setw(5)<<t.year<<" | "<<setw(4)<<fac<<" | "<<setw(2);
cout<<kurs<<" |"<<endl;
}
//======= getfac =================
char* Student::getfac(){
return fac;
}
//======= getkurs =================
int Student::getkurs(){
return kurs;
}
vivod(Student *spis, int n); // вывод списка студентов
spisfac(Student *spis,int n); // список студентов заданного факультета
spisfackurs(Student *spis,int n);// список студ. заданных фак. и курса
shapka();
main(){
Student *spis;
int n, q;
cout<<"Input a number of students: "<< endl; cin>>n;
spis = new Student[n]; //динамический массив объектов
while(true){
// system("cls");
cout<<"viberite nomer comandi(1-4)"<<endl;
cout<<"1-write display "<<endl;
cout<<"2-spisok fakulteta "<<endl;
cout<<"3-spisok fakulteta i kursa"<<endl;
cout<<"4-vixod"<<endl;
cin>>q;
switch(q)
{
case 1:vivod (spis,n);break;
case 2:spisfac(spis,n);break;
case 3:spisfackurs(spis,n);break;
case 4:exit(1);
}
}
cout << "Press any key !" << endl;
delete [] spis;
system("pause");
}
//=====вывод шапки=====
shapka(){
cout<<"|--------------------------------------------|"<<endl;
cout<<"| Family | month | year | fac |kurs|"<<endl;
cout<<"|--------------------------------------------|"<<endl;
}
//=====список всех студентов==========================
vivod(Student *spis, int n){
shapka();
for(int i = 0; i < n; i++)
spis[i].show();
}
//=======список студентов заданного факультета========
spisfac(Student *spis, int n){
int i;
char fac[size];
cout<<"vivod studentov zadannogo faculty"<<endl;
cout << "Input faculty" << endl;
cin >> fac;
shapka();
for( i = 0; i < n; i++)
if(strcmp(spis[i].getfac(),fac)==0)spis[i].show();
}
//=======список студентов заданных факультета и курса==
spisfackurs(Student *spis, int n){
int i,k;
char fac[size];
cout<<"vivod studentov zadannogo faculty i course"<<endl;
cout << "Input faculty" << endl;
cin >> fac;
cout << "Input the course" << endl;
cin >> k;
shapka();
for( i = 0; i < n; i++)
if ((strcmp(spis[i].getfac(),fac)==0)&&(spis[i].getkurs()==k))
spis[i].show();
}
Abiturient: Фамилия, Имя, Отчество, Адрес, Оценки. Вывести:
Aeroflot: Номер рейса, Пункт назначения, Время вылета, Информация о наличии свободных мест. Вывести:
Automobile: Марка автомобиля, Год выпуска, Номер, Фамилия владельца. Вывести:
список автомашин не старше заданного года выпуска;
список автомашин заданной марки, упорядочив его по году выпуска (фамилии владельца).
сведения об автомашинах в алфавитном порядке.
Boots: Артикул, Наименование, Размер, Количество пар, Стоимость одной пары. Артикул начинается с буквы D для дамской, с М – для мужской, с С – для детской обуви. Вывести:
информацию о наличии и стоимости обуви артикула ХХ;
списки дамской, мужской и детской обуви заданного размера, имеющиеся в наличии, и число пар каждой модели;
список наименований всей обуви в алфавитном порядке.
Book: Автор, Название, Издательство, Год. Вывести:
Bus: Фамилия водителя, Номер автобуса, Номер маршрута, Марка, Год начала эксплуатации. Вывести:
Bus: Номер автобуса, Фамилия водителя, Возраст водителя, Номер маршрута.Вывести:
списки автобусов, находящихся в парке, и автобусов, находящихся на маршруте, упорядочив их в порядке возрастания номеров автобусов (номеров маршрутов);
средний возраст водителей автобусного парка и фамилии самого старшего и самого младшего водителей;
список водителей в алфавитном порядке и их возраст.
Baggage: Фамилия пассажира, Количество мест багажа и Вес каждого места багажа. Вывести:
список пассажиров в алфавитном порядке;
фамилию пассажира с наибольшим количеством мест багажа;
фамилию пассажира с наименьшим весом багажа.
Bank: Номер филиала сбербанка, Номер лицевого счёта вкладчика, Фамилия вкладчика, Размер вклада. Вывести:
для каждого филиала списки вкладчиков, упорядоченные по алфавиту и по сумме вклада
для каждого филиала справку об общей сумме вкладов и средний размер вклада.
Customer: Фамилия, Имя, Отчество, Адрес, Телефон, Номер кредитной карточки. Вывести:
список покупателей в алфавитном порядке;
список покупателей, у которых номер кредитной карточки находится в заданном интервале.
Contest: Название страны, Вид спорта, Фамилия и Имя призёра, Тип медали (золото, серебро, бронза). Вывести:
список призёров страны NNN в алфавитном порядке;
список призёров, упорядоченный по названию страны;
списки призёров мужчин и женщин по типу медали.
Championship: Название команды, Количество забитых мячей, Количество пропущенных мячей, Количество выигрышей. Вывести:
список команд в порядке убывания забитых мячей;
список команд в порядке убывания количества выигрышей;
File: Имя файла, Тип файла, Дата создания, Количество обращений к файлу. Вывести:
список файлов (имя, тип), созданных ранее указанной даты;
список файлов, упорядоченный по имени (типу, дате создания, количеству обращений);
список файлов заданного типа по возрастанию количества обращений к ним.
House: Фамилия владельца, Адрес, Этаж, Количество комнат, Площадь. Вывести:
список квартир, имеющих заданное число комнат;
список квартир, отсортированный по размеру площади;
список жильцов в алфавитном порядке;
список жильцов, имеющих площадь, превосходящую заданную.
Library: Шифр темы, Шифр книги, Фамилия автора, Название книги, Год издания. Вывести:
список книг по заданной теме, выпущенных после заданного года издания;
список книг заданного автора в порядке возрастания года издания;
список книг для заданного года издания, расположив в алфавитном порядке фамилии авторов.
Phone: Фамилия, Адрес, Номер, Время междугородних разговоров. Вывести:
Phone: Фамилия абонента, Адрес, Номер телефона. Вывести:
список абонентов в порядке возрастания номеров телефонов;
список жильцов, фамилии которых начинаются на заданную букву, имеют телефон в доме, адрес которого вводится;
список телефонов, начинающихся с цифры Х.
Person: Фамилия, Адрес, Образование, Год рождения. Вывести:
Product: Наименование, Цена, Срок хранения. Вывести:
Student: Фамилия, Имя, Отчество, Адрес, Факультет, Курс. Вывести:
Student: Фамилия и Имя студента, Курс, Группа, Оценки, полученные в сессию. Вывести:
для каждого курса список отличников в алфавитном порядке
для заданного курса список студентов в порядке убывания среднего балла.
для заданных курса список студентов, имеющих неудовлетворительные оценки;
список студентов, сдавших все дисциплины.
Student: Фамилия и Имя студента, Курс, Группа, Место проживания. Вывести:
список студентов в алфавитном порядке, проживающих в общежитии;
список студентов по курсам, нуждающихся в общежитии;
для каждого курса и группы список и количество студентов, проживающих в своей квартире, в общежитии и на квартире.
Student: Фамилия и Имя студента, Курс, Группа, Оценки, полученные в сессию. Вывести:
список студентов заданного курса и группы, имеющих неудовлетворительные оценки;
список студентов заданного курса, средний балл которых больше четырёх, упорядочив их по алфавиту.
Swimming: Номер заплыва, Дистанция, Фамилия участника и Время. Вывести:
Train: Пункт назначения, Номер поезда, Время отправления, Число общих мест, Купейных, Плацкартных. Вывести:
Worker: Шифр цеха, Фамилия рабочего, Пол, Год рождения, Образование, Год поступления на работу. Вывести:
список работников моложе 35 лет, не имеющих среднего образования;
для каждого цеха средний возраст мужчин и женщин;
для каждого цеха список работников со стажем более 5 лет в алфавитном порядке.
Worker: Фамилия, Должность, Стаж работ, Зарплата. Вывести:
Цель задания – изучение приёмов объектного программирования с использованием операторных функций, обеспечивающих перегрузку стандартных операций для работы с объектами данного класса.
В С++ операции, также как и функции, можно перегружать. Перегружаются почти все операции, за исключением некоторых: ., .*, ::, :?, sizeof.
Для перегрузки операции задаётся оператор-функция (операторная функция), которая является либо членом класса, либо дружественной классу, для которого она задана:
тип имя_класса::operator #(список параметров){
// …
}
Здесь вместо знака # ставится знак перегружаемой операции.
Существуют некоторые ограничения на перегрузку операций: нельзя менять приоритет операций; нельзя менять число операндов операций; нельзя создавать новые операции; оператор-функции не могут иметь аргументов по умолчанию.
Бинарные операции перегружается как функции класса с одним параметром или как дружественные функция с двумя параметрами. Один из этих параметров должен быть либо объектом класса, либо ссылкой на объект этого класса.
Унарные операции имеют один операнд, поэтому унарная операция класса перегружается как функция без параметров или как дружественная функция с одним параметром. Этот параметр должен быть или объектом, или ссылкой на объект этого класса.
Ссылка на некоторый объект может рассматриваться как указатель, который при работе с ним всегда разыменовывается. Для определения ссылки применяется унарная операция &. Ссылка не создаёт копию объекта, а лишь является другим именем объекта. Чаще всего ссылки используются для передачи аргументов в функции.
Операция присваивания перегружается для случая, когда нежелательно побитовое копирование, но только как функция класса. Функция оperator=() возвращает *this, так как функция возвращает объект, которому присваивается значение, т. е. левый операнд в операторе изменяется. Это позволяет выполнить любую цепочку присваиваний (ob1 = ob2 = ob3).
Перегрузка операций ввода-вывода “>>” и “>>” в С++ предусмотрена для выполнения ввода-вывода объектов класса.
Для вывода объектов создаётся оператор-функция (функция вставки символов в объект), общий формат которой имеет вид:
ostream& operator<<(ostream &stream, имя_класса obj){
// …
return stream;
}
Первый параметр в функции является ссылкой на объект типа ostream. Это означает, что поток stream должен быть потоком вывода. Второй параметр получает выводимый объект (он, если это нужно, тоже может быть параметром-ссылкой). Функция возвращает ссылку на объект типа ostream что позволяет использовать операцию << в ряде последовательных выражений вывода (cout<<ob1<<ob2<<ob3).
Для ввода объектов создаётся оператор-функция (функция извлечения символов из потока), формат которой имеет следующий вид:
istream& opepator>>(istream &stream, имя_класса &obj){
//…
return stream;
}
Первый параметр – ссылка на объект типа istream, т. е. поток stream должен быть потоком ввода. Второй параметр – ссылка на объект, получающий вводимую информацию. Функция возвращает ссылку на объект типа istream, что позволяет использовать операцию >> в ряде последовательных выражений ввода (cin>>ob1>>ob2>>ob3).
Следует помнить, что пользовательские функции ввода-вывода не должны быть членами класса, для ввода-вывода данных которого они предназначены. Они могут быть дружественными функциями этого класса или просто независимыми функциями.
// Пример 4.1. Перегрузка операций ввода-вывода объектов.
// Нахождение наименьшего делителя числа.
#include <iostream.h>
class Factor{
int num; //число
int min_del; //наименьший делитель
public:
Factor(){};
delit();
friend ostream& operator<<(ostream &stream, Factor ob);
friend istream& operator>>(istream &stream, Factor &ob);
};
Factor::delit(){
int n;
int i = num;
for(n = 2; n < (i/2); n++)
if(i%n == 0) break;
if(n < (i/2)) min_del = n;
else min_del = 1;
}
istream& operator>>(istream &stream, Factor &ob){
cout<<"Vvedi chslo:";
stream>>ob.num;
return stream;
}
ostream& operator<<(ostream &stream, Factor ob){
stream << endl;
stream << ob.min_del<< " min delitel chisla ";
stream << ob.num << '\n';
return stream;
}
main(){ // функция main()
Factor ob; // создание объекта ob
cin>>ob; // ввод объекта ob
ob.delit(); // вызов функции del()
cout << ob; // вывод объекта ob
system(“pause”);
}
Результат:
Vvedi chslo:12
2 min delitel chisla 12
// Пример 4.2. Перегружается операция + для сложения объектов,
// члены класса – одномерный массив и его размерность.
// Объект в функцию operator+() передаётся по ссылке, возвращается
// по значению. Возвратить ссылку на объект функция не может,
// т. к. объект temp – локальный
#include <iostream.h>
const n_max = 10;
class Mas{ // определение класса Mas
int a[n_max]; // объявление массива
int n; // размерность массива
public:
Mas(); // конструктор по умолчанию
Mas(int k); // конструктор с параметром
Mas operator+(Mas &ob); // функция operator+()
friend ostream& operator<<(ostream &stream , Mas ob);
friend istream& operator>>(istream &stream , Mas &ob);
};
Mas::Mas(int k){ // определение конструктора
n = k; // инициализация n
}
// оператор-функция ввода объекта
istream& operator>>(istream &stream , Mas &ob){
int i;
for(i = 0; i < ob.n; i++){
cout<<"Vvedi a["<<i<<"] ";
stream>>ob.a[i];
}
return stream;
}
// оператор-функция вывода объекта
ostream& operator<<(ostream &stream , Mas ob){
int i;
for(i = 0; i < ob.n; i++)
stream<<ob.a[i]<<" ";
stream<<endl;
return stream;
}
Mas Mas::operator+(Mas &ob){ // функция operator+()
Mas temp(n);
for (int i = 0; i < n; i++)
temp.a[i] = a[i] + ob.a[i];
return temp; // возврат объекта temp
}
main(){ // функция main()
int n1;
cout<<"Vvedi razmernost massiva: "; cin>>n1;
Mas ob1(n1), ob2(n1), ob3(n1); // создание объектов
cout<<"Vvedi ob1:"<<endl; cin>>ob1; // ввод объекта ob1
cout<<"Vvedi ob2:"<<endl; cin>>ob2; // ввод объекта ob2
cout<<"ob1 = "; cout<<ob1; // вывод объекта ob1
cout<<"ob2 = "; cout<<ob2; // вывод объекта ob2
ob3 = ob1 + ob2; // ob1 + ob2
cout<<"ob3 = "; cout<<ob3; // вывод объекта ob3
system(“pause”);
}
Результат:
Vvedi razmernost massiva: 5
ob1= 1 2 3 4 5 ob2= 2 3 4 5 6 ob3= 3 5 7 9 11
// Пример 4.3. Перегружается операция + для сложения объектов,
// членами которых являются динамические одномерные массивы.
// Объект в функцию operator+() передаётся по ссылке, возвращается по
// значению, поэтому объект в функцию operator=() передаётся по
// значению. Используется конструктор копии.
#include <iostream.h>
class Mas{
int *a;
int n;
public:
Mas();
Mas(int k); //конструктор с параметром
Mas(const Mas &ob); //конструктор копии
~Mas();
Mas operator+(Mas &ob); //функция operator+
Mas& operator=(Mas ob); //перегрузка =
friend ostream& operator<<(ostream& stream , Mas ob);
friend istream& operator>>(istream& stream , Mas &ob);
};
Mas::Mas(int k){
cout<<"Constructor: "<<endl;
n=k;
a=new int[n];
}
istream& operator>>(istream& stream , Mas& ob){
int i;
for(i=0;i<ob.n;i++){
cout<<"Vvedi a["<<i<<"] "; stream>>ob.a[i];
}
return stream;
}
ostream& operator<<(ostream& stream , Mas ob){
int i;
for(i=0;i<ob.n;i++)
stream<<ob.a[i]<<" ";
stream<<endl;
return stream;
}
Mas& Mas::operator=(Mas ob){
n=ob.n;
cout<<" Vxod operator= "<<endl;
for (int i=0;i<n;i++)
a[i]=ob.a[i];
cout<<" End operator= "<<endl;
return *this;
}
Mas Mas::operator+(Mas& ob){
cout<<" Vxod operator+ "<<endl;
Mas temp(ob.n);
cout<<" temp.a[i]= ";
for (int i=0;i<n;i++){
temp.a[i] = a[i] + ob.a[i];
cout<<temp.a[i]<<' ';
}
cout<<endl<<" End operator+ "<<endl;
return temp;
}
Mas::Mas(const Mas &ob){
cout<<" vxod Copy "<<endl;
n=ob.n;
a=new int[n];
for (int i=0;i<n;i++)
a[i]=ob.a[i];
cout<<" end Copy "<<endl;
}
Mas::~Mas(){
cout<<"Destructor "<<endl;
delete []a;
}
main(){
int n1;
cout<<"Vvedi razmernost massiva: "; cin>>n1;
Mas ob1(n1),ob2(n1),ob3(n1);
cout<<"Vvedi ob1"<<endl;cin>>ob1;
cout<<"Vvedi ob2"<<endl;cin>>ob2;
cout<<"ob1= "; cout<<ob1;
cout<<"ob2= "; cout<<ob2;
ob3=ob1 + ob2;
cout<<"ob3= "; cout<<ob3;
system(''pause'');
}
// Пример 4.4. Перегружаются операции ”+” и “!” для объектов-матриц:
// "+" – для сложения объектов-матриц;
// "!" – для определения кол-ва строк матрицы, не содерж. нулевых элементов.
// Перегружаются операции “>>” и “<<” для ввода/вывода объектов.
// Объект передаётся в оператор-функцию operator+() по ссылке,
// возвращается объект из функции operator+() по значению.
#include <iostream.h>
const n_max=10, m_max=10;
class Matrix{
int a[n_max][m_max];
int n, m;
public:
Matrix(int k, int l);
Matrix operator+(Matrix &ob); // функция operator+()
int operator!(); // функция operator!()
friend ostream& operator<<(ostream& stream , Matrix ob);
friend istream& operator>>(istream& stream , Matrix &ob);
};
Matrix::Matrix(int k, int l){ // определение конструктора
cout<<"Constructor "<<endl;
n=k; m=l;
}
Matrix Matrix::operator+(Matrix &ob){ // определение operator+()
cout<<" Vxod operator+()"<<endl;
Matrix temp(n, m);
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
temp.a[i][j]=a[i][j]+ob.a[i][j];
cout<<" End operator+()"<<endl;
return temp;
}
int Matrix::operator!(){ // определение operator!()
cout<<" Vxod operator!()"<<endl;
int k1=0;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if (a[i][j]==0){k1++;break;}
int kol=n-k1;
cout<<" End operator!()"<<endl;
return kol;
}
istream& operator>>(istream& stream , Matrix &ob){ // ввод объекта
for(int i=0;i<ob.n;i++)
for(int j=0;j<ob.m;j++){
cout<<"a["<<i<<" "<<j<<"] ";stream>>ob.a[i][j];
}
return stream;
}
ostream& operator<<(ostream& stream , Matrix ob){ // вывод объекта
for(int i=0;i<ob.n;i++){
for(int j=0;j<ob.m;j++){
stream.width(4);
stream<<ob.a[i][j];
}
stream<<endl;
}
stream<<endl; return stream;
}
main(){
int n, m;
cout<<"***OVERLOAD***"<<endl;
cout<<"Vvedi razmernost matrix: ";cin>>n>>m;
Matrix ob1(n,m),ob2(n,m);
cout<<"Vvedi matrix 1"<<endl;
cin>>ob1; cout<<endl<<ob1;
cout<<"Vvedi matrix 2"<<endl;
cin>>ob2; cout<<endl<<ob2;
Matrix ob3(n,m);
ob3=ob1+ob2;
cout<<"Summa of matrix..."<<endl;
cout<<ob3;
int kol; kol=!ob1;
cout<<"kol="<<kol<<endl;
kol=!ob2; cout<<"kol="<<kol<<endl;
system("pause");
}
// Пример 4.5. Перегружается операция “+” для объектов-матриц,
// использующих динамическую память. В функцию operator+()
// объект передаётся по ссылке, возвращается объект по значению,
// поэтому в функцию operator=() объект передаётся по значению.
//Используется конструктор копии.
#include <iostream.h>
class Matrix{ // определение класса Matrix
int **a; //указатель на массив указателей
int n, m;
public:
Matrix(int k, int l );
~Matrix();
Matrix(const Matrix &ob); //конструктор копии
Matrix operator+(Matrix &ob); //функция operator+()
Matrix& operator=(Matrix ob); //функция operator=()
friend ostream& operator<<(ostream &stream , Matrix &ob);
vvod(); //функция ввода матрицы
};
Matrix::Matrix(int k, int l){ // конструктор
n = k; m = l;
a = new int *[n];
for(int i = 0; i < n; i++)
a[i] = new int[m];
}
Matrix::~Matrix(){ // деструктор
for(int i = 0; i < n; i++)
delete []a[i];
delete []a;
}
Matrix::Matrix(const Matrix &ob){ // конструктор копирования
a = new int*[ob.n];
for(int i = 0; i < ob.n; i++)
a[i] = new int[ob.m];
for(int i = 0; i < ob.n; i++)
for(int j = 0; j < ob.n; j++)
a[i][j] = ob.a[i][j];
n = ob.n; m = ob.m;
}
Matrix Matrix::operator+(Matrix &ob){ // функция operator+()
Matrix temp(n,m);
for(int i = 0; i < n; i++)
for(int j = 0; j < m; j++)
temp.a[i][j] = a[i][j]+ob.a[i][j];
return temp;
}
Matrix& Matrix::operator=(Matrix ob){ // функция operator=()
for(int i = 0; i < n; i++)
for(int j = 0; j < m; j++)
a[i][j] = ob.a[i][j];
return *this;
}
ostream &operator<<(ostream &stream , Matrix &ob){ // вывод
for(int i = 0; i < ob.n; i++){
for(int j = 0; j < ob.m; j++)
{
stream.width(4);
stream<<ob.a[i][j];
}
stream<<endl;
}
return stream;
}
Matrix::vvod(){ // функция ввода vvod()
cout<<"Vvedi matrix"<<endl;
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++){
cout<<"a["<<i<<" "<<j<<"] ";cin>>a[i][j];
}
}
main(){
int n, m;
cout<<"Vvedi razmernost matrix: "; cin>>n>>m;
cout<<"***OVERLOAD***"<<endl;
Matrix ob1(n, m), ob2(n, m);
ob1.vvod(); // ввод объекта ob1
cout<<ob1; // вывод объекта ob1
ob2.vvod(); // ввод объекта ob2
cout<<ob2; // вывод объекта ob2
Matrix ob3(n, m);
ob3 = ob1 + ob2; // ob3 = ob1 + ob2
cout<<"Summa of matrix== "<<endl; cout<<ob3;
system("pause");
}
Определить класс, который должен включать в себя конструктор, деструктор, операторные функции, обеспечивающие перегрузку стандартных операций для работы с объектами данного класса. Для указанного класса также перегрузить операции << и >> для ввода и вывода объектов.
Написать программу, демонстрирующую концепцию перегрузки операторов.
Цель задания – получение практических навыков создания и построения иерархии классов, изучение виртуальных функций и использование их для реализации динамического полиморфизма.
Определить базовый класс и наследующие его производные классы.
Для проверки функционирования созданных классов написать программу, использующую эти классы. Предусмотреть передачу аргументов конструкторам базового класса, использование виртуальных функций для реализации динамического полиморфизма.
В заданиях перечисляются только обязательные переменные и функции класса. Можно задавать дополнительные переменные и функции, если они не отменяют обязательные и обеспечивают дополнительные удобства при работе с данными классами.
// Пример 5.1. Определить базовый класс Строка, предусмотрев ввод,
// вывод строки, получение длины строки, очистку строки.
// Определить производный класс Десятичная Строка. Предусмотреть
// ввод, вывод десятичных чисел, проверку, является ли введённая
// строка десятичным числом, если нет - присвоить ей нулевое значение,
// сравнение двух чисел.
#include<iostream.h>
#include<conio.h>
#include<string.h>
#define N 100
class Stroka { // определение базового класса Stroka
protected:
char str[N];
public:
Stroka (){str[0]='\0'; }
virtual void create(); // создание строки
show(); // вывод строки
int length(); // определение длины строки
clear(); // очистка строки
};
class DecStroka : public Stroka { // опр. производного класса DecStroka
public:
void create(); // создание строки
bool isnumber(); // проверка строки на число
int operator==(DecStroka ); // сравнение двух строк
};
int menu(); // меню
Stroka::create() { // создание строки базового класса
cout<<"Input your stroky: ";
flushall(); gets(str);
}
Stroka::show(){ // вывод строки
int i=0;
cout<<"Your stroka: (";
cout<<str; cout<<')'<<endl;
}
int Stroka::length(){ // определение длины строки
int i=0;
while(!str[i]=='\0') i++;
return i;
}
Stroka::clear(){ // очистка строки
*str='\0';
cout<<"Your stroka ochichena "<<endl;
}
DecStroka::create(){ // создание строки производного класса
char s[N]; char c;
cout<<"Do you want your number will be positive or negative ? (+/-) ";
cin>>c;
str[0]=c; str[1]='\0';
cout<<"Input your decstroky: ";
flushall();
gets(s); strcat(str, s);
}
bool DecStroka::isnumber(){ // проверка строки на число
bool pr(true);
int k=0; int l(0);
if(str[0]=='+'||str[0]=='-') k=1;
l = length(); // вызов length() базового класса
for(int j=k;j<l;j++) {
if(str[j]>='0'&& str[j]<='9') pr=true;
else{ pr=false; break; }
}
if(!pr) { cout<<"Your stroka isn't a number "<<endl;
clear(); }
else cout<<"Your stroka is a number "<<endl;
show(); // вызов show() базового класса
return pr;
}
int DecStroka::operator==(DecStroka ob){ // сравнение двух строк
return !strcmp(str,ob.str);
}
int main (){
int m, l=0;
Stroka *p; // указатель на базовый класс Stroka
Stroka ob; // объект класса Stroka
DecStroka d_ob1,d_ob2,d_ob3,d_ob4;
p=&ob; // указатель установлен на объект базового класса
while (1){
m=menu();
switch (m){
case 1: clrscr(); p->create(); getch (); break;
case 2: clrscr(); ob.show(); getch(); break;
case 3: clrscr(); l = ob.length();
cout<<" dlina stroki = "; cout<<l; getch(); break;
case 4: clrscr(); p->clear(); getch(); break;
case 5: clrscr(); p = &d_ob1; p->create(); getch(); break;
case 6: clrscr(); d_ob1.show(); getch(); break;
case 7: clrscr(); d_ob1.isnumber(); getch(); break;
case 8: clrscr();
cout<<"Input two number "<<endl<<endl;
d_ob1.create(); d_ob2.create();
if (d_ob1.isnumber()&& d_ob2.isnumber())
if (d_ob1==d_ob2) cout<<"Your chicla ravnu "<<endl;
else cout<<"Your chicla ne ravnu "<<endl;
else cout<<"Your stroka isn't a number "<<endl;
getch(); break;
case 9: clrscr(); exit(1); break;
}
}
return 0;
}
int menu(){ // меню
int m;
do{
clrscr();
cout<<" 1: Sozdat stroky "<<endl;
cout<<" 2: Show stroky "<<endl;
cout<<" 3: Opredelit dliny stroki"<<endl;
cout<<" 4: Ochistit stroky "<<endl;
cout<<" 5: Sozdat dec_stroky "<<endl;
cout<<" 6: Show dec_stroky "<<endl;
cout<<" 7: Opredelit if your sroka is a number "<<endl;
cout<<" 8: Proverit dva chisla na ravenstvo "<<endl;
cout<<" 9: Exit "<<endl;
cin>>m;
}while(m<1 || m>9);
return m;
}
В производном классе переопределить указанные операции для квадратных матриц, добавив следующие операции:
В производном классе BoolVector (компоненты вектора принимают значения из множества {0,1}) переопределить указанные операции для Vector, добавив следующие операции:
В производном классе ТРОИЧНЫЙ ВЕКТОР (компоненты вектора принимают значения из множества {0,1,2}) переопределить указанные операции для Vector, добавив следующие операции:
В производном классе БУЛЕВА МАТРИЦА переопределить указанные операции, добавив следующие операции:
В производном классе Строка переопределить указанные операции, добавив следующие операции:
В производном классе Строка переопределить указанные операции, добавив следующие операции:
В производном классе Строка_Идентификатор переопределить указанные операции, добавив следующие операции:
В производном классе Битовая_Строка переопределить указанные операции, добавив следующие операции:
В производном классе Десятичная_Строка переопределить указанные операции, добавив следующие операции:
В производном классе Комплексное_число (Строка состоит из двух полей, разделённых символом i. Каждое из полей может содержать только символы десятичных цифр и символы – или +. Символы – и + могут находиться только в первой позиции числа, причём символ + может отсутствовать, в этом случае число считается положительным. Содержимое данной строки рассматривается как комплексное число, например, 35i14 ,-4i100, +3-i21) переопределить указанные операции, добавив следующие операции:
В производном классе Текст переопределить указанные операции, добавив следующие операции:
В производном классе Текст переопределить указанные операции, добавив следующие операции:
В производном классе Текст переопределить указанные операции, добавив следующие операции:
В производном классе Текст переопределить указанные операции, добавив следующие операции:
Ввести кольца целых чисел многочленов, система классов целых чисел, сравнимых по модулю. Кольцо является полем, если в нём определена операция деления, кроме деления на ноль. Рациональные числа, дробно рациональные функции.
|
[1] ЗАДАНИЕ 1. ПРОСТЕЙШИЕ КЛАССЫ И ОБЪЕКТЫ [1.1] Основные понятия [1.2] Примеры выполнения задания [1.3] Постановка задания [1.4] Варианты контрольных заданий [2] ЗАДАНИЕ 2. МАССИВЫ – ЧЛЕНЫ КЛАССА [2.1] Основные понятия [2.2] Примеры выполнения задания [2.3] Постановка задания [2.4] Варианты контрольных заданий [2.4.1] Одномерные МАССИВЫ – члены класса [2.4.2] Двумерные МАССИВЫ – члены класса [3] ЗАДАНИЕ 3. МАССИВЫ ОБЪЕКТОВ, УКАЗАТЕЛИ [3.1] Основные понятия [3.2] Постановка задания [3.3] Примеры выполнения задания [3.4] Варианты контрольных заданий [4] ЗАДАНИЕ 4. ПЕРЕГРУЗКА ОПЕРАЦИЙ [4.1] Основные понятия [4.2] Примеры выполнения задания [4.3] Постановка задания [4.4] Варианты контрольных заданий [5] ЗАДАНИЕ 5. НАСЛЕДОВАНИЕ [5.1] Постановка задания [5.2] Пример выполнения задания [5.3] Варианты заданий [6] Оглавление |
54
PAGE 56