C++程序设计语言书中11章实现Sting部分不会的地方

对这里实现String中作者没写的四个函数

 

// 这两个是成员函数

mString& operator+=( const mString&);

mString& operator +=(const char*);

 

// 这两个是非成员函数

mString operator+( const mString&, const mString&);

mString operator+( const mString&, const char*);

 

的具体实现不是很有想法。

 

问题是：

 

1、 前两个类成员函数返回的是引用，而这里String的具体实现是用的char，根据作者写的代码，自己感觉这里肯定会修改原String的char指针，也就返回的不再是之前的引用对象了。

 

2、后面两个实现中，比如第一个：怎样来调用形参里面String对象的内部实现，即char*

 

还有一个问题是，自己写的时候也是把mString类内的Cref还有Srep写在.cpp中，但链接不通过，最后改成写在声明mString.h中，原作者的代码链接如下

http://www2.research.att.com/~bs/string_example.c

 

已写完代码记录如下

#pragma once
#include <string.h>
#include <iostream>

class mString
{


public:
    mString(void);
    mString(const char*);
    mString(const mString&);
    mString& operator=(const char*);
    mString& operator=(const mString&);

    ~mString(void);

    class Cref;
    class Range{ };

    void check(int i) const { if (i<0 || (rep->sz)<=i) throw Range(); }
    char read(int i) const { return rep->s[i]; }
    void write(int i, char c) { rep = rep->get_own_copy(); rep->s[i] = c; }
    Cref operator[](int i) { check(i); return Cref(*this, i); }
    char operator[](int i) const { check(i); return rep->s[i]; }
    int size() const { return rep->sz; }


    mString& operator+=(const mString&);
    mString& operator+=(const char*);

    friend std::ostream operator<<(std::ostream&, const mString&);
    friend std::istream& operator>>(std::istream&, mString&);
    friend bool operator==(const mString& x, const char* s) { return strcmp(x.rep->s, s) == 0; }
    friend bool operator==(const mString& x, const mString& y) { return strcmp(x.rep->s, y.rep->s) == 0; }
    friend bool operator!=(const mString& x, const char* s) { return strcmp(x.rep->s, s) != 0; }
    friend bool operator!=(const mString& x, const mString& y) { return strcmp(x.rep->s, y.rep->s) != 0; }


private:
    struct Srep; //表示
    Srep* rep;

    struct mString::Srep {
        char* s; //到元素的指针
        int sz; //字符个数
        int n; //引用计数

        Srep(int nsz, const char* p)
        {
            n = 1;
            sz = nsz;
            s = new char[sz+1];
            strcpy_s(s, sz, p);
        }

        ~Srep() { delete[] s; }

        Srep* get_own_copy()
        {
            if (1 == n)
            {
                return this;
            }
            --n;
            return new Srep(sz, s);
        }

        void assign(int nsz, const char* p)
        {
            if (sz != nsz)
            {
                delete[] s;
                sz = nsz;
                s = new char[sz+1];
            }
            strcpy_s(s, sz, p);
        }

    private:
        Srep(const Srep&);
        Srep& operator=(const Srep&);

    };

    class mString::Cref {

    public:
        operator char() const { return s.read(i); }
        void operator=(char c) { s.write(i,c); }

    private:
        friend class mString;
        Cref(mString& ss, int ii) :s(ss), i(ii) {}

    private:
        mString& s;
        int i;

    };

    /*class mString::Range {
    public:
        Range(void) { std::cout << "go here:Range()" << std::endl;}
    };*/

};

mString operator+(const mString&, const mString&);
mString operator+(const mString&, const char*);

#include "StdAfx.h"
#include "mString.h"

mString::mString(void)
{
    rep = new Srep(0, "");
}

mString::mString(const mString& rhs)
{
    (rhs.rep->n)++;
    rep = rhs.rep;
}

mString::mString(const char* rhs)
{
    rep = new Srep(strlen(rhs), rhs);
}

mString::~mString(void)
{
    if (--rep->n == 0)
    {
        delete rep;
    }
}

mString& mString::operator=(const mString& rhs)
{
    rhs.rep->n++;
    if ( --rep->n == 0)
    {
        delete rep;
    }
    rep = rhs.rep;
    return *this;
}

mString& mString::operator=(const char* rhs)
{
    if (rep->n == 1)
    {
        rep->assign(strlen(rhs), rhs);
    }
    else
    {
        rep->n--;
        rep = new Srep(strlen(rhs), rhs);
    }
    return *this;
}

mString& mString::operator+=(const mString&)
{

}

mString& mString::operator+=(const char*)
{

}

mString operator+(const mString& x, const mString& y)
{
    int length = x.size() + y.size() + 1;
    const char* s = new char[length];
//    strcpy_s(s, length, ); //这里不知道怎么来调用x 或者y的内部char*
    return mString(s);

}
mString operator+(const mString& )