/*基于char*.设计一个字符串MyString并且具有构造函数，析构函数，复制构造函数，并在其中加入重载运算符，使之能满足各种需求
string s1="abc",s2="def";
string s3=s1+s2;         结果是“abcdef”
char s5=s2[1];           结果是“e”*/
#include <iostream>
#include <string>
using namespace std;

class MyString
{
private:
    int i;
    char* string;   
public:
    MyString( )                      //构造函数
    {
        string = new char [1];
        string[0] = '\0';
        i=1;
    }
    ~MyString()                      //析构函数
    {
        delete [] string;
    }
    MyString(const MyString &rhs)    //复制构造函数
    {
        i=strlen(rhs.string);
        string = new char [i+1];
        string[i] = '\0';
        //strcpy(string,rhs.string);
    }
    MyString(const char* s)          //用指针s所指向的字符串常量初始化atring类的对象
    {
        i=strlen(s);
        string = new char [i+1];
        string[i] = '\0';
        //strcpy(string,s);
    }
    MyString operator+(const MyString &s) const //加法运算
    {
        int len = strlen(s.string);
        char* str = new char [len+1];
        str[len] = '\0';
        strcat(string,s.string);
        strcpy(str,string);
        return MyString (str);
    }
    char operator[](int x) const    //按下标查找元素
    {
        if (x>i||x<0)
        {
            cout<<"查找不在范围内！"<<endl;
        }
        else
            return string[i];
    }
    friend ostream & operator<< (ostream &out, const MyString &s)
    {
        out<<s.string;
        return out;
    }
    void show()
    {
        cout<<"加法运算结果为："<<string[i]<<endl;
    }
};

void main()
{
    int m;
    MyString s1 = "abc",s2="def",s3;
    s3=s1+s2;
    s3.show();
    cout<<"请输入你要查找的信息的下标：";
    cin>>m;
    cout<<"查找的元素为："<<s3[m]<<endl;
    system("pause");
}

    MyString(const MyString &rhs)    //复制构造函数
    {
        i=strlen(rhs.string);
        string = new char [i+1];
        string[i] = '\0';
        //strcpy(string,rhs.string);
    }
你是只复制另一个对象的字符串长度还是它的字符串？如果是想复制字符串的话要用strcpy();

我把它取消注释后还是不对啊
MyString(const MyString &rhs)    //复制构造函数
    {
        i=strlen(rhs.string);
        string = new char [i+1];
        string[i] = '\0';
        strcpy(string,rhs.string);
    }
结果还是出不来啊

想解决哪个模块？哪一个函数结果出不来？

下面按照你的思路修改下，你可以参考：

#include <iostream>
#include <string>
using namespace std;

class MyString
{
    char* string;    
private:
    MyString()
    {
        string = NULL;
    }
public:
    ~MyString()                      //析构函数
    {
        delete[] string;
    }

    MyString(const MyString &rhs)    //复制构造函数
    {
        size_t srcLen = strlen(string);
        size_t dstLen = strlen(rhs.string);
        if (srcLen <= dstLen)
        {
            delete[] string;
            string = new char[dstLen + 1];
            memcpy(string, rhs.string, dstLen);
            string[dstLen - 1] = '\0';
        }
        else
        {
            memset(string, 0, strlen(string));
            memcpy(string, rhs.string, dstLen);
            string[dstLen - 1] = '\0';
        }
    }
    
    MyString operator=(const MyString& rhs)
    {
        return *this;
    }

    MyString(const char* s)          //用指针s所指向的字符串常量初始化atring类的对象
    {
        size_t len = strlen(s) + 1;
        string = new char[len];
        memcpy(string, s, strlen(s));
        string[len - 1] = '\0';
    }

    MyString operator+(const MyString &s) const //加法运算
    {
        size_t len = strlen(s.string);
        char* str = new char [len+1];
        str[len - 1] = '\0';
        strcat(string,s.string);
        strcpy(str,string);
        return MyString(str);
    }

    char operator[](int x) const    //按下标查找元素
    {
        return string[x];
    }

    friend ostream & operator<< (ostream &out, const MyString &s)
    {
        out<<s.string;
        return out;
    }

    void show()
    {
        cout<<"加法运算结果为："<<string<<endl;
    }
};

void main()
{
    int m = 1;
    MyString s1 = "abc",s2="def";
    MyString s3 = s1+s2;
    s3.show();
    cout<<"查找的元素为："<<s3[m]<<endl;
}

[此贴子已经被作者于2016-11-18 23:01编辑过]

加法和查找的结果实现不了

请问一下你用的是什么编译器？

加法的长度就没有留够
int len = strlen(s.string);
应该是
int len = strlen(s.string)+strlen(string);吧？

友情帮顶

随手写的，你自己检查一下

#include <cstring>
#include <iostream>
#include <exception>

class MyString
{
public:
    MyString() try : size_(0), str_(new char[size_+1])
    {
        str_[0] = '\0';
    }
    catch( std::bad_alloc& )
    {
        throw;
    }

    MyString( const MyString& rhs ) try : size_(rhs.size_), str_(new char[size_+1])
    {
        memcpy( str_, rhs.str_, size_+1 );
    }
    catch( std::bad_alloc& )
    {
        throw;
    }

    MyString( const char* rhs ) try : size_(strlen(rhs)), str_(new char[size_+1])
    {
        memcpy( str_, rhs, size_+1 );
    }
    catch( std::bad_alloc& )
    {
        throw;
    }

    MyString& operator=( const MyString& rhs )
    {
        if( this != &rhs )
        {
            if( size_ >= rhs.size_ )
            {
                size_ = rhs.size_;
                memcpy( str_, rhs.str_, size_ );
            }
            else
            {
                delete[] str_;
                size_ = rhs.size_;
                str_ = new char[size_+1];
                memcpy( str_, rhs.str_, size_ );
            }
        }
        return *this;
    }

    ~MyString()
    {
        delete[] str_;
    }

    MyString operator+( const MyString& s ) const
    {
        size_t newsize = size_ + s.size_;
        char* newstr = new char[ newsize+1 ];
        memcpy( newstr, str_, size_ );
        memcpy( newstr+size_, s.str_, s.size_+1 );
        MyString result;
        result.size_ = newsize;
        result.str_ = newstr;
        return result;
    }

    char operator[]( size_t index ) const
    {
        return str_[index];
    }
    char& operator[]( size_t index )
    {
        return str_[index];
    }

    char at( size_t index ) const
    {
        if( index > size_ )
            throw std::out_of_range("out of range");
        return str_[index];
    }
    char& at( size_t index )
    {
        if( index > size_ )
            throw std::out_of_range("out of range");
        return str_[index];
    }

private:
    size_t size_;
    char* str_;

    friend std::ostream& operator<<( std::ostream& out, const MyString& s );
};

std::ostream& operator<<( std::ostream& out, const MyString& s )
{
    return out << s.str_;
}

using namespace std;

int main( void )
{
    MyString s1="abc", s2="def";
    MyString s3 = s1 + s2;
    char s5 = s2[1];

    cout << s1 << '\n'
         << s2 << '\n'
         << s3 << '\n'
         << s5 << endl;

    return 0;
}