информационная безопасность
без паники и всерьез
 подробно о проектеRambler's Top100
Портрет посетителяСтрашный баг в Windows
BugTraq.Ru
Русский BugTraq
 Анализ криптографических сетевых... 
 Модель надежности двухузлового... 
 Специальные марковские модели надежности... 
 Крупный взлом GoDaddy 
 Просроченный сертификат ломает... 
 Phrack #70/0x46 
главная обзор RSN блог библиотека закон бред форум dnet о проекте
bugtraq.ru / форум / programming
Имя Пароль
ФОРУМ
если вы видите этот текст, отключите в настройках форума использование JavaScript
регистрация





Легенда:
  новое сообщение
  закрытая нитка
  новое сообщение
  в закрытой нитке
  старое сообщение
  • Напоминаю, что масса вопросов по функционированию форума снимается после прочтения его описания.
  • Новичкам также крайне полезно ознакомиться с данным документом.
Насколько я понимаю 22.06.06 21:57  Число просмотров: 2120
Автор: 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;
}
}
}
<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-2021 Dmitry Leonov   Page build time: 0 s   Design: Vadim Derkach