информационная безопасность
без паники и всерьез
 подробно о проектеRambler's Top100 		Страшный баг в WindowsГде водятся OGRыВсе любят мед
BugTraq.Ru
 Русский BugTraq
 Анализ криптографических сетевых... 
 Модель надежности двухузлового... 
 Специальные марковские модели надежности... 
 Очередное исследование 19 миллиардов... 
 Оптимизация ввода-вывода как инструмент... 
 Зловреды выбирают Lisp и Delphi 
главная обзор RSN блог библиотека закон бред форум dnet о проекте
bugtraq.ru / форум / programming
Имя Пароль
если вы видите этот текст, отключите в настройках форума использование JavaScript
ФОРУМ
все доски
FAQ
IRC
новые сообщения
site updates
guestbook
beginners
sysadmin
programming
operating systems
theory
web building
software
hardware
networking
law
hacking
gadgets
job
dnet
humor
miscellaneous
scrap
регистрация





Легенда:
  новое сообщение
  закрытая нитка
  новое сообщение
  в закрытой нитке
  старое сообщение
Опять ни фига 22.06.06 21:39  Число просмотров: 2434
Автор: amirul <Serge> Статус: The Elderman
<"чистая" ссылка>
> У тебя в коде написано:
>
> Str1=Str2+Str1;
>
> Эта запись эквивалентна:

Эта в данном случае запись эквивалентна
Str1.operator=(Str2.operator+(Str1));

> Str1=operator+(Str2,Str1);

Бирарные операторы с двумя аргументами тоже бывают, но поиск в функциях-членах идет ДО поиска в глобальных функциях.

> Стало быть и в определении operator+ должно быть два
> аргумента:
>
> TString TString::operator+(const TString &aString,
> const TString &bString)

ГОНИШЬ!!!
Функция член с двумя аргументами. Не бывает такого.
<programming>
[C++] Помогите разобраться в с++ под Линуксом.(в смысле ООП) 22.06.06 19:34  
Автор: panter_dsd Статус: Незарегистрированный пользователь
<"чистая" ссылка>
Помогоите, пожалуйста!.
Недавно перешел на Линуху и пытаюсь писать на с++. Создал свой строковой класс. Вот одна функция:

TString TString::operator+(TString &aString)
{
TString Temp(*this);
Temp.AddStr(aString.c_str());
return Temp;
};

Пытаюсь вызвать:

TString Str1("aaa");
TString Str2("bbb");
Str1=Str2+Str1; // В этом месте выдается ошибка и прога не компилится, причем под виндой (TurboC++) все шло нормально.

Буду очень благодарен!

http://panter_dsd@mail.ru
Посмотри на определение 22.06.06 20:39  
Автор: Heller <Heller> Статус: Elderman
<"чистая" ссылка>
operator+ имеет два аргумента (и лучше их делать const):

> TString TString::operator+(TString &aString)
> {
> TString Temp(*this);
> Temp.AddStr(aString.c_str());
> return Temp;
> };
>
> Пытаюсь вызвать:
>
> TString Str1("aaa");
> TString Str2("bbb");
> Str1=Str2+Str1; // В этом месте выдается
> ошибка и прога не компилится, причем под виндой (TurboC++)
> все шло нормально.
Именно из-за неправильного определения.

>
> Буду очень благодарен!
Ни фига 22.06.06 20:54  
Автор: amirul <Serge> Статус: The Elderman
<"чистая" ссылка>
> operator+ имеет два аргумента (и лучше их делать const):

operator+ имеет два аргумента, только если он сделан глобальной функцией (не членом)

> > TString Str1("aaa");
> > TString Str2("bbb");
> > Str1=Str2+Str1; // В этом месте выдается
> > ошибка и прога не компилится, причем под виндой

Хотя бы написал, что за ошибка (это уже к пантеру)

Попробуй вместо последней строки сделать сначала просто
Str1 + Str2;

А потом просто
Str1 = Str2;

Так будет понятно какой из операторов у тебя глючит.

> (TurboC++)
> > все шло нормально.
> Именно из-за неправильного определения.

Нет
[C++] Ни фига 22.06.06 21:04  
Автор: panter_dsd Статус: Незарегистрированный пользователь
<"чистая" ссылка>
Оба пробовал, по отдельности не глючат, но при Str1+Str2, конечно, ничего не происходит. При Str1=Str2 все нормально. Вот мой код.
MyString.h

//---------------------------------------------------------------------------
#include <string.h>
#include <stdio.h>

class TString
{
private:
char *string;
int StrLength;
void AddStr(char *aStr);
public:
TString();
TString(char *aStr);
TString(TString &aString);
~TString();

void Clear();
void Delete(int First, int Count);
void LowerCase();
char *c_str() {return string;};
int Length() {return StrLength;};

void operator=(TString &aString);
void operator=(char *aStr);
TString operator+(const TString &aString,const TString &bString);
TString operator+(char *aStr);
char operator[](int index);
};
//-------------------------------------------
TString::TString()
{
string=0;
string=new char;
StrLength=0;
}
//-------------------------------------------
TString::TString(char *aStr)
{
StrLength=strlen(aStr);
string=new char[StrLength+1];
strcpy(string,aStr);
}
//-------------------------------------------
TString::TString(TString &aString)
{
StrLength=aString.StrLength;
string=new char[StrLength+1];
strcpy(string,aString.string);
}
//-------------------------------------------
TString::~TString()
{
if (string) {delete[] string;}
string=0;
StrLength=0;
}
//-------------------------------------------
void TString::AddStr(char *aStr)
{
char *Temp=new char[StrLength+strlen(aStr)+1];
strcpy(Temp,string);
Temp[StrLength]='\0';
if (string) {delete[] string;}
strcat(Temp,aStr);
string=Temp;
StrLength+=strlen(aStr);
}
//-------------------------------------------
void TString::Clear()
{
if (string)
{
delete[] string;
string=0 ;
StrLength=0;
}

}
//-------------------------------------------
void TString::Delete(int First, int Count)
{
//
}

//-------------------------------------------
void TString::operator=(TString &aString)
{
if (string)
{
delete[] string;
string=0 ;
StrLength=0;
}
StrLength=aString.StrLength;
string=new char[StrLength+1];
strcpy(string,aString.string);
};
//-------------------------------------------
void TString::operator=(char *aStr)
{
if (string)
{
delete[] string;
string=0 ;
StrLength=0;
}
StrLength=strlen(aStr);
string=new char[StrLength+1];
strcpy(string, aStr);
};
//-------------------------------------------
TString TString::operator+(const TString &aString,const TString &bString)
{
TString Temp(aString);
Temp.AddStr(bString.c_str());
return Temp;
};
//-------------------------------------------
TString TString::operator+(char *aStr)
{
TString Temp(*this);
Temp.AddStr(aStr);
return Temp;
};
//-------------------------------------------
char TString::operator[](int index)
{
if ((index>StrLength)|(index<1)) {return '\0';}
return string[index-1];
};
//-------------------------------------------
void TString::LowerCase()
{
for (int i=0; i<StrLength; i++)
{
if ((int(string[i])>65) && (int(string[i])<90))
{
string[i]=string[i]+32;
}
if ((int((unsigned char)(string[i]))>128) && (int((unsigned char)(string[i]))<144))
{
string[i]=string[i]+32;
}
if ((int((unsigned char)(string[i]))>143) && (int((unsigned char)(string[i]))<160))
{
string[i]=string[i]+81;
}
}
}
//-----------------------------------------------------------------------------------------------------------------------------

temp.cpp
//--------------------------------------------------------------
#include "mystring.h"

main()
{
TString Str;
TString Str1("sadfasdf");
Str="PanteR";
Str=Str+Str1;
printf(Str.c_str());
printf("\n");
}
сильно не разбирался, не тестил, просто прочитал... 24.06.06 12:21  
Автор: kstati <Евгений Борисов> Статус: Elderman
Отредактировано 24.06.06 12:23  Количество правок: 2
<"чистая" ссылка>
Вот ошибка: "no match for 'operator
= <<<<<<<<<<<< а оператор + при чем?!
' in 'Str=TString::operator+(TString&)(((TString&)(&Str1)))'"
Во объявлениях всех методов принимающих char * и где не... 22.06.06 21:20  
Автор: Killer{R} <Dmitry> Статус: Elderman
<"чистая" ссылка>
Во объявлениях всех методов принимающих char * и где не происходит его изменения (мельком глянув код я так понял что во всех) напиши вместо char * - const char *. Тк GCC ложит строки как константные данные потом у тебя неявно пытается вызываться конструктор TSTring'а для оператора + ну и не получается тк конструктор у тя принимает не const char * а char *

PS а чем std::basic_string<char> ака std::string плох?
Опять, к сожалению, немного не то... 22.06.06 21:26  
Автор: panter_dsd Статус: Незарегистрированный пользователь
<"чистая" ссылка>

Во первых спасибо, но ошибка не в этом. Ошибку выдает именно operator+. Можно даже тело этой функции сделать пустым, все равно ошибка.
А на счет использования "std::basic_string<char> ака std::string " - недавно только перешел на ООП. Хочу пообучаться, а это самый простой и интересный класс (мне так кажется). Я еще хочу TStringList написать, только пока не получается.

Пантер.
Гм повнимательнее посмотрел на код. Дейтствительно не то -... 22.06.06 21:36  
Автор: Killer{R} <Dmitry> Статус: Elderman
Отредактировано 22.06.06 21:37  Количество правок: 1
<"чистая" ссылка>
Гм повнимательнее посмотрел на код. Дейтствительно не то - там не char * прибавляется)
Но в любом случае с константностью у тебя там путаница а тот код что ты привел вообще не работает. А после правки - работает). Не помешал бы оригинал кода без всяких операторов + с двумя параметрами.

ЗЫ. А какая ошибка хоть выдается?
Посылаю код 22.06.06 21:42  
Автор: panter_dsd Статус: Незарегистрированный пользователь
<"чистая" ссылка>
Вот ошибка: "no match for 'operator=' in 'Str=TString::operator+(TString&)(((TString&)(&Str1)))'"

А вот код:
#include <string.h>
#include <stdio.h>

class TString
{
private:
char *string;
int StrLength;
void AddStr(char *aStr);
public:
TString();
TString(char *aStr);
TString(TString &aString);
~TString();

void Clear();
void Delete(int First, int Count);
void LowerCase();
char *c_str() {return string;};
int Length() {return StrLength;};

void operator=(TString &aString);
void operator=(char *aStr);
TString operator+(const TString &aString,const TString &bString);
TString operator+(char *aStr);
char operator[](int index);
};
//-------------------------------------------
TString::TString()
{
string=0;
string=new char;
StrLength=0;
}
//-------------------------------------------
TString::TString(char *aStr)
{
StrLength=strlen(aStr);
string=new char[StrLength+1];
strcpy(string,aStr);
}
//-------------------------------------------
TString::TString(TString &aString)
{
StrLength=aString.StrLength;
string=new char[StrLength+1];
strcpy(string,aString.string);
}
//-------------------------------------------
TString::~TString()
{
if (string) {delete[] string;}
string=0;
StrLength=0;
}
//-------------------------------------------
void TString::AddStr(char *aStr)
{
char *Temp=new char[StrLength+strlen(aStr)+1];
strcpy(Temp,string);
Temp[StrLength]='\0';
if (string) {delete[] string;}
strcat(Temp,aStr);
string=Temp;
StrLength+=strlen(aStr);
}
//-------------------------------------------
void TString::Clear()
{
if (string)
{
delete[] string;
string=0 ;
StrLength=0;
}

}
//-------------------------------------------
void TString::Delete(int First, int Count)
{
//
}

//-------------------------------------------
void TString::operator=(TString &aString)
{
if (string)
{
delete[] string;
string=0 ;
StrLength=0;
}
StrLength=aString.StrLength;
string=new char[StrLength+1];
strcpy(string,aString.string);
};
//-------------------------------------------
void TString::operator=(char *aStr)
{
if (string)
{
delete[] string;
string=0 ;
StrLength=0;
}
StrLength=strlen(aStr);
string=new char[StrLength+1];
strcpy(string, aStr);
};
//-------------------------------------------
TString TString::operator+(const TString &aString,const TString &bString)
{
TString Temp(aString);
Temp.AddStr(bString.c_str());
return Temp;
};
//-------------------------------------------
TString TString::operator+(char *aStr)
{
TString Temp(*this);
Temp.AddStr(aStr);
return Temp;
};
//-------------------------------------------
char TString::operator[](int index)
{
if ((index>StrLength)|(index<1)) {return '\0';}
return string[index-1];
};
//-------------------------------------------
void TString::LowerCase()
{
for (int i=0; i<StrLength; i++)
{
if ((int(string[i])>65) && (int(string[i])<90))
{
string[i]=string[i]+32;
}
if ((int((unsigned char)(string[i]))>128) && (int((unsigned char)(string[i]))<144))
{
string[i]=string[i]+32;
}
if ((int((unsigned char)(string[i]))>143) && (int((unsigned char)(string[i]))<160))
{
string[i]=string[i]+81;
}
}
}
Насколько я понимаю 22.06.06 21:57  
Автор: amirul <Serge> Статус: The Elderman
<"чистая" ссылка>
Временные переменные могут копироваться только в константные ссылки. Либо принимай по значению, либо не используй временных переменных, либо поопределяй все ссылки, которые ты не собираешься менять константными.

Вот код, который компилируется. Но я заметил там несколько ошибок

#include <string.h>
#include <stdio.h>

class TString
{
private:
char *string;
int StrLength;
void AddStr(char *aStr);
public:
TString();
TString(char *aStr);
TString(const TString &aString);
~TString();

void Clear();
void Delete(int First, int Count);
void LowerCase();
char *c_str() {return string;};
int Length() {return StrLength;};

void operator=(const TString &aString);
void operator=(char *aStr);
TString operator+(TString &aString);
TString operator+(char *aStr);
char operator[](int index);
};
//-------------------------------------------
TString::TString()
{
string=0;
string=new char;
StrLength=0;
}
//-------------------------------------------
TString::TString(char *aStr)
{
StrLength=strlen(aStr);
string=new char[StrLength+1];
strcpy(string,aStr);
}
//-------------------------------------------
TString::TString(const TString &aString)
{
StrLength=aString.StrLength;
string=new char[StrLength+1];
strcpy(string,aString.string);
}
//-------------------------------------------
TString::~TString()
{
if (string) {delete[] string;}
string=0;
StrLength=0;
}
//-------------------------------------------
void TString::AddStr(char *aStr)
{
char *Temp=new char[StrLength+strlen(aStr)+1];
strcpy(Temp,string);
Temp[StrLength]='\0';
if (string) {delete[] string;}
strcat(Temp,aStr);
string=Temp;
StrLength+=strlen(aStr);
}
//-------------------------------------------
void TString::Clear()
{
if (string)
{
delete[] string;
string=0 ;
StrLength=0;
}

}
//-------------------------------------------
void TString::Delete(int First, int Count)
{
//
}

//-------------------------------------------
void TString::operator=(const TString &aString)
{
if (string)
{
delete[] string;
string=0 ;
StrLength=0;
}
StrLength=aString.StrLength;
string=new char[StrLength+1];
strcpy(string,aString.string);
};
//-------------------------------------------
void TString::operator=(char *aStr)
{
if (string)
{
delete[] string;
string=0 ;
StrLength=0;
}
StrLength=strlen(aStr);
string=new char[StrLength+1];
strcpy(string, aStr);
};
//-------------------------------------------
TString TString::operator+(TString &aString)
{
TString Temp(*this);
Temp.AddStr(aString.c_str());
return Temp;
};
//-------------------------------------------
TString TString::operator+(char *aStr)
{
TString Temp(*this);
Temp.AddStr(aStr);
return Temp;
};
//-------------------------------------------
char TString::operator[](int index)
{
if ((index>StrLength)|(index<1)) {return '\0';}
return string[index-1];
};
//-------------------------------------------
void TString::LowerCase()
{
for (int i=0; i<StrLength; i++)
{
if ((int(string[i])>65) && (int(string[i])<90))
{
string[i]=string[i]+32;
}
if ((int((unsigned char)(string[i]))>128) && (int((unsigned char)(string[i]))<144))
{
string[i]=string[i]+32;
}
if ((int((unsigned char)(string[i]))>143) && (int((unsigned char)(string[i]))<160))
{
string[i]=string[i]+81;
}
}
}
[C++] Посмотри на определение 22.06.06 20:40  
Автор: panter_dsd Статус: Незарегистрированный пользователь
<"чистая" ссылка>
А можно кусочек кода?

Заранее благодарен.
Пантер.
Re 22.06.06 20:52  
Автор: Heller <Heller> Статус: Elderman
Отредактировано 22.06.06 20:55  Количество правок: 1
<"чистая" ссылка>
У тебя в коде написано:

Str1=Str2+Str1;

Эта запись эквивалентна:

Str1=operator+(Str2,Str1);

Стало быть и в определении operator+ должно быть два аргумента:

TString TString::operator+(const TString &aString, const TString &bString)

Ну и вообще по поводу самой функции.

operator+ вызывается в общем случае именно как функция, а не как метод класса, так что указатель класса нужно убрать. Ну и никакого this тогда быть не может.

Если, скажем, Concat - это метод для конкатенации, то код должен быть таким:

TString operator+ (const TString &aString, const TString &bString)
{
return aString.Concat(bString);
}

Но это уже чисто архитектурные замечания.
Опять ни фига 22.06.06 21:39  
Автор: amirul <Serge> Статус: The Elderman
<"чистая" ссылка>
> У тебя в коде написано:
>
> Str1=Str2+Str1;
>
> Эта запись эквивалентна:

Эта в данном случае запись эквивалентна
Str1.operator=(Str2.operator+(Str1));

> Str1=operator+(Str2,Str1);

Бирарные операторы с двумя аргументами тоже бывают, но поиск в функциях-членах идет ДО поиска в глобальных функциях.

> Стало быть и в определении operator+ должно быть два
> аргумента:
>
> TString TString::operator+(const TString &aString,
> const TString &bString)

ГОНИШЬ!!!
Функция член с двумя аргументами. Не бывает такого.
Просто опечатался (вернее, Ctrl+C->Ctrl+V и не все... 22.06.06 22:05  
Автор: Heller <Heller> Статус: Elderman
Отредактировано 22.06.06 22:05  Количество правок: 1
<"чистая" ссылка>
> > У тебя в коде написано:
> >
> > Str1=Str2+Str1;
> >
> > Эта запись эквивалентна:
>
> Эта в данном случае запись эквивалентна
> Str1.operator=(Str2.operator+(Str1));
>
> > Str1=operator+(Str2,Str1);
>
> Бирарные операторы с двумя аргументами тоже бывают, но
> поиск в функциях-членах идет ДО поиска в глобальных
> функциях.
>
> > Стало быть и в определении operator+ должно быть два
> > аргумента:
> >
> > TString TString::operator+(const TString &aString,
> > const TString &bString)
>
> ГОНИШЬ!!!
> Функция член с двумя аргументами. Не бывает такого.
Просто опечатался (вернее, Ctrl+C->Ctrl+V и не все подправил).
Однако согласись, что скорее не "Бирарные операторы с двумя аргументами тоже бывают", а вообще чаще операторы перегружаются за пределами класса, если этот оператор не модифицирует сам объект для которого вызывается (как, например, в случае присваивания).

И вообще я на C++ не программирую :-X
Общая рекомендация такая: 23.06.06 16:29  
Автор: amirul <Serge> Статус: The Elderman
<"чистая" ссылка>
Глобальный оператор делается только в том случае, если невозможно сделать его членом. То бишь, если левый аргумент либо встроенного либо библиотечного типа.

> Однако согласись, что скорее не "Бирарные операторы с двумя
> аргументами тоже бывают", а вообще чаще операторы
> перегружаются за пределами класса, если этот оператор не

Ни фига. Засирать глобальное пространство имен надо как можно меньше.

> модифицирует сам объект для которого вызывается (как,
> например, в случае присваивания).

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

> И вообще я на C++ не программирую :-X

А я программирую :-)
[C++] Не получается 22.06.06 21:01  
Автор: panter_dsd Статус: Незарегистрированный пользователь
<"чистая" ссылка>
Попробовал

TString TString::operator+(const TString &aString,const TString &bString)
{
TString Temp(aString);
Temp.AddStr(bString.c_str());
return Temp;
};
Выдает ошибку

no match for 'operator=' in 'Str=TString::operator+(TString&)(((TString&)(&Str1)))'
1




Rambler's Top100
Рейтинг@Mail.ru


  Copyright © 2001-2025 Dmitry Leonov   Page build time: 0 s   Design: Vadim Derkach