string.h

Editor C++ 源程序 用链表实现

class String {
public:                           //  methods of the string ADT
   String();
   ~String();
   String (const String &copy);   //  copy constructor
   String (const char * copy);    //  conversion from C-string
   String (List<char> &copy);     //  conversion from List

   void operator =(const String &copy);
   const char *c_str() const;     //  conversion to C-style string

protected:
   char *entries;
   int length;
};


String read_in(istream &input);
String read_in(istream &input,char &terminal_char);
void write(String &s);
void strcat(String &add_to, const String &add_on);
void strcpy(String &copy, const String &original);
void strncpy(String &copy, const String &original, int n);
int strstr(const String &text, const String &target);
bool operator ==(const String &first, const String &second);
bool operator <(const String &first, const String &second);
bool operator >(const String &first, const String &second);
bool operator <=(const String &first, const String &second);
bool operator >=(const String &first, const String &second);
bool operator !=(const String &first, const String &second);


String::String()
{
   length = 0;
   entries = NULL;
}


String::~String()
{
   delete []entries;
}


String::String (const String &copy)
{
   length = strlen(copy.c_str());
   entries = new char[length + 1];
   strcpy(entries, copy.c_str());
}


String::String (const char *in_string)
/*
Pre:  The pointer in_string references a C-string.
Post: The String is initialized by the C-string in_string.
*/
{
   length = strlen(in_string);
   entries = new char[length + 1];
   strcpy(entries, in_string);
}


String::String (List<char> &in_list)
/*
Post: The String is initialized by the character List in_list.
*/
{
   length = in_list.size();
   entries = new char[length + 1];
   for (int i = 0; i < length; i++) in_list.retrieve(i,entries[i]);
   entries[length] = '\0';
}


void String::operator =(const String &copy)
{
   delete []entries;
   length = strlen(copy.c_str());
   entries = new char[length + 1];
   strcpy(entries, copy.c_str());
}


const char*String::c_str() const
/*
Post: A pointer to a legal C-string object matching the String is returned.
*/
{
   return (const char *) entries;
}


void strcat(String &add_to, const String &add_on)
/*
Post: The function concatenates String add_on onto the end of String add_to.
*/
{
   const char *cfirst = add_to.c_str();
   const char *csecond = add_on.c_str();
   char *copy = new char[strlen(cfirst) + strlen(csecond) + 1];
   strcpy(copy, cfirst);
   strcat(copy, csecond);
   add_to = copy;
   delete []copy;
}


String read_in(istream &input)
/*
Post: Return a String read (as characters terminated
      by a newline or an end-of-file character) from an istream parameter.
*/
{
   List<char> temp;
   int size = 0;
   char c;
   while ((c = input.peek()) != EOF && (c = input.get()) != '\n')
      temp.insert(size++, c);
   String answer(temp);
   return answer;
}


String read_in(istream &input,char &terminal_char)
/*
Post: Return a String read (as characters terminated
      by a newline or an end-of-file character) from an istream parameter.
*/
{
   List<char> temp;
   int size = 0;
   char c;
   while ((c = input.peek()) != EOF && (c = input.get()) != '\n')
      temp.insert(size++, c);
   terminal_char=c;
   String answer(temp);
   return answer;
}


void write(String &s)
/*
Post: The String parameter s is written to cout.
*/
{
   cout << s.c_str() << endl;
}


void strcpy(String &copy, const String &original)
{
   const char *coriginal = original.c_str();
   char *ccopy = new char[strlen(coriginal) + 1];
   strcpy(ccopy, coriginal);
   copy = ccopy;
   delete []ccopy;
}


void strncpy(String &copy, const String &original, int n)
{
   const char *coriginal = original.c_str();
   int len=strlen(coriginal)<n?strlen(coriginal):n;
   char *ccopy = new char[len+1];
   strncpy(ccopy, coriginal,n);
   ccopy[len]='\0';
   copy = ccopy;
   delete []ccopy;
}


int strstr(const String &text, const String &target)
{
   const char *ctext = text.c_str();
   const char *ctarget = target.c_str();
   char *ptr=strstr(ctext, ctarget);
   if(ptr==NULL)return -1; 
   else return ptr - ctext;
}


bool operator ==(const String &first, const String &second)
{
   return strcmp(first.c_str(), second.c_str()) == 0;
}


bool operator <(const String &first, const String &second)
{
   return strcmp(first.c_str(), second.c_str()) < 0;
}


bool operator >(const String &first, const String &second)
{
   return strcmp(first.c_str(), second.c_str()) > 0;
}


bool operator <=(const String &first, const String &second)
{
   return strcmp(first.c_str(), second.c_str()) <= 0;
}


bool operator >=(const String &first, const String &second)
{
   return strcmp(first.c_str(), second.c_str()) >= 0;
}

bool operator !=(const String &first, const String &second)
{
   return strcmp(first.c_str(), second.c_str()) != 0;
}