String类封装

//Node.h


typedef int Node_entry;

typedef int Node_entry;
enum Error_code {success, overflow, underflow, rangeError};
template <class Node_entry>
struct Node {
    Node_entry entry;
    Node<Node_entry> *next;
    Node();
    Node(Node_entry item, Node<Node_entry> *link = NULL);
};

template <class Node_entry>
Node<Node_entry>::Node()
{
    next = NULL;
}

template <class Node_entry>
Node<Node_entry>::Node(Node_entry item, Node<Node_entry> *link)
{
    entry = item;
    next = link;
}

//List.h

#include "Node.h"
template<class List_entry>
class List {
public:
    List();
    ~List();
    bool empty() const;
    List(const List<List_entry> ©);
    List<List_entry> operator = (const List<List_entry> ©);
    Error_code insert(int position, const List_entry &x);
    Error_code retrieve(int position, List_entry &x);
    Error_code replace(int position, const List_entry &x);
    Error_code remove(int position);
    int size() const;
    void clear();
protected:
    int count;
    Node<List_entry> *head;
    Node<List_entry> *set_position(int position) const;
};

template<class List_entry>
Error_code List<List_entry>::remove(int position)
{
    if (count == 0) return underflow;
    if (position < 0 || position >= count) return rangeError;
    Node<List_entry> *t, *target = set_position(position - 1);
    t = target->next;
    target->next = target->next->next;
    delete t;
    return success;
}

template<class List_entry>
Error_code List<List_entry>::replace(int position, const List_entry &x)
{   if (position < 0 || position > count) return rangeError;
    Node<List_entry> *target = set_position(position);
    target->entry = x;
    return success;
}

template<class List_entry>
int List<List_entry>::size() const
{
    return count;
}

template<class List_entry>
List<List_entry> List<List_entry>::operator = (const List<List_entry> ©)
{
    List<List_entry> new_list(copy);
    clear();
    head = new_list.head;
    count = new_list.count;
    new_list.count = 0;
    new_list.head = NULL;
    return *this;
}


template<class List_entry>
void List<List_entry>::clear()
{   
    Node<List_entry> *t = head;
    while (!empty()) {
    head = t->next;
    delete t;
    t = head;
    }
}

template<class List_entry>
bool List<List_entry>::empty() const
{
    return head == NULL;
}

template<class List_entry>
List<List_entry>::~List()
{
    clear();
}

template<class List_entry>
Error_code List<List_entry>::retrieve(int position, List_entry &x)
{
    if (position < 0 || position > count)
        return underflow;
    Node<List_entry> *t = set_position(position);
        x = t->entry;
    return success;
}
    
template<class List_entry>
List<List_entry>::List(const List<List_entry> ©)
{
    Node<List_entry> *new_node, *copy_copy = copy.head;
    if (copy.head == NULL) 
          head = NULL;
    else {
           head = new_node = new Node<List_entry>(copy.head->entry);
           while (copy_copy->next != NULL) {
               copy_copy = copy_copy->next;
               new_node->next = new Node<List_entry>(copy_copy->entry);
               new_node = new_node->next;
           }
    }
    count = copy.count;
}

template<class List_entry>
List<List_entry>::List()
{   head = NULL;
    count = 0; 
}



template<class List_entry>
Node<List_entry> *List<List_entry>::set_position(int position) const
{
    Node<List_entry> *q = head;
    for (int i = 0; i < position; i++)
        q = q->next;
    return q;
}

template<class List_entry>
Error_code List<List_entry>::insert(int position, const List_entry &x)
{
    if (position < 0 || position > count)
        return rangeError;
    Node<List_entry> *new_node, *previous, *following;
    if (position > 0) {
        previous = set_position(position - 1);
        following = previous->next;
    }
    else following = head;
    new_node = new Node<List_entry>(x, following);
    if (new_node == 0)
        return overflow;
    if (position == 0)
        head = new_node;
    else
        previous->next = new_node;
    count++;
    return success;
}

//String.h

#include <cstring>
#include <iostream>

#include "List.h"
class String {
public:
    String();
    ~String();
    String(const String ©);
    String(const char *copy);
    String(List<char> ©);
    String& operator = (const String ©);
    const char *c_str() const;
    void test();
protected:
    char *entries;
    int length;
};

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);


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;
}

const char* String::c_str() const
{
    return (const char *)entries;
}

String& String::operator = (const String ©)
{
    delete [] entries;
    length = copy.length;
    entries = new char[length + 1];
    strcpy(entries, copy.entries);
    return *this;
}
    

void String::test()
{
    std::cout << entries ;
}

String::String(const char *in_string)
{
    length = strlen(in_string);
    entries = new char[length + 1];
    strcpy(entries, in_string);
}

String::String(List<char> &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';
}

String::String()
{
    length = 0;
    entries = new char[1];
    strcpy(entries, "");
}

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

String::String(const String ©)
{
    length = copy.length;
    entries = new char[length + 1];
    for (int i = 0; i < length; i++) 
        entries[i] = copy.entries[i];
    entries[length] = '\0';
}

//trial.cpp

#include <iostream>
#include "String.h"
using namespace std;
class String;
void main()
{
    String a("ttt");
    String b;
    String c;
    b = c = a;
    a.test();
    cout << endl;
    b.test();
    cout << endl;
    c.test();
    cout << c.c_str() << endl;
    bool x = (a != b);
    cout << x;
    system("pause");
    return;
}