Перегрузка операторов
22.08.2013, 23:16. Показов 1166. Ответов 3
Помогите проверить и сделать
надо
1) Базовый класс Строка
Кликните здесь для просмотра всего текста
Описать базовый класс СТРОКА.
Обязательные члены класса:
* указатель на char - хранит адрес динамически выделенной памяти
для размещения символов строки;
* значение типа int - хранит длину строки в байтах.
Обязательные методы должны выполнять следующие действия:
* конструктор без параметров;
* конструктор, принимающий в качестве параметра
Си-строку (заканчивается нулевым байтом);
* конструктор, принимающий в качестве параметра символ (char).
* конструктор копирования;
* деструктор.
* чтение символа из заданной позиции;
Переопределить следующие операции:
* присваивание (=);
* оператор == - проверка на равенство;
это у меня как то так получилось
Кликните здесь для просмотра всего текста
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| class Stroka
{
protected:
char *pCh;
int len;
public:
Stroka();
Stroka(char*);
Stroka(char);
Stroka(const Stroka &obj);
~Stroka();
char *GetStr(void)const{return pCh;}
int GetLen(void)const{return len;}
Stroka&Stroka::operator=(const Stroka a);
// bool Stroka::operator==(const Stroka &a,const Stroka &b);
friend int operator==(string& x, char* s)
{return strcmp(x.pСh->s, s) == 0; }
friend int operator==(string& x, string& y)
{return strcmp(x.pСh->s, y.pСh->s) == 0; }
friend char getsim(const Stroka a,int i)
void Show();
} |
|
сами функции
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
| #include "stdafx.h"
#include "STROK.h"
#include <iostream>
using namespace std;
#include <string.h>
void Stroka::Show()
{
puts(pCh);
cout<<len<<endl;
}
Stroka::~Stroka()
{
if(pCh!=0) delete pCh;
cout<<"Stroka::~Stroka()"<<endl;
}
Stroka::Stroka()
{
len=0;
pCh='\0';
cout<<"Stroka::Stroka()"<<endl;
}
Stroka::Stroka(char ch)
{
len = 1;
pCh = new char [len + 1];
pCh[0] = ch;
pCh[1] = '\0';
//cout<<ch<<endl;
cout<<"Stroka::Stroka(char)"<<endl;
}
Stroka::Stroka(char*s)
{
len=strlen(s);
pCh=new char[len+1];
strcpy(pCh,s);
pCh[len]=0;
cout<<"Stroka::Stroka(const char*s)"<<endl;
}
Stroka::Stroka(const Stroka &obj)
{
char*tmpStr;
int l;
tmpStr=obj.GetStr();
l=obj.GetLen();
pCh=new char[l+1];
strcpy(pCh,tmpStr);
len=l;
cout<<"Stroka::Stroka(const Stroka&obj)"<<endl;
}
Stroka&Stroka::operator=(const Stroka a)
{
len=a.GetLen();
delete []pCh;
pCh=new char[len+1];
strcpy(pCh,a.pCh);
return *this;
}
char getsim(const Stroka &a,int i)
{
if(i-1>=0)
return a.pCh[i-1];
else return a.pCh[0];
} |
|
тут не знаю правельно ли сделал переопределение и вывод символа) чет он орет что недоступен pCh
|
2)Производный от СТРОКА класс СТРОКА_ИДЕНТИФИКАТОР
Кликните здесь для просмотра всего текста
Производный от СТРОКА класс СТРОКА_ИДЕНТИФИКАТОР
Строки данного класса строятся по правилам записи идентификаторов
в СИ, и могут включать в себя только те символы, которые могут входить
в состав Си-идентификаторов. Если исходные данные противоречат правилам
записи идентификатора, то создается пустая СТРОКА_ИДЕНТИФИКАТОР.
Обязательные методы:
* конструктор без параметров;
* конструктор, принимающий в качестве параметра Си-строку
(заканчивается нулевым байтом);
* конструктор, принимающий в качестве параметра символ (char).
* конструктор копирования;
* деструктор.
* перевод всех символов строки (кроме цифр) в нижний регистр;
Переопределить следующие операции:
* присваивание (=);
* оператор == - проверка на равенство;
вот что получается
Кликните здесь для просмотра всего текста
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| #include "STROK.h"
class Identificator:public Stroka
{
public:
Identificator();
Identificator(char ch);
Identificator(const Identificator&from);
Identificator(char*);
~Identificator();
char *GetStr(void)const{return pCh;}
int GetLen(void)const{return len;}
void PerevodRegistraUP();
void PerevodRegistraDOWN();
Identificator&Identificator::operator=(const Identificator a);
bool Identificator::operator==(const Identificator &a,const Identificator &b);
}; |
|
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
| #include "stdafx.h"
#include "IdStroka.h"
#include <stdio.h>
#include <conio.h>
#include <iostream>
using namespace std;
#include <string.h>
#include <math.h>
#define KEYWD_SZ 4
Identificator::~Identificator()
{
//if(pCh!=0) delete pCh;
//if(len!=0) delete[]pCh;
cout<<"Identificator::~Identificator()"<<endl;
}
Identificator::Identificator():Stroka()
{
len=0;
pCh='\0';
//cout<<"0-string"<<endl;
cout<<"Identificator::Identificator()"<<endl;
}
Identificator::Identificator(char*s):Stroka(s)
{
int i;
char *keywords[]={"int","extern","else","char","register","for","float","typedef","do","double","static","while",
"struct","goto","switch","union","return","case","long","sizeof","short","break","enter","unsigned","auto",
"class","if","void","main","scanf","printf","float","struct","union","continue","malloc","calloc","realloc",
"free","new","delete","default","puts","fscanf","fprintf","NULL","fgets","FILE","fclose","fopen","read","gets",
"asm","bool","catch","const","enum","dynamic_cast","explicit","const_cast","export","friend","inline","mutable",
"namespase","operator","private","public","protect","reinterpret_cast","static_cast","template","this","try",
"typeid","typename","using","virtual","volatile","wchar_t",0};
//просматриваем список, пока не обнаружен 0-указатель, т.е. конец списка.
for(i=0;keywords[i]!=0;i++)
{ //сравниваем не больше 8 символов.strncmp(), // лучше 1 символ
if(strncmp(s,keywords[i],KEYWD_SZ)==0)break;
}
if(keywords[i]==0)
{
printf("не найдено");
len=0;
pCh=new char[len+1];
pCh[0]='\0';
return;
}
if (!(((s[0]>='a')&&(s[0]<='z'))||((s[0]>='A')&&(s[0]<='Z'))||(s[0]=='_')))
{
len=0;
pCh=new char[len+1];
pCh[0]='\0';
return;
}
int j;
len=strlen(s);
for(j=1;j<len;j++)
if (!(((s[j]>='a')&&(s[j]<='z'))||((s[j]>='A')&&(s[j]<='Z'))||((s[j]>='0')&&(s[j]<='9'))||(s[j]=='_')))
{
len=0;
pCh=new char[len+1];
pCh[0]='\0';
return;
}
len=0;
while(s[len])len++;
pCh=new char[len+1];
for(int i=0;i<len;i++)
pCh[i]=s[i];
pCh[len]='\0';//
//puts(s);
cout<<"Identificator::Identificator(const char*s)"<<endl;
//81шт
}
Identificator::Identificator(const Identificator&from):Stroka(from)
{
char *tmpstr=from.GetStr();
int L=from.GetLen();
pCh=new char[L+1];
strcpy(pCh,tmpstr);
len=L;
pCh[L]='\0';
//puts(tmpstr);
cout<<"Identificator::Identificator(const Identificator&obj)"<<endl;
}
Identificator::Identificator(char ch):Stroka(ch)
{
len = 1;
pCh = new char [len + 1];
pCh[0] = ch;
pCh[1] = '\0';
//cout<<ch<<endl;
cout<<"Identificator::Identificator(char)"<<endl;
}
void Identificator::PerevodRegistraDOWN()
{
int i;
for (i=0;i<len;i++)
{
if ((pCh[i]>='A')&&(pCh[i]<='Z')) pCh[i]+=32;
}
//cout<<"lolo"<<pCh<<endl;
}
void Identificator::PerevodRegistraUP()
{
int i;
for (i=0;i<len;i++)
{
if ((pCh[i]>='a')&&(pCh[i]<='z')) pCh[i]-=32;
}
//cout<<"lolo"<<pCh<<endl;
}
Identificator&Identificator::operator=(const Identificator a)
{
len=a.GetLen();
delete []pCh;
pCh=new char[len+1];
strcpy(pCh,a.pCh);
cout<<"Done"<<endl;
return *this;
}
функцию== я не знаю как правильно написать) так что так пишу
bool Identificator::operator==(const Identificator &a,const Identificator &b)
{
int i=0,pop=1;
if(a.len>b.len||b.len<b.len)
return 0;
else
for(i=0;i>a.len;i++)
{
if(a.pCh[i]!=b.pCh[i])
return 0;
}
return 1;
} |
|
тут помогите с ф переопределения ну и так вдруг чтото бросится в глаза
|
3) Производный от СТРОКА класс БИТОВАЯ_СТРОКА.
Кликните здесь для просмотра всего текста
Строки данного класса могут содержать только символы '0' или '1'. Если
в составе инициализирующей строки будут встречены любые символы, отличные
от допустимых, БИТОВАЯ_СТРОКА принимает нулевое значение.
Содержимое данных строк рассматривается как двоичное число.
Отрицательные числа хранятся в дополнительном коде.
Обязательные методы:
* конструктор без параметров;
* конструктор, принимающий в качестве параметра
Си-строку (заканчивается нулевым байтом);
* конструктор копирования;
* деструктор;
* удаление лишних ведущих символов (нулей или единиц в зависимости от
знака числа);
Переопределить следующие операции (длина строки результата
равна длине большей из строк, в случае необходимости, более
короткая битовая строка расширяется влево знаковым разрядом) :
* присваивание (=);
* операция == - проверка на равенство
* операция < - проверка на меньше (по значению).
Вот код что то типо того
Кликните здесь для просмотра всего текста
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
| class Complex:public Stroka
{
public:
Complex();
Complex(char*);
Complex::Complex(const Complex&from);
~Complex();
char *GetStr(void)const{return pCh;}
int GetLen(void)const{return len;}
Complex&Complex::operator=(const Complex a);
//+ еще 2 функции на == и на < (проверка на меньше (по значению)) не знаю как
}; |
|
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
| #include "stdafx.h"
#include "ComplStroka.h"
#include <stdio.h>
#include <conio.h>
#include <iostream>
using namespace std;
#include <string.h>
#include <math.h>
Complex::~Complex()
{
//if(pCh!=0) delete pCh;
//if(len!=0) delete []pCh;
cout<<"Complex::~Complex()"<<endl;
}
Complex::Complex():Stroka()
{
len=3;
pCh=new char[len+1];
pCh[0]='0';
pCh[1]='i';
pCh[2]='0';
pCh[len]='\0';
cout<<"Complex::Complex()"<<endl;
}
Complex::Complex(char*a):Stroka(a)
{
int tmp[2],l;
char *tmp3,tmp2[80],*p;
l=strlen(a);
tmp3=new char(l);
tmp[0]=atoi(a);
p=strchr(a,'i');
tmp[1]=atoi(p+1);
itoa(tmp[0],tmp3,10);
strcat(tmp3,"i");
itoa(tmp[1],tmp2,10);
strcat(tmp3,tmp2);
len=strlen(tmp3);
pCh=new char[len+1];
pCh[len]='\0';
pCh=tmp3;
cout<<"Complex::Complex(const char*a)"<<endl;
}
Complex::Complex(const Complex&from):Stroka(from)
{
char *tmpstr=from.GetStr();
int L=from.GetLen();
pCh=new char[L+1];
strcpy(pCh,tmpstr);
len=L;
pCh[L]='\0';
puts(tmpstr);
cout<<"Complex::Complex(const Complex&obj)"<<endl;
}
Complex&Complex::operator=(const Complex a)
{
cout<<"присваивание(=)\n";
len=a.GetLen();
delete []pCh;
pCh=new char[len+1];
strcpy(pCh,a.pCh);
cout<<"Done"<<endl;
return *this;
}
+2 функции |
|
тут надо 2 функции == и <
|
Буду очень благодарен если кто то может допилить эти несколько ф ! или направит на путь истинный))
|
Добавлено через 41 минуту
Нашел для битовой что то подобное (фул копипаст) посмотрите правельно нет?
Кликните здесь для просмотра всего текста
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
| 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 0;
//если строки равны, возвращаем 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;
//если строки равны, возвращаем 1
return 1;
}
//когда длины строк равны, просто побитово сравниваем обе строки
//до нарушения равновесия
for(i=0;i<length;i++)
if((s[i]-48)!=(Object.s[i]-48))
return 0;
//если строки равны, возвращаем 1
return 1;
} |
|
Кликните здесь для просмотра всего текста
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
| 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;
} |
|
0
|
(
