关于如何来构造一个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[];
         *test = '\0';
     }
     else
     {
         int length = strlen(str);
         test = new char[length + ];
         strcpy(test, str);  //复制
     }
 }

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

 //返回长度
 int MyString::length() {

     int i = ;
     if (test == NULL) return ;
     while (test[i] != '\0') i++;
     return i;
 }

 void MyString::print() {

     if (test != NULL) {
         //printf("%s\n",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 + ];
     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()<<endl;

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

     MyString  bb(aa);  //对于复制构造函数而言
     bb.print();
     cout << "长度为：" << bb.length();
     cout << "显示abcd第二个元素的内容" << bb.at()<<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 = - , lenb=-;
        lena=strlen(aa.test);
        lenb = strlen(test);
        if (lena> ) {
            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 = -, lenb = -;
     lena = strlen(str);
     lenb = strlen(test);
     if (lena > ) {
             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[];
         *test = '\0';
     }
     else
     {
         int length = strlen(str);
         test = new T[length + ];
         strcpy(test, str);  //复制
     }
 }

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

 //返回长度
 template < typename  T >
 int MyString<T>::length() {

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

     if (test != NULL) {
         //printf("%s\n",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 + ];
     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()<<endl;

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

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

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

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

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

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

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

 String::String(const String &str) {
     int var = strlen(str.gg);
     gg = new char[var + ];
     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 + ];
     strcpy(gg, str.gg);
     gg[var] = '\0';
     return  *this;
 }

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

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

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

     gg = new char();
     gg[] = str;
     gg[] = '\0';
     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+);
         strcpy(gg,str.gg);
         gg[var] = '\0';
     }
     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] = '\0';
     }
     return *this;
 }

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

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

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

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