我要好offer之 C++大总结

class Mystring {
    public:
        Mystring() : data_(new char[1]) {
            *data = ‘\0‘;
        }

        Mystring(const char* str) : data_(new char[strlen(str) + 1]) {
            strcpy(data_, str);
        }

        Mystring(const Mystring& str) : data_(new char[str.size() + 1]) {
            strcpy(data_, str.c_str());
        }

        ~Mystring() {
            delete[] data_;
        }
        
        // 重载赋值，采用copy and swap手法，旧式写法
        Mystring& operator=(const Mystring& str) {
            Mystring tmp(str);
            swap(tmp);
            return *this;
        }

        // 重载赋值，采用copy and swap手法，新式写法
        Mystring& operator=(Mystring& str) {
            swap(str);
            return *this;
        }

        int size() const {
            return (int)strlen(data_);
        }
        const char* c_str() const {
            return data_;
        }

        void swap(Mystring& str) {
            std::swap(data_, str.data_);
        }
    private:
        char* data_;
};

template<typename T>
class SmartPointer {
    public:
        SmartPointer<T>(T* ptr) {
            ref = ptr;
            ref_count = (unsigned*)malloc(sizeof(unsigned));
            *ref_count = 1;
        }

        SmartPointer<T>(SmartPointer<T*>& sptr) {
            ref = sptr.ref;
            ref_count = sptr.ref_count;
            ++(*ref_count);
        }
                
        //  覆写=运算符，这样才能将一个旧的智能指针赋值给另一指针，旧的引用计数减一，新的智能指针的引用计数则加一
        SmartPointer<T>& operator=(SmartPointer<T*> sptr) {
            if (this == &sptr) {
                *this;
            }
            // 若已赋值为某个对象，则移除引用
            if (*ref_count > 0) {
                remove();
            }

            ref = sptr.ref;
            ref_count = sptr.ref_count;
            ++(*ref_count);
            return *this;
        }

        ~SmartPointer<T>() {
            remove();
        }

        T* GetValue() {
            return ref;
        }

    private:
        void remove() {
            --(*ref_count);
            if (*ref_count == 0) {
                delete ref;
                free(ref_count);
                ref = NULL;
                ref_count = NULL;
            }
        }

        T* ref;
        unsigned* ref_count;
};