У меня есть кусок кода, написанный на Builder'e, мне надо переделать его так, чтобы он мог работать без библиотеки vcl (под Линухом). Т.к. там используются только 3 класса: AnsiString, TList и TStringList, я решил написать эти классы, естественно не полность, а только те моменты, которые исп. в коде, но похоже у меня это не очень получилось, потому как все это дело глючит со страшной силой, а при больших объемах данных вообще зависает. Если кто подскажет как решить эту проблему иным путем или довести до ума мой способ, буду признателен.

Непосредственно мой вариант классов:

//-------TStrAnsiClass.h----------------------------------------------------------

#ifndef TStrAnsiClassH
#define TStrAnsiClassH
//---------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <alloc.h>
#include <string.h>
#include "ptypes.h"

//-------AnsiString------AnsiString--------

class AnsiString
{
friend AnsiString operator+( AnsiString &s1,  AnsiString &s2);
friend AnsiString operator+( AnsiString &s1,char *s2);
friend AnsiString operator+(char* s1,  AnsiString &s2);

private:

  int     LengthL;

public:
  AnsiString();
  AnsiString(char * stc);
  ~AnsiString();

int Length();
  AnsiString& SubString(int StartSimbol, int NumSimbols);
  char* c_str();
  int Pos(AnsiString& str);
  int Pos(char* str);

  AnsiString&  operator = ( char* );
  AnsiString & operator = (const AnsiString & );
  bool operator == (AnsiString &);
  bool operator == (char *);
  bool operator != (AnsiString &);
  bool operator != (char *);
  operator const char*();

char*   Data;
};
//--------------------TStringList---------------------------
class TSL
{
private:
AnsiString ** Str;
int maxCount;
public:
TSL();
~TSL();
void Add(AnsiString* str);
void Del(int index);
AnsiString& operator [] (int index);
int Count;
};

class TStringList
{
private:
  int maxCount;

public:
  TStringList();
  ~TStringList();
  void Clear();
  void Add(AnsiString &String);
void Add(char* String);
  void AddObject( AnsiString &String,void* Object);
  void AddObject( char* String,void* Object);
  int Count;
  TSL Strings;
  void** Objects;
  void LoadFromFile(char* FileName);
  void SaveToFile(char* FileName);
  void Delete(int index);
  int IndexOf(AnsiString & str);
  int IndexOf(char* str);
  void Assign(TStringList* Source);
  void Free();
};
typedef TStringList TStrings;
//--------------------TList--------------------------------
class TList
{
private:
  int maxCount;

public:
  TList();
  ~TList();
  void Clear();
  void Add(void * Object);
  int Count;

  void** Items;

  void Delete(int index);
  int IndexOf(void * ptr);
  void Free();

};

//--------------------TList--------------------------------
extern int AnsiCompareStr(AnsiString& S1,  AnsiString& S2);
#endif

//-------TStrAnsiClass.cpp----------------------------------------------------------

//---------------------------------------------------------------------------

#include "TStrAnsiClass.h"
#define min(a, b)  (((a) < (b)) ? (a) : (b))

//---------------------------------------------------------------------------

void CopyBuf(char* Po, char* Pi, int L)
{

    for (int i=1;i<=L;i++){
        *Po=*Pi;
        Po++;
        Pi++;
    }

}

//--------------------------------------------------------------------------
TSL::TSL()
{
Count=0;
maxCount=100;
Str=(AnsiString**)malloc(maxCount*sizeof(AnsiString*));

}
//--------------------------------------------------------------------------
TSL::~TSL()
{

for (int i=0;i<Count;i++)
delete Str[i];
free((void*)Str);

}
//--------------------------------------------------------------------------
void TSL::Add(AnsiString* str)
{
Count++;
if (Count>maxCount){
maxCount+=maxCount*2;
Str=(AnsiString**)realloc((void*)Str,maxCount*sizeof(AnsiString*));
}
Str[Count-1]=str;
}
//--------------------------------------------------------------------------
void TSL::Del(int index)
{

delete Str[index];
int idx=0;
for(int i=0;i<Count;i++)
if (i!=index){
     Str[idx]=Str[i];
idx++;
}
Count--;
}
//--------------------------------------------------------------------------
AnsiString& TSL::operator [] (int index)
{
//AnsiString* str=new AnsiString;
   //*str=Str[index]->c_str();
//return *str;
   AnsiString *str;
str=Str[index];
return *str;
}
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
TStringList::TStringList()
{
  Count                     =0;
  maxCount=100;

  Objects=(void**)malloc(maxCount*sizeof(void*));
}

//---------------------------------------------------------------------------

TStringList::~TStringList()
{
    free(Objects);
}
//---------------------------------------------------------------------------
void TStringList::Clear()
{
int c;
   c=Count;
   for (int i=0;i<c;i++)
   Delete(0);
}
//---------------------------------------------------------------------------
void TStringList::Add(AnsiString &String)
{
  Count++;
  if (Count>maxCount){
   maxCount+=maxCount*2;
    Objects=(void**)realloc((void*)Objects,maxCount*sizeof(void*));
  }

  AnsiString * sd=new AnsiString;
  *sd=String.c_str();
   Strings.Add(sd);

  Objects[Count-1]=NULL;

}
//---------------------------------------------------------------------------
void TStringList::Add(char *String)
{
  Count++;
  if (Count>maxCount){
   maxCount+=maxCount*2;
    Objects=(void**)realloc((void*)Objects,maxCount*sizeof(void*));
  }

  AnsiString * sd=new AnsiString;
  *sd=String;
   Strings.Add(sd);

  Objects[Count-1]=NULL;

}

//---------------------------------------------------------------------------
void TStringList::AddObject( AnsiString &String,void* Object)
{
  Count++;
  if (Count>maxCount){
   maxCount+=maxCount*2;
    Objects=(void**)realloc((void*)Objects,maxCount*sizeof(void*));
  }

  AnsiString * sd=new AnsiString;
  *sd=String.c_str();
   Strings.Add(sd);

  Objects[Count-1]=Object;
}
//---------------------------------------------------------------------------
void TStringList::AddObject( char* String,void* Object)
{
  Count++;
  if (Count>maxCount){
   maxCount+=maxCount*2;
    Objects=(void**)realloc((void*)Objects,maxCount*sizeof(void*));
  }

  AnsiString * sd=new AnsiString;
  *sd=String;
   Strings.Add(sd);

  Objects[Count-1]=Object;
}
//---------------------------------------------------------------------------
void TStringList::LoadFromFile(char* FileName)
{
  FILE                       *F;
  F                          = fopen(FileName, "r");
  if (F==NULL)
   return;
  fseek(F,0,SEEK_END);
  int FileSize=ftell(F);
  fseek(F,0,SEEK_SET);

  char * buf;
  buf=(char*)malloc(FileSize);
  AnsiString str;
  TStringList *t;
  t=(TStringList*)this;
  t->Clear();

  while (!feof(F))
  {
      fscanf(F, "%s\n", buf);
      //fgets(buf,FileSize,F);
      str=buf;
      t->Add(str);
  }

  free((void*)buf);

  fclose(F);

  return;

}

//---------------------------------------------------------------------------

void TStringList::SaveToFile(char* FileName)
{
  FILE                       *F;
  F                          = fopen(FileName, "w+");
  AnsiString str;

  if (F==NULL)
   return;
  for (int i=0; i<Count; i++)
    {
     str=Strings[i];
      fprintf(F, "%s\n", str.c_str());

    }
  fclose(F);

}

//---------------------------------------------------------------------------

void TStringList::Delete(int index)
{

  int idx=0;
  for (int i=0;i<Count;i++)
   if (i!=index){
   Objects[idx]=Objects[i];
      idx++;
   }

   Strings.Del(index);
  Count--;
}
//---------------------------------------------------------------------------
int TStringList::IndexOf(AnsiString & str)
{

AnsiString s;
for (int i=0;i<Count;i++){
   s=Strings[i];
if (s==str)
return i;
}

  return -1;

}
//---------------------------------------------------------------------------
int TStringList::IndexOf(char* str)
{

AnsiString s;
for (int i=0;i<Count;i++){
   s=Strings[i];
if (s==str)
return i;
}

  return -1;

}
//---------------------------------------------------------------------------
void TStringList::Assign(TStringList* Source)
{
AnsiString as;
void * ob;
for (int i=0;i<Source->Count;i++){
as=Source->Strings[i];
ob=Source->Objects[i];
   AddObject(as,ob);
}
}
//---------------------------------------------------------------------------
void TStringList::Free()
{
delete this;
}
//---------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//---AnsiString---AnsiString---AnsiString---AnsiString---AnsiString---AnsiString
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

AnsiString::AnsiString()
{
  LengthL                    =0;
}

//---------------------------------------------------------------------------
AnsiString::AnsiString(char * stc)
{
   int newLengthL=0;
    if (stc!=NULL)
    newLengthL               =strlen(stc);
    if (newLengthL>0)
      Data                   =(char*)malloc(newLengthL+1);
    /*else
    ;  if (newLengthL>0)
      Data                   =(char*)realloc(Data,newLengthL+1);
      else
       free(Data);*/

    LengthL                  =newLengthL;
    if (LengthL>0)
    strcpy(Data, stc);
    else
     Data=NULL;
}

//---------------------------------------------------------------------------
AnsiString::~AnsiString()
{
  if (LengthL>0)
  free(Data);
}

//---------------------------------------------------------------------------

int AnsiString::Length()
{
  return LengthL;
}

//---------------------------------------------------------------------------
int AnsiString::Pos(AnsiString &str)
{
char *s=str.Data;
char *d=this->Data;
int ls,ld;
ls=str.Length();
ld=this->LengthL-ls;
if (ls>ld || ld==0 || ls==0) return 0;
  bool bl;
for (int i=0;i<=ld;i++){
bl=true;
   for (int j=0;(j<ls && bl);j++)
if (d[i+j]!=s[j])
bl=false;
if (bl)
return i+1;
}
  return 0;

}
//---------------------------------------------------------------------------
int AnsiString::Pos(char *str)
{
char *s=str;
char *d=this->Data;
int ls,ld;
ls=strlen(s);
ld=this->LengthL-ls;
if (ls>ld || ld==0 || ls==0) return 0;
  bool bl;
for (int i=0;i<=ld;i++){
bl=true;
   for (int j=0;(j<ls && bl);j++)
if (d[i+j]!=s[j])
bl=false;
if (bl)
return i+1;
}
  return 0;

}
//---------------------------------------------------------------------------
AnsiString& AnsiString::SubString(int StartSimbol, int NumSimbols)
{
  char * dst;
  char * src;
  dst=(char*)malloc(NumSimbols+1);
  src=Data;
  src+=(StartSimbol-1);
  CopyBuf(dst,src,NumSimbols);
  dst[NumSimbols]=NULL;
  AnsiString *sd=new AnsiString;
  *sd=dst;
  free((void*)dst);
  return *sd;
}

//---------------------------------------------------------------------------

char* AnsiString::c_str()
{
  return Data;
}
//----------------------------------------------------------------------------
AnsiString&  AnsiString::operator = ( char* stc)
{

   int newLengthL=0;
    if (stc!=NULL)
    newLengthL               =strlen(stc);
    if (LengthL==0 && newLengthL>0)
      Data                   =(char*)malloc(newLengthL+1);
    else
      if (newLengthL>0)
      Data                   =(char*)realloc(Data,newLengthL+1);
      else
         if (LengthL>0)
       free(Data);

    LengthL                  =newLengthL;
    if (LengthL>0)
    strcpy(Data, stc);
    else
     Data=NULL;

    return *this;

}
//---------------------------------------------------------------------------
AnsiString& AnsiString::operator = (const AnsiString &sta)

{
char * stc=sta.Data;

   int newLengthL=0;
    if (stc!=NULL)
    newLengthL               =strlen(stc);
    if (LengthL==0 && newLengthL>0)
      Data                   =(char*)malloc(newLengthL+1);
    else
      if (newLengthL>0)
      Data                   =(char*)realloc(Data,newLengthL+1);
      else
         if (LengthL>0)
       free(Data);

    LengthL                  =newLengthL;
    if (LengthL>0)
    strcpy(Data, stc);
    else
     Data=NULL;

    return *this;
}
//---------------------------------------------------------------------------
AnsiString  operator+( AnsiString &s1, AnsiString &s2)
{

int l1,l2;
   l1=s1.Length();
   l2=s2.Length();
   AnsiString* sd=new AnsiString;

   char *cd;
   cd=(char*)malloc(l1+l2+1);
   CopyBuf(cd,s1.c_str(),l1);
   cd+=l1;
CopyBuf(cd,s2.c_str(),l2);
   cd+=l2;
   cd[0]=NULL;
   cd-=(l1+l2);
   sd->LengthL=l1+l2;
   sd->Data=cd;
   return *sd;

}
//---------------------------------------------------------------------------
AnsiString operator+( AnsiString &s1,char *s2)
{
int l1,l2;
   l1=s1.Length();
   l2=0;
   if (s2!=NULL)
   l2=strlen(s2);
   AnsiString* sd=new AnsiString;

   char *cd;
   cd=(char*)malloc(l1+l2+1);
   CopyBuf(cd,s1.c_str(),l1);
   cd+=l1;
CopyBuf(cd,s2,l2);
   cd+=l2;
   cd[0]=NULL;
   cd-=(l1+l2);
   sd->LengthL=l1+l2;
   sd->Data=cd;
   return *sd;
}
//---------------------------------------------------------------------------
AnsiString operator+(char* s1,  AnsiString &s2)
{
int l1,l2;
   l2=s2.Length();
   l1=0;
   if (s1!=NULL)
   l1=strlen(s1);
   AnsiString* sd=new AnsiString;

   char *cd;
   cd=(char*)malloc(l1+l2+1);
   CopyBuf(cd,s1,l1);
   cd+=l1;
CopyBuf(cd,s2.c_str(),l2);
   cd+=l2;
   cd[0]=NULL;
   cd-=(l1+l2);
   sd->LengthL=l1+l2;
   sd->Data=cd;
   return *sd;
}
//---------------------------------------------------------------------------
bool AnsiString::operator == (AnsiString & str)
{
int c;
char *sc;
sc=str.Data;
int l;
l=str.Length();
if (l!=LengthL) return false;
      if (LengthL==0) return true;
  c=strcmp(sc,Data);
bool bl;
  bl=(c==0);
return bl;
}
//---------------------------------------------------------------------------
bool AnsiString::operator == (char * str)
{
int c;
char *sc;
sc=str;
int l;
l=strlen(str);
if (l!=LengthL) return false;
   if (LengthL==0) return true;
  c=strcmp(sc,Data);
bool bl;
  bl=(c==0);
return bl;
}
//---------------------------------------------------------------------------
bool AnsiString::operator != (AnsiString & str)
{
int c;
char *sc;
sc=str.Data;
int l;
l=str.Length();
if (l!=LengthL) return true;
      if (LengthL==0) return true;
  c=strcmp(sc,Data);
bool bl;
  bl=(c==0);
return !bl;
}
//---------------------------------------------------------------------------
bool AnsiString::operator != (char * str)
{
int c;
char *sc;
sc=str;
int l;
l=strlen(str);
if (l!=LengthL) return true;
      if (LengthL==0) return tr

• замена vcl-классов, ihor, 01:48 , 25-Июл-04, (1)
  • замена vcl-классов, DiS, 13:38 , 25-Июл-04, (2)