关于如何来构造一个String类

  今天帮着一位大二的学弟写了一个String的类，后来一想这个技术点，也许不是什么难点，但是还是简单的记录一些吧！ 为那些还在路上爬行的行者，剖析一些基本的实现.....

  内容写的过于简单，没有涉及到其他格式的如考虑utf_8.这儿单纯的考虑了char的使用.......

     

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<windows.h>
using namespace std;

class MyString {

public :
    MyString(const char * str = NULL) ;  //默认构造函数
    MyString(const MyString  & mystr);  //复制构造函数
    ~MyString() {
        if (test != NULL) delete[] test;
    };
        //析构函数
    int length();  //返回字符串长度
    void print();  //打印
    char at(int pos) ;  //查找第i个字符
    MyString & operator = (const MyString  &other); //等号操作符重载
   MyString & operator = (const  char  * str ); //等号操作符重载
private:
    char * test;
};

//构造函数
MyString::MyString(const  char * str) {


    if (str == NULL)
    {
        test = new char[1];
        *test = '';
    }
    else
    {
        int length = strlen(str);
        test = new char[length + 1];
        strcpy(test, str);  //复制
    }
}

MyString::MyString(const MyString  & mystr)   //复制构造函数
{
    char * pstr = mystr.test; 
    test = new char [strlen(pstr)+1];  //开辟空间
    strcpy(test, mystr.test);    //复制类容
}

//返回长度
int MyString::length() {
    
    int i = 0;
    if (test == NULL) return 0;
    while (test[i] != '') i++;
    return i;
}

void MyString::print() {

    if (test != NULL) {
        //printf("%s
",test);
         puts(test);  //这样可以输出空格
    }
}

char MyString::at(int pos) {

    if (test != NULL) {
        int len = strlen(test);
        if (len <=pos) {
            throw out_of_range("位置超过字符串长度！");
        }
        else {
            return test[pos];
        }
    } {
        throw out_of_range("字符串为空！");
    }
}

MyString & MyString::operator =(const MyString & aa)
{
    if (this == &aa)//当地址相同时，直接返回；
        return *this;
        delete[] test;//当地址不相同时，删除原来申请的空间，重新开始构造；
    int length = strlen(aa.test);
    test = new char [length + 1];
    strcpy(test, aa.test);
    return *this;
  
}

MyString & MyString::operator = (const  char  * str) //等号操作符重载
{

    MyString  * ss = new MyString (str);
    return *ss;
}


int main(){

    char *pp = "sadasd";
    MyString  aa = "abcd";
    aa.print();  //显示
    cout << "长度为：" << aa.length();
    cout << "显示abcd第二个元素的内容"<<aa.at(1)<<endl;
    
    MyString  *str = new MyString(pp);  //对于指针而言
    str->print();
    cout << "长度为：" << str->length();
    cout << "显示sadasd第二个元素的内容" << str->at(1)<<endl;

    MyString  bb(aa);  //对于复制构造函数而言
    bb.print();
    cout << "长度为：" << bb.length();
    cout << "显示abcd第二个元素的内容" << bb.at(1)<<endl;
    str->print();
    getchar();
}

对于这一点，后来又加深了一些基本模式，简略的实现以下String类吧！

  

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;

template < typename  T >

class MyString {

public :

    MyString(const T * str = NULL) ;
        //默认构造函数
    MyString(const MyString<T>  & mystr);  //复制构造函数
    ~MyString() {
        if (test != NULL) delete[] test;
    };
        //析构函数
    int length();  //返回字符串长度
    void print();  //打印
    T at(int pos);
    MyString<T> & operator + (const MyString<T>  &aa); //等号操作符重载
    MyString<T> & operator + (const  T  * str); //等号操作符重载
    MyString<T> & operator = (const MyString<T>  &aa); //等号操作符重载
    MyString<T> & operator = (const  T  * str );     //等号操作符重载

private:
    T * test;

};

template < typename  T >
MyString<T> &  MyString<T>::operator + (const MyString<T>  &aa) {
    
    T  *str =test;
    int lena = -1 , lenb=-1;
       lena=strlen(aa.test);
       lenb = strlen(test);
       if (lena> 0) {
           test = new T[lena+lenb];
           strcpy(test, strcat(str, aa.test));

       }
       return *this;
}


template < typename  T >
MyString<T> & MyString<T>::operator + (const T * str) {

    T  * str = test;
    int lena = -1, lenb = -1;
    lena = strlen(str);
    lenb = strlen(test);
    if (lena > 0) {
            test = new T[lena + lenb];
        strncpy(test, strcat(str, str));
    }
    return *this;
}

//构造函数
template < typename  T >
MyString<T>::MyString(const  T * str) {


    if (str == NULL)
    {
        test = new T[1];
        *test = '';
    }
    else
    {
        int length = strlen(str);
        test = new T[length + 1];
        strcpy(test, str);  //复制
    }
}

template < typename  T >
MyString<T>::MyString(const MyString<T>  & mystr)   //复制构造函数
{
    T * pstr = mystr.test; 
    test = new T [strlen(pstr)+1];  //开辟空间
    strcpy(test, mystr.test);    //复制类容
}

//返回长度
template < typename  T >
int MyString<T>::length() {
    
    int i = 0;
    if (test == NULL) return 0;
    while (test[i] != '') i++;
    return i;
}
template < typename  T >
void MyString<T>::print() {

    if (test != NULL) {
        //printf("%s
",test);
         puts(test);  //这样可以输出空格
    }
}
template < typename  T >
T MyString<T>::at(int pos) {

    if (test != NULL) {
        int len = strlen(test);
        if (len <=pos) {
            throw out_of_range("位置超过字符串长度！");
        }
        else {
            return test[pos];
        }
    } {
        throw out_of_range("字符串为空！");
    }
}

template < typename  T >
MyString<T> & MyString<T>::operator =(const MyString<T> & aa)
{
    if (this == &aa)//当地址相同时，直接返回；
        return *this;
        delete[] test;//当地址不相同时，删除原来申请的空间，重新开始构造；
    int length = strlen(aa.test);
    test = new T [length + 1];
    strcpy(test, aa.test);
    return *this;
  
}

template < typename  T >
MyString<T> & MyString<T>::operator = (const  T  * str) //等号操作符重载
{

    MyString<T>  * ss = new MyString<T> (str);
    return *ss;
}


int main(){

    char *pp = "sadasd";
    MyString<char> aa = "abcd";
    aa.print();  //显示
    cout << "长度为：" << aa.length();
    cout << "显示abcd第二个元素的内容"<<aa.at(1)<<endl;
    
    MyString<char>  *str = new MyString<char>(pp);  //对于指针而言
    str->print();
    cout << "长度为：" << str->length();
    cout << "显示sadasd第二个元素的内容" << str->at(1)<<endl;

    MyString<char>  bb(aa);  //对于复制构造函数而言
    bb.print();
    cout << "长度为：" << bb.length();
    cout << "显示abcd第二个元素的内容" << bb.at(1)<<endl;
    str->print();
    MyString<char>  sc="你好，北京人";
    sc.print();
    sc = sc + bb;
    sc.print();
    getchar();
    return 0;
}

  String类的先关补充.....

/*
String类的功能为：
  1.构造函数
  2.重载赋值操作符
  3.重载下标操作符
  4.重载关系操作符
  5.重载转换操作符
  6.析构函数
*/
#include<iostream>
#include<string.h>
#include<assert.h>
#include<string>
using namespace std;



class String {

    //重载输出操作符
    friend ostream & operator << (ostream &out, String & str);
    friend istream & operator >> (istream &in, String & str);
    //重载关系操作符
    friend bool operator == (const String &src , const String &op);
    friend bool operator != (const String &src, const String &op);
    friend bool operator  < (const String &src, const String &op);
public :
    //定义构造函数
    String();  //default
    String(const char * str); //elements
    String(const String &str); //copy
   //重载赋值操作符
    String & operator =(const String & str);
    String & operator =(const char * str);
    String & operator =(const char str);
    //+=重载运算操作符
    String & operator +=(const String & str);
    String & operator +=(const char * str);
    String & operator +=(const char str);

   //重载[]操作符
    char & operator [] (int index );
    //重载转换操作符
    operator char*();
    ~String();
private:
    char *gg  ;      //字符指针
};

ostream & operator << (ostream &out, String & str) {
    out << str.gg ;
    return  out;
}

istream & operator >> (istream &in, String & str)
{
    in >> str.gg;
    return in ;
}

bool operator == (const String &src, const String &op) {
    return strcmp(src.gg , op.gg) == 0;
}

bool operator != (const String &src, const String &op)
{
    return strcmp(src.gg , op.gg )!=0;
}

bool operator  < (const String &src, const String &op) {
    return strcmp(src.gg ,op.gg )<0;
}

String::String() {
    gg = new char[1];
    gg = '';
};

String::String(const char * str) {
    int var = strlen(str);
    gg = new char[var+1];
    strcpy(gg ,str);
}

String::String(const String &str) {
    int var = strlen(str.gg);
    gg = new char[var + 1];
    strcpy(gg, str.gg);
}


String & String::operator =(const String & str) {
    if (this == &str) return *this;
    delete gg;
    int var = strlen(str.gg);
    gg = new char[var + 1];
    strcpy(gg, str.gg);
    gg[var] = '';
    return  *this;
}

char & String::operator [] (int index) {
    assert(index>=0&&index<strlen(gg));
    return gg[index];
}


String & String::operator =(const char * str) {
    if (strcmp(gg,str)==0) return *this;
    int var = strlen(str);
    gg = new char(var + 1);
    strcpy(gg, str);
    gg[var] = '';
    return *this;
}

String & String::operator = (const char str) {

    gg = new char(2);
    gg[0] = str;
    gg[1] = '';
    return *this;
}

String::operator char *() {
    return gg;
}

String::~String() {
    delete gg;
}

String & String::operator +=(const String & str) {
    int var = strlen(str.gg);
    if (gg == NULL)
    {
        gg = new char(var+1);
        strcpy(gg,str.gg);
        gg[var] = '';
    }
    else {
        char *p = gg;
        int vat = strlen(p) + var;
        gg = new char(vat+var);
        strcpy(gg,p);
        delete p;
        strcat(gg,str.gg);
        gg[vat] = '';
    }
    return *this;
}

String & String::operator +=(const char * str) {

    int var = strlen(str);
    if (gg == NULL)
    {
        gg = new char(var + 1);
        strcpy(gg, str);
        gg[var] = '';
    }
    else {
        char *p = gg;
        int vat = strlen(p) + var;
        gg = new char(vat + var);
        strcpy(gg, p);
        delete p;
        strcat(gg, str);
        gg[vat] = '';
    }
    return *this;

}
String & String::operator +=(const char str) {

    if (gg == NULL)
    {
        gg = new char(2);
        gg[0] == str;
        gg[1] = '';
    }
    else {
        char *p = gg;
        int vat = strlen(p)+1;
        gg = new char(vat + 2);
        strcpy(gg, p);
        delete p;
        gg[vat - 1] = str;
        gg[vat] = '';
    }
    return *this;
}