Пример 1
Задание. Определить класс заданного типа. Написать определенные как дружественные функции подпрограммы ввода с клавиатуры и вывода на экран данных, определяющих объекты этого класса. Перегрузить указанные операции и функции с помощью составных функций класса:
Матрица n x n | +, - * float norma() | сумма и разность произведение матриц норма |
Рассмотрим программу с использованием некоторых рассмотренных классов ввода/вывода в сочетании с собственным классом Matrix, в котором собраны матрица и порядок этой матрицы. Элементы-члены в свою очередь являются закрытыми данными класса.
В этой программе мы рассмотрим ввод/вывод объектов собственного класса с использованием классов istream и ostream, функции которых будут определены дружественными для нашего класса. Это достигается перегрузкой операторов функций >> (для объекта cin класса istream) и << (для объекта cout класса ostream), чтобы они поддерживали работу с нашим созданным классом. Помимо этого в программе будут рассмотрены перегрузки таких операторов, как присваивание (=), сложение (+), вычитание (-) и умножение (*). Причем сложение, вычитание и умножение перегружаются дружественными функциями для класса Matrix, а присваивание – функцией-членом нашего класса Matrix, т. к. для этой операции компилятор С++ предусматривает скрытую функцию по умолчанию, если она не определена в явном виде. Еще в нашем классе рассмотрена функция-элемент norma(), которая возвращает норму матрицы типа float, т. е. третью норму матрицы: третья норма матрицы 
.
Кроме того, в программе предусмотрены два вида конструкторов: конструктор копирования и, следовательно, конструктор по умолчанию; и соответственно для удаления объекта из памяти без завершения программы предусмотрен деструктор.
Примечание. Для ввода и вывода объектов класса Matrix использованы только объекты классов istream и ostream: cin и cout. Функции printf() и scanf() в программе не используются.
Программа
#include <iostream. h>
#include <conio. h>
#include <math. h>
int y;
// Класс матрица
class Matrix
{
private:
// Собственные элементы:
static int size; // Порядок матрицы
int **matrix; // Матрица
public:
// Общедоступные элементы:
Matrix() {} // Конструктор по умолчанию
Matrix(const Matrix &Object); // Конструктор копирования
~Matrix(); // Деструктор
float norma(); // Норма матрицы
Matrix &operator=(const Matrix &Object); // Перегрузка =
Matrix operator+(Matrix &); // Сложение матриц
Matrix operator-(Matrix &); // Вычитание матриц
Matrix operator*(Matrix &); // Перемножение матриц
// Перегрузка оператора << для вывода матрицы
friend ostream &operator<<(ostream &, Matrix &);
// Перегрузка оператора >> для ввода матрицы
friend istream &operator>>(istream &, Matrix &);
};
// Конструктор копирования
Matrix::Matrix(const Matrix &Object)
{
int i, j;
size = Object. size;
matrix = new int *[size];
for (i = 0; i < size; i++)
matrix[i] = new int [size];
for (i = 0; i < size; i++)
for (j = 0; j < size; j++)
matrix[i][j] = Object. matrix[i][j];
}
// Деструктор
Matrix::~Matrix()
{
for (int i = 0; i < size; i++)
delete matrix[i];
delete matrix;
}
// Норма матрицы
float Matrix::norma()
{
int i, j;
float tmp = 0;
for (i = 0; i < size; i++)
for (j = 0; j < size; j++)
tmp += matrix[i][j] * matrix[i][j];
return sqrt(tmp);
}
// Перегрузка оператора =
Matrix& Matrix::operator=(const Matrix &Object)
{
int i, j;
size = Object. size;
matrix = new int *[size];
for (i = 0; i < size; i++)
matrix[i] = new int [size];
for (i = 0; i < size; i++)
for (j = 0; j < size; j++)
matrix[i][j] = Object. matrix[i][j];
return *this;
}
// Перегрузка оператора +
Matrix Matrix::operator+(Matrix &fp1)
{
int i, j;
if (size == fp1.size)
{
Matrix fp(fp1);
for (i=0;i<fp. size;i++)
for (j=0;j<fp. size;j++)
fp. matrix[i][j]=matrix[i][j]+fp1.matrix[i][j];
return fp;
}
}
// Перегрузка оператора -
Matrix Matrix::operator-(Matrix &fp1)
{
int i, j;
if (size == fp1.size)
{
Matrix fp(fp1);
for (i = 0; i < fp. size; i++)
for (j = 0; j < fp. size; j++)
fp. matrix[i][j] = matrix[i][j] - fp1.matrix[i][j];
return fp;
}
}
// Перегрузка оператора *
Matrix Matrix::operator*(Matrix &fp1)
{
int i, j, k, sum;
if (size == fp1.size)
{
Matrix fp(fp1);
for(i = 0; i < fp. size; i++)
for(j = 0; j < fp. size; j++)
{
sum = 0;
for (k = 0; k < fp. size; k++)
sum += matrix[i][k] * fp1.matrix[k][j];
fp. matrix[i][j]=sum;
}
return fp;
}
}
// Перегрузка оператора >>
istream &operator>>(istream &fi, Matrix &fp)
{
int i, j;
fp. matrix = new int *[fp. size];
for (i = 0; i < fp. size; i++)
fp. matrix[i] = new int [fp. size];
for (i = 0; i < fp. size; i++)
for (j = 0; j < fp. size; j++)
{
gotoxy((j + 1) * 4, y + i + 2);
fi >> fp. matrix[i][j];
}
y += i + 2 /*- 1*/;
return fi;
}
// Перегрузка оператора <<
ostream &operator<<(ostream &fo, Matrix &fp)
{
int i, j;
for (i = 0; i < fp. size; i++)
for (j = 0; j < fp. size; j++)
{
gotoxy((j + 1) * 4, y + i + 2);
fo << fp. matrix[i][j];
}
y += i + 2 /*- 1*/;
return fo;
}
int Matrix::size = 2;
void main()
{
clrscr();
Matrix pr1, pr2;
cout << "Введите матрицу A ->\n ";
cin >> pr1;
cout << "\nВведите матрицу B ->\n ";
cin >> pr2;
cout << "\nA+B="<<(pr1+pr2);
cout << "\n\nA-B="<<(pr1-pr2);
cout << "\n\nA*B="<<(pr1*pr2);
pr1 = pr2;
cout << "\nНорма матрицы B = " << pr1.norma();
getch();
}
Результаты работы программы
Введите матрицу A ->
1 10
20 32
Введите матрицу B ->
-20 43
0 -45
1
A+B=
-19 53
20 -13
A-B=
21 -33
20 77
A*B=
-
Норма матрицы B = 65.375839
Пример 2
Задание. Определить класс заданного типа. Написать определенные как дружественные функции подпрограммы ввода с клавиатуры и вывода на экран данных, определяющих объекты этого класса. Перегрузить указанные операции и функции с помощью составных функций класса:
Комплексные числа | +, - *, / float abs() |
Рассмотрим программу с использованием некоторых рассмотренных классов ввода/вывода в сочетании с собственным классом Complex, который включает действительную (real) и мнимую (image) часть. Элементы-члены в свою очередь являются закрытыми данными класса.
В этой программе мы рассмотрим вывод объектов собственного класса с использованием класса ostream, функция которого будет определена дружественной для нашего класса. Это достигается перегрузкой операторов функций << (для объекта cout класса ostream), чтобы они поддерживали работу с нашим созданным классом. Помимо этого в программе будут рассмотрены перегрузки таких операторов, как сложение (+), вычитание (-), умножение (*) и деление (/). Кроме того, в программе предусмотрены конструктор по умолчанию; и соответственно для удаления объекта из памяти без завершения программы предусмотрен деструктор. Еще в нашем классе рассмотрена функция-элемент abs(), которая возвращает модуль комплексного числа типа float, т. е. 
.
Программа
#include <iostream. h>
#include <conio. h>
#include <math. h>
class Complex
{
private:
double real; // Действительная часть
double image; // Мнимая часть
public:
Complex() {}; // Конструктор по умолчанию
Complex(double r) { real = r; image = 0; } // Конструктор
Complex(double r, double i) { real = r, image = i; } // Конструктор
~Complex() {} // Деструктор
float abs() // Модуль комплексного числа
{
return sqrt(real * real - image * image);
}
Complex operator+(Complex &); // Перегрузка оператора сложения
Complex operator-(Complex &); // Перегрузка оператора вычитания
Complex operator*(Complex &); // Перегрузка оператора умножения
Complex operator/(Complex &); // Перегрузка оператора деления
// Перегрузка функции-оператора << для вывода класса Complex
friend ostream &operator<<(ostream &, Complex &);
// Перегрузка функции-оператора >> для ввода класса Complex
friend istream &operator>>(istream &, Complex &);
};
// Перегрузка +
Complex Complex::operator+(Complex &fp1)
{
fp1.real = real + fp1.real;
fp1.image = image + fp1.image;
return fp1;
}
// Перегрузка -
Complex Complex::operator-(Complex &fp1)
{
fp1.real = real - fp1.real;
fp1.image = image - fp1.image;
return fp1;
}
// Перегрузка *
Complex Complex::operator*(Complex &fp1)
{
double i, j;
i = real * fp1.real - image * fp1.image;
j = real * fp1.image + fp1.real * image;
fp1.real = i;
fp1.image = j;
return fp1;
}
// Перегрузка /
Complex Complex::operator/(Complex &fp1)
{
double k, i, j;
k = fp1.real * fp1.real + fp1.image * fp1.image;
i = (real * fp1.real + image * fp1.image) / k;
j = (fp1.real * image - real * fp1.image) / k;
fp1.real = i;
fp1.image = j;
return fp1;
}
// Перегрузка оператора <<
ostream &operator<< (ostream &fo, Complex &fp)
{
if (fp. image < 0) fo << fp. real << "+i(" << fp. image << ")\n";
else fo << fp. real << "+i" << fp. image << "\n";
return fo;
}
// Перегрузка оператора >>
istream &operator>>(istream &fi, Complex &fp)
{
cout << "Введите действительную часть: ";
fi >> fp. real;
cout << "Введите мнимую часть: ";
fi >> fp. image;
return fi;
}
void main()
{
clrscr();
// Комплексные числа
Complex c1, c2, c3, c4, c5;
// Ввод комплексных чисел
cin >> c1;
cin >> c2;
cin >> c3;
cin >> c4;
cin >> c5;
// Вывод комплексных чисел
cout << "\nc1 = " << c1;
cout << "c2 = " << c2;
cout << "c3 = " << c3;
cout << "c4 = " << c4;
cout << "c5 = " << c5 << '\n';
cout << "Модуль c1: " << c1.abs() << "\n\n";
// Вывод результатов операций
cout << "c1 + c2 = " << (c1 + c2);
cout << "c1 - c3 = " << (c1 - c3);
cout << "c1 * c4 = " << (c1 * c4);
cout << "c1 / c5 = " << (c1 / c5);
getch();
}
Результаты работы программы
Введите действительную часть: 9
Введите мнимую часть: 8
Введите действительную часть: 7
Введите мнимую часть: 6
Введите действительную часть: 5
Введите мнимую часть: 4
Введите действительную часть: 3
Введите мнимую часть: 2
Введите действительную часть: 1
Введите мнимую часть: 2
c1 = 9+i8
c2 = 7+i6
c3 = 5+i4
c4 = 3+i2
c5 = 1+i2
Модуль c1: 4.123106
c1 + c2 = 16+i14
c1 - c3 = 4+i4
c1 * c4 = 11+i42
c1 / c5 = 5+i(-2)
Пример 3
Задание. Определить класс заданного типа. Написать определенные как дружественные функции подпрограммы ввода с клавиатуры и вывода на экран данных, определяющих объекты этого класса. Перегрузить указанные операции и функции с помощью составных функций класса:
Неупакованный BCD | +, - = |
Рассмотрим программу с использованием некоторых рассмотренных классов ввода/вывода в сочетании с собственным классом LongBCD, который состоит из последовательности цифр. Элементы-члены в свою очередь являются закрытыми данными класса.
Операция сложения чисел складывает и вычитает цифры, начиная с младших разрядов.
Числа выводятся с помощью стандартных функций
Программа
#include <iostream. h>
#include <stdio. h>
#include <conio. h>
#include <alloc. h>
//Числа хранятся в формате "младший разряд первым",
//Поддержка отрицательных чисел отсутствует
//Минимальный размер выделяемой памяти под хранение BCD числа
#define MINBCDSIZE 4
// Класс BCD-числа
class LongBCD
{
private:
char * data; // BCD-число
int size; // Его размер
// Функция увеличения области данных с их сохранением
void extend(int newsize)
{
char *nd = new char [newsize];
memset(nd, '0', newsize);
memcpy(nd, data, size);
size = newsize;
delete data;
data = nd;
}
// Установка значения i-го разряда области данных BCD-числа
void set(int i, char dig)
{
if (i >= size)
extend(i + 1);
data[i] = dig;
}
// Обнуление области данных BCD-числа, начиная с i-го разряда
void zero(int i);
// Установка значения BCD-числа на основании другого BCD-числа
void setvalue(LongBCD & n);
// Суммирование (+=)
void add(LongBCD & n);
// Вычитание (-=)
void sub(LongBCD & n);
public:
// Конструкторы
LongBCD();
LongBCD(long n);
// Деструктор
~LongBCD() {if (data) free(data);}
// Установка значения BCD-числа на основании long
void setvalue(long n);
// Перегрузка оператора присваивания
LongBCD & operator = (long n) {setvalue(n); return *this;}
LongBCD & operator = (LongBCD & n) {setvalue(n); return *this;}
// Перегрузка операций + и -
friend LongBCD operator + (LongBCD &, LongBCD &);
friend LongBCD operator - (LongBCD &, LongBCD &);
// Функция вывода BCD-числа на экран
void show(void);
};
// Суммирование (+=)
void LongBCD::add(LongBCD & n)
{
int maxl = n. size;
int i, carry = 0;
// Проверка наличия достаточного количества памяти
if (maxl >= size) extend(maxl + 1);
// Цикл по всем разрядам, начиная с младшего
for (i = 0; i < maxl; i++)
{
int res = (data[i] - '0') + (n. data[i] - '0') + carry;
// Учет переноса
if (res > 9)
{
res -= 10;
carry = 1;
}
else carry = 0;
set(i, '0' + res);
}
if (carry) set(maxl, '1');
}
// Вычитание (-=)
void LongBCD::sub(LongBCD & n)
{
int maxl = n. size;
int i, carry = 0;
// Проверка наличия достаточного количества памяти
if (maxl >= size) extend(maxl + 1);
// Цикл по всем разрядам, начиная с младшего
for (i = 0; i < maxl; i++)
{
int res = (data[i] - '0') - (n. data[i] - '0') - carry;
// Учет заема
if (res < 0)
{
res += 10;
carry = 1;
}
else carry = 0;
set(i, '0' + res);
}
}
// Обнуление области данных BCD-числа, начиная с i-го разряда
void LongBCD::zero(int i)
{
while(i < size) data[i++] = '0';
}
// Установка значения BCD-числа на основании long
void LongBCD::setvalue(long n)
{
int i = 0;
while (n!= 0)
{
set(i, '0' + (n % 10));
n /= 10;
i++;
}
zero(i);
}
// Установка значения BCD-числа на основании другого BCD-числа
void LongBCD::setvalue(LongBCD & n)
{
int i;
for (i = 0; i < n. size; i++) set(i, n. data[i]);
zero(i);
}
// Функция вывода BCD-числа на экран
void LongBCD::show(void)
{
int i = size;
while((i!= 0) && (data[i-1] == '0')) i--;
if (i == 0)
putchar('0');
else
while (i!= 0) {
i--;
putchar(data[i]);
}
puts("");
}
// Конструктор создает число со значеним 0
LongBCD::LongBCD()
{
data = new char[MINBCDSIZE];
size = MINBCDSIZE;
zero(0);
}
// Конструктор создает число со значеним, определяемым переменной
LongBCD::LongBCD(long n)
{
data = new char[MINBCDSIZE];
size = MINBCDSIZE;
setvalue(n);
}
// Перегрузка операции +
LongBCD operator + (LongBCD & a, LongBCD & b)
{
LongBCD * temp = new LongBCD;
*temp = a;
temp->add(b);
return * temp;
}
// Перегрузка операции -
LongBCD operator - (LongBCD & a, LongBCD & b)
{
LongBCD * temp = new LongBCD;
*temp = a;
temp->sub(b);
return * temp;
}
void main(void)
{
clrscr();
LongBCD A, B, C;
long temp;
cout << "Введите BCD-число A: ";
cin >> temp;
A. setvalue(temp);
cout << "Введите BCD-число B: ";
cin >> temp;
B. setvalue(temp);
cout << "\nA = "; A. show();
cout << "\nB = "; B. show();
cout << "\nA+B = "; C=A+B; C. show();
cout << "\nA-B = "; C=A-B; C. show();
getch();
}
Результаты работы программы
Введите BCD-число A: 12345
Введите BCD-число B: 324
A = 12345
B = 324
A+B = 12669
A-B = 12021
РАСЧЕТНО-ГРАФИЧЕСКОЕ ЗАДАНИЕ 2
Шаблоны функций и классов
Задание
· Написать параметризованную подпрограмму сортировки указанным методом. Отладить ее на целых числах и числах с плавающей точкой.
· Определить класс объектов массива, предназначенного для сортировки. Перегрузить для него операцию присваивания и операции сравнения <, <=, ==, >=, >.
· Написать программу, сортирующую массив объектов построенного класса с помощью написанной параметризованной подпрограммы.
Варианты заданий
Рассмотрим следующие методы сортировки:
S1. Пирамидальная сортировка.
S2. Сортировка подсчетом.
S3. Метод Шелла.
S4. Быстрая сортировка.
S5. Метод выбора.
S6. Метод вставок.
Рассмотрим классы:
String – строка символов;
Fraction – рациональная дробь;
Bits – битовая строка;
Bcd – строка, состоящая из десятичных цифр, записанных как символы;
Vector – n-мерный вектор, вектора сортируются в лексикографическом порядке.
Комбинируя методы сортировки и классы, получаем варианты заданий:
S1 | S2 | S3 | S4 | S5 | S6 | |
String | 1 | 6 | 11 | 16 | 21 | 26 |
Fraction | 2 | 7 | 12 | 17 | 22 | 27 |
Bits | 3 | 8 | 13 | 18 | 23 | 28 |
Bcd | 4 | 9 | 14 | 19 | 24 | 29 |
Vector | 5 | 10 | 15 | 20 | 25 | 30 |
Примеры выполнения РГЗ 2
Пример 1
Задание
· Написать параметризованную подпрограмму сортировки указанным методом. Отладить ее на целых числах и числах с плавающей точкой.
· Определить класс объектов массива, предназначенного для сортировки. Перегрузить для него операцию присваивания и операции сравнения <, <=, ==, >=, >.
· Написать программу, сортирующую массив объектов построенного класса с помощью написанной параметризованной подпрограммы.
Метод сортировки - метод Шелла, класс - битовая строка.
Программа
#include <iostream. h>
#include <string. h>
#include <conio. h>
#include <stdlib. h>
#define n 100
//класс: Битовая строка
class BinStr
{
private:
char *s; //сама строка
int length; //указатель на длину
public:
BinStr();
BinStr(char *);
BinStr(const BinStr &);
~BinStr();
int operator> (BinStr &);
int operator>=(BinStr &);
int operator< (BinStr &);
int operator<=(BinStr &);
int operator==(BinStr &);
BinStr &operator=(BinStr &Object);//перегрузка оператора присваивания
friend ostream &operator<<(ostream &, BinStr &);
};
BinStr::BinStr()
{
s=new char[1];
*s='\0';
length=0;
}
BinStr::BinStr(char *st)
{
length=strlen(st);
s=new char[(length)+1];
strcpy (s, st);
}
BinStr::BinStr(const BinStr &s1)
{
length=strlen(s1.s);
s=new char[(length)+1];
strcpy (s, s1.s);
}
BinStr::~BinStr()
{
delete s;
}
int BinStr::operator> (BinStr &Object)
{
int i;
//если длина левой строки больше правой
if(length>Object. length)
{
//проверяем, есть ли в старших битах левой
//строки, которых нет в правой, единицы
//если есть, то возвращаем 1
for(i=0;i<length-Object. length;i++)
if((s[i]-48)==1)
return 1;
//если единиц не оказалось, то побитово сравниваем
//обе строки: оставшуюся часть правой строки со всей левой,
//до нарушения равновесия
for(i=0;i<Object. length;i++)
if((s[i+(length-Object. length)]-48)<(Object. s[i]-48))
return 0;
else if((s[i+(length-Object. length)]-48)>(Object. s[i]-48))
return 1;
//если строки равны, возвращаем 0
return 0;
}
//далее следует все аналогично для оставшихся двух случаев,
//когда правая строка длиннее левой и когда длины строк равны
else if(length<Object. length)
{
for(i=0;i<Object. length-length;i++)
if((Object. s[i]-48)==1)
return 0;
for(i=0;i<length;i++)
if((s[i]-48)<(Object. s[i+Object. length-length]-48))
return 0;
else if((s[i]-48)>(Object. s[i+Object. length-length]-48))
return 1;
//если строки равны, возвращаем 0
return 0;
}
//когда длины строк равны, просто побитово сравниваем обе строки
//до нарушения равновесия
for(i=0;i<length;i++)
if((s[i]-48)<(Object. s[i]-48))
return 0;
else if((s[i]-48)>(Object. s[i]-48))
return 1;
//если строки равны, возвращаем 0
return 0;
}
int BinStr::operator>=(BinStr &Object)
{
int i;
//если длина левой строки больше правой
if(length>Object. length)
{
//проверяем, есть ли в старших битах левой
//строки, которых нет в правой, единицы
//если есть, то возвращаем 1
for(i=0;i<length-Object. length;i++)
if((s[i]-48)==1)
return 1;
//если единиц не оказалось, то побитово сравниваем
//обе строки: оставшуюся часть правой строки со всей левой,
//до нарушения равновесия
for(i=0;i<Object. length;i++)
if((s[i+(length-Object. length)]-48)<(Object. s[i]-48))
return 0;
else if((s[i+(length-Object. length)]-48)>(Object. s[i]-48))
return 1;
//если строки равны, возвращаем 1
return 1;
}
//далее следует все аналогично для оставшихся двух случаев,
//когда правая строка длиннее левой и когда длины строк равны
else if(length<Object. length)
{
for(i=0;i<Object. length-length;i++)
if((Object. s[i]-48)==1)
return 0;
for(i=0;i<length;i++)
if((s[i]-48)<(Object. s[i+Object. length-length]-48))
return 0;
else if((s[i]-48)>(Object. s[i+Object. length-length]-48))
return 1;
//если строки равны, возвращаем 1
return 1;
}
//когда длины строк равны, просто побитово сравниваем обе строки
//до нарушения равновесия
for(i=0;i<length;i++)
if((s[i]-48)<(Object. s[i]-48))
return 0;
else if((s[i]-48)>(Object. s[i]-48))
return 1;
//если строки равны, возвращаем 1
return 1;
}
int BinStr::operator< (BinStr &Object)
{
int i;
//если длина левой строки больше правой
if(length>Object. length)
{
//проверяем, есть ли в старших битах левой
//строки, которых нет в правой, единицы
//если есть, то возвращаем 0
for(i=0;i<length-Object. length;i++)
if((s[i]-48)==1)
return 0;
//если единиц не оказалось, то побитово сравниваем
//обе строки: оставшуюся часть правой строки со всей левой,
//до нарушения равновесия
for(i=0;i<Object. length;i++)
if((s[i+(length-Object. length)]-48)<(Object. s[i]-48))
return 1;
else if((s[i+(length-Object. length)]-48)>(Object. s[i]-48))
return 0;
//если строки равны, возвращаем 0
return 0;
}
//далее следует все аналогично для оставшихся двух случаев,
//когда правая строка длиннее левой и когда длины строк равны
else if(length<Object. length)
{
for(i=0;i<Object. length-length;i++)
if((Object. s[i]-48)==1)
return 1;
for(i=0;i<length;i++)
if((s[i]-48)<(Object. s[i+Object. length-length]-48))
return 1;
else if((s[i]-48)>(Object. s[i+Object. length-length]-48))
return 0;
//если строки равны, возвращаем 0
return 0;
}
//когда длины строк равны, просто побитово сравниваем обе строки
//до нарушения равновесия
for(i=0;i<length;i++)
if((s[i]-48)<(Object. s[i]-48))
return 1;
else if((s[i]-48)>(Object. s[i]-48))
return 0;
//если строки равны, возвращаем 0
return 0;
}
int BinStr::operator<=(BinStr &Object)
{
int i;
//если длина левой строки больше правой
if(length>Object. length)
{
//проверяем, есть ли в старших битах левой
//строки, которых нет в правой, единицы
//если есть, то возвращаем 0
for(i=0;i<length-Object. length;i++)
if((s[i]-48)==1)
return 0;
//если единиц не оказалось, то побитово сравниваем
//обе строки: оставшуюся часть правой строки со всей левой,
//до нарушения равновесия
for(i=0;i<Object. length;i++)
if((s[i+(length-Object. length)]-48)<(Object. s[i]-48))
return 1;
else if((s[i+(length-Object. length)]-48)>(Object. s[i]-48))
return 0;
//если строки равны, возвращаем 1
return 1;
}
//далее следует все аналогично для оставшихся двух случаев,
//когда правая строка длиннее левой и когда длины строк равны
else if(length<Object. length)
{
for(i=0;i<Object. length-length;i++)
|
Из за большого объема этот материал размещен на нескольких страницах:
1 2 3 4 5 6 7 8 |
