یه String جدید بسازید !

[مهدی رحیم زاده]

سلام من یه برنامه دارم که توی اون باید یه String جدید بسازم که این قابلیت ها رو داشته باشه :
1- سایز رشته نا محدود باشه .
2- تمام توابع کتابخانه ای String در موردش کار کنه .
3- تمام عملگر های ریاضی و منطقی در موردش کار کنه .
خوب حالا پیشنهاد شما چیه برای حل این مسئله ؟ من می خوام از یک درخت برای ایجاد رشته استفاده کنم که توی هر نود یک کاراکتر از این رشته نامحدود ذخیره میشه .
ممنون میشم زو راهنمایی کنیدم .

[sasan_vm]

سلام
این مسئله با استفاده از ارایه پویا حل میشه نیازی به استفاده از ساختار درخت نیست.
نمونه یک کلاس که برای کار با آرایه پویا نوشته بودم می فرستم. کامل نیست ولی برای شروع بد نیست. :چشمک:


//------------------------------------------------------------------------------
template <class T> class VArray
{
private:
T * PtrData;
int FSize;
void __fastcall NewMem(int Value)
{
PtrData = new T[Value];
FSize = Value;
for (int i = 0; i < FSize; i++)
Data[i] = 0;
}
void __fastcall Free()
{
if (PtrData)
{
delete PtrData;
PtrData = NULL;
}
FSize = 0;
}
void __fastcall CheckIndex(int Index)
{
if (FSize == 0)
throw Exception("VArray <T> Zero size.");
if (Index < 0 || Index >= FSize)
throw Exception("VArray <T> out of range.");
}
void __fastcall SetSize(int Value)
{
if (FSize != Value)
{
if (FSize > 0)
{
int i, min, size = FSize;
VArray <T> temp(size);
for (i = 0; i < size; i++)
temp[i] = Data[i];
Free();
if (Value)
{
NewMem(Value);
min = FSize < size ? FSize : size;
for (i = 0; i < min; i++)
Data[i] = temp[i];
}
}
else
{
Free();
NewMem(Value);
}
}
}
void __fastcall QuickSort(int iLo, int iHi)
{
int Lo, Hi;
T Mid, Tmp;
Lo = iLo;
Hi = iHi;
Mid = Data[(Lo + Hi) / 2];
do
{
while (Data[Lo] < Mid) Lo++;
while (Data[Hi] > Mid) Hi--;
if (Lo <= Hi)
{
Tmp = Data[Lo];
Data[Lo] = Data[Hi];
Data[Hi] = Tmp;
Lo++;
Hi--;
}
}
while (Lo <= Hi);
if (Hi > iLo) QuickSort(iLo, Hi);
if (Lo < iHi) QuickSort(Lo, iHi);
}
public:
__fastcall VArray(int size)
{
FSize = size;
PtrData = NULL;
NewMem(size);
}
__fastcall VArray (const VArray <T> & Other) // Copy constructor
{
NewMem(Other.Size);
for (int i = 0; i < FSize; i++)
Data[i] = Other.Data[i];
}
__fastcall ~VArray()
{
Free();
}
T & __fastcall operator [] (int Index)
{
CheckIndex(Index);
return PtrData[Index];
}
VArray <T> & __fastcall operator = (const VArray <T> & Other)
{
Size = Other.Size;
for (int i = 0; i < FSize; i++)
Data[i] = Other.Data[i];
return *this;
}
VArray <T> & __fastcall operator += (const VArray <T> & Other)
{
*this = *this + Other;
return *this;
}
bool __fastcall operator == (const VArray <T> & Other)
{
bool res;
res = Size == Other.Size;
for (int i = 0; res && i < Size; i++)
res = Data[i] == Other.Data[i];
return res;
}
bool __fastcall operator != (const VArray <T> & Other)
{
bool res;
res = !(*this == Other);
return res;
}
friend VArray <T> __fastcall operator + (const VArray <T> & One, const VArray <T> & Two)
{
int i, j;
VArray <T> sum (One.Size + Two.Size);
for (i = 0, j = 0; i < One.Size; i++, j++)
sum[j] = One.Data[i];
for (i = 0; i < Two.Size; i++, j++)
sum[j] = Two.Data[i];
return sum;
}
VArray <T> __fastcall SubArray(int Index, int Count) // Zero base index
{
int i, Len, Last;
CheckIndex(Index);

Len = Count;
Last = Index + Count - 1;
Last = Last < FSize ? Last : FSize - 1;
Len = Last - Index + 1;
VArray <T> sub(Len);
for ( i = 0; i < Len; i++ )
sub[i] = Data[Index+i];
return sub;
}
int __fastcall IndexOf(const T & Item)
{
int i, res;
res = -1;
for (i = 0; res < 0 && i < FSize; i++)
if (Data[i] == Item)
res = i;
return res;
}
void __fastcall Delete(int Index)
{
int i, last;
CheckIndex(Index);
last = FSize - 1;
for (int i = Index; i < last; i++)
Data[i] = Data[i + 1];
Size = FSize - 1;
}
void __fastcall Remove(const T & Item, bool All = false)
{
int idx;
do
{
idx = IndexOf(Item);
if (idx > -1)
Delete(idx);
}
while (idx != -1 && All);
}
void __fastcall Add(const T & Item)
{
Size = FSize + 1;
Data[FSize - 1] = Item;
}
void __fastcall Insert(int Index, const T & Item)
{
int i, last;
CheckIndex(Index);
Size = FSize + 1;
last = FSize - 1;
for (i = last; i >= Index; i--)
Data[i] = Data[i-1];
Data[Index] = Item;
}
void __fastcall Sort()
{
if (FSize)
QuickSort(0, FSize - 1);
}
__property int Size = { read = FSize, write = SetSize }; // For removing all data set size to 0
__property T * Data = { read = PtrData };
};
//------------------------------------------------------------------------------

[مهدی رحیم زاده]

میدونید من نباید از توابع سیستم استفاده کنم ، بلکه خودم باید اونا رو طراحی کنم .
به نظر شما برای این کارا کار با آرایه بهتره یا نه لیست پیوندی ؟

[مهدی رحیم زاده]

من این کدو نوشتم اما بعد از اینکه یه تعدادی رشته رو از ورودی می گیره گیر میکنه ، چکار کنم که درست بشه ؟؟؟

#include <stdio.h>
#include <iostream.h>
#include <stdlib.h>
#include <conio.h>

//For Create a Node
class Node{
friend class LinkList;
char strchar;
Node *next;
};
//Now Create Linklist class
class LinkList{
public:
LinkList();
~LinkList();
void AddElement();
private:
Node *first;
Node *last;
};
//
void LinkList::LinkList()
{
first=last=NULL;
}
//
void LinkList::~LinkList()
{
Node *curptr=first;
Node *temp;
while(curptr)
{
temp=curptr;
curptr=curptr->next;
delete temp;
}
}
//Add Element
void LinkList::AddElement()
{
Node *newptr=new Node;
newptr -> next = NULL;//For Show End of String
cin>>newptr->strchar;//get a character from Keyboard
if (first==NULL)
first=last=newptr;
else
{
last->next = newptr;
last=newptr;
}
}
//Main Program
void main(void)
{
LinkList String;
for(;;)
{
String.AddElement();
}
}

[A.S.Roma]

با سلام

این برنامه رو نوشتم فکر کنم همونیه که می خواهید .


#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

#define NUM 4

struct Node
{
char x;
Node *next;
};

Node * CreateNode(char x)
{
Node *p;
p = (Node *)malloc(sizeof(Node));
p->next=NULL;
p->x=x;
return p;
}

class String
{
Node *start;
public:
String();
String(Node *);
~String();
void Print();
void DisAllocate();
void AddNode(Node *newNode);
void GetStr();
void Remove();
};

String::String(Node *a)
{
DisAllocate();
start = a;
}

String::String()
{
start = NULL;
}

String::~String()
{
DisAllocate();
}


void String::DisAllocate()
{
if(start)
delete start;
}

void String::AddNode(Node *newNode)
{
Node *p=start;
if(p==NULL)
{
start=newNode;
return;
}
while(p->next!=NULL)
p=p->next;
p->next = newNode;


}

void String::GetStr()
{
char temp;
do
{
temp = getche();
AddNode(CreateNode(temp));
}while(temp != 13);
}


void String::Print()
{
if(!start)
{
printf("String is Empty ...\n");
return;
}
Node *p=start;
while(p!=NULL)
{
printf("%c",p->x);
p=p->next;
}
}

void main()
{
String s[4];
char temp;
Node *start = NULL;
clrscr();
for(int i=0;i<NUM;i++)
{
s[i].GetStr();
printf("\n");
}
printf("\n\n");
for( i=0;i<NUM;i++)
{
s[i].Print();
printf("\n");
}
getch();
}




مقدار NUM رو هر مقدار بگذارید به همون مقدار رشته تولید می کند.
OverLoad کردن Operator ها با خودتان .