master

分支 (1)

管理

管理

master

nb.c
/
string.h

#define _CRT_SECURE_NO_WARNINGS
#pragma once
#include<iostream>
#include<string.h>
#include<assert.h>
using std::cout;
using std::cin;
using std::endl;
using std::swap;

	using std::ostream;
	using std::istream;

namespace zjy
{
    class string

    {

        friend ostream& operator<<(ostream& _cout, const string& s);

        friend istream& operator>>(istream& _cin, string& s);

    public:

        typedef char* iterator;

    public:

        string(const char* str = "")
        {
            size_t len = strlen(str);
            _str = new char[len + 1];
            memmove(_str, str, len + 1);
            _capacity =_size= len;
        }

        string(const string& s)
        {
            string tmp(s.c_str());
            swap(tmp);
        }

        string& operator=(const string& s)
        {
            string tmp(s.c_str());
            swap(tmp);
            return *this;
        }

        ~string()
        {
            delete[] _str;
            _str = nullptr;
            _capacity = _size = 0;
        }


            //////////////////////////////////////////////////////////////

            // iterator

        iterator begin()
        {
            return _str;
        }

        iterator end()
        {
            return _str + _size;
        }


            /////////////////////////////////////////////////////////////

            // modify

        void push_back(char c)
        {
            if (_capacity == _size)
            {
                reserve(_capacity==0?0:_capacity * 2);
            }
            _str[_size++] = c;
            _str[_size] = '\0';

        }

        string& operator+=(char c)
        {
            push_back(c);
            return *this;
        }
        void append(const char* str)
        {
            size_t len = strlen(str);
            if (_size + len > _capacity)
            {
                reserve((_size + len)*2);
            }
            for(size_t i = 0; i < len; i++)
            {
                push_back(*(str + i));
            }
        }
        string& operator+=(const char* str)
        {
            append(str);
        }

        void clear()
        {
            _size = 0;
            _str[_size] = '\0';
        }

        void swap(string& s)
        {
            ::swap(_str, s._str);
            ::swap(_size, s._size);
            ::swap(_capacity, s._capacity);
        }

        const char* c_str()const
        {
            return _str;
        }


        /////////////////////////////////////////////////////////////

        // capacity


        size_t size()const
        {
            return _size;
        }

        size_t capacity()const
        {
            return _capacity;
        }

        bool empty()const
        {
            return _size == 0;
        }

        void resize(size_t n, char c = '\0')
        {
            reserve(n);
            if (_size >= n)
            {
                _str[_size] = '\0';
                _size = n;
                return;
            }
            else
            {
                for (size_t i = _size; i < n; i++)
                {
                    push_back(c);
                }
            }
        }

        void reserve(size_t n)
        {
            if (n > _capacity)
            {
                char* tmp = new char[n + 1];
                memmove(tmp, _str, _size + 1);
                delete[] _str;
                _str = tmp;
                _capacity = n;
            }
        }


        /////////////////////////////////////////////////////////////

        // access

        char& operator[](size_t index)
        {
            assert(index <= _size);
            return _str[index];
        }

        const char& operator[](size_t index)const
        {
            assert(index <= _size);
            return _str[index];
        }


        /////////////////////////////////////////////////////////////

        //relational operators

        bool operator<(const string& s)
        {
            int maxlen = _size > s._size ? _size : s._size;
            int ret = memcmp(_str, s._str, maxlen);
            if (ret < 0 || ret == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        bool operator<=(const string& s)
        {
            return (*this < s) || (*this == s);
        }

        bool operator>(const string& s)
        {
            return !(*this <= s);
        }
        bool operator>=(const string& s)
        {
            return !(*this < s);
        }
        bool operator==(const string& s)
        {
            int maxlen = _size > s._size ? _size : s._size;
            int ret = memcmp(_str, s._str, maxlen);
            if (ret == 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        bool operator!=(const string& s)
        {
            return !(*this == s);
        }


        // 返回c在string中第一次出现的位置

        size_t find(char c, size_t pos = 0) const
        {
            char*p=strchr(_str, c);
            if (p != NULL)
            {
                return p-_str;
            }

            //for (size_t i = 0; i < _size; i++)
            //{
            //    if (_str[i] == c)
            //    {
            //        return i;
            //    }
            //}
            return npos;
        }

        // 返回子串s在string中第一次出现的位置

        size_t find(const char* s, size_t pos = 0) const
        {
            size_t len = strlen(s);
            const char* flag = NULL;
            for (size_t i = 0; i < _size; i++)
            {
                flag = strchr(s,_str[i]);
                if (flag != NULL)
                {
                    size_t pos = (&_str[i]) - _str;
                    return pos;
                }
            }
            cout << "not found!\n";
            return npos;
        }

        // 在pos位置上插入字符c/字符串str，并返回该字符的位置

        string& insert(size_t pos,  char c)
        {
            if (_capacity == _size)
            {
                reserve(_capacity == 0 ? 0 : _capacity * 2);
            }
            size_t end = _size + 1;
            while (end >= pos)
            {
                _str[end] = _str[end-1];
                --end;
            }
            _str[pos] = c;
            _size++;
            return *this;
        }

        string& insert(size_t pos, const char* str)
        {
            size_t len = strlen(str);
            if (len + _size > _capacity)
            {
                reserve((_size + len) * 2);
            }
            size_t end = _size + len;
            while (end >= pos+len)
            {
                _str[end] = _str[end - len];
                --end;
            }
            memmove(_str + pos, str, len);
            _size+=len;
            return *this;
        }


        // 删除pos位置上的元素，并返回该元素的下一个位置

        string& erase(size_t pos, size_t len = 1)
        {
            assert(pos <= _size);
            if ( pos + len >= _size)
            {
                _str[pos] = '\0';
                _size = pos;
            }
            else {
                memmove(_str + pos, _str + (pos + len), _size - (pos + len)+1);
                _size -= len;
            }
            return *this;
        }

    private:

        char* _str;

        size_t _capacity;

        size_t _size;

        const static size_t npos = -1;
    };
}


//namespace zjy
//{
//	class string
//	{
//	public:
//		typedef char* iterator;
//		typedef char* const_iterator;
//		iterator begin()
//		{
//			return _str;
//		}
//
//		iterator end()
//		{
//			return _str + _size;
//		}
//
//		const_iterator begin() const
//		{
//			return _str;
//		}
//
//		const_iterator end() const
//		{
//			return _str + _size;
//		}
//
//		string(const char* str = "")
//			:_str(new char[_size + 1]),
//			_size(strlen(str)),
//			_capacity(_size)
//		{
//			strcpy(_str, str);
//		}
//	public:
//
//		char& operator [](size_t pos)
//		{
//			return _str[pos];
//		}
//
//		const char& operator [](size_t pos)const
//		{
//			return _str[pos];
//		}
//
//		// 老老实实敲代码思维
//		//string(const string& s)
//		//	:_str(new char[s._capacity + 1]),
//		//	_size(s._size),
//		//	_capacity(s._capacity)
//		//{
//		//	strcpy(_str, s._str);
//		//}
//		//  资本家思维
//		void swap(string& tmp)
//		{
//			::swap(tmp._size, _size);
//			::swap(tmp._capacity, _capacity);
//			::swap(tmp._str, _str);
//		}
//
//		string(const string& s)
//			:_str(nullptr),
//			_capacity(0),
//			_size(0)
//		{
//			string tmp(s._str);
//			swap(tmp);
//		}
//
//		const char* c_str()const
//		{
//			return _str;
//		}
//
//		//string& operator =(const string& s)
//		//{
//		//	if (&s == this)
//		//	{
//		//		return *this;
//		//	}
//		//	string tmp(s);
//		//	swap(tmp);
//		//	return *this;
//
//		//	/*if (&s == this)
//		//	{
//		//		return *this;
//		//	}
//		//
//		//	try
//		//	{
//		//		delete _str;
//		//		_str = new char[s._capacity + 1];
//		//		_capacity = s._capacity;
//		//		_size = s._size;
//		//		memmove(_str, s._str, _capacity + 1);
//		//		return *this;
//
//		//	}
//		//	catch (const std::exception&e)
//		//	{
//		//		cout << e.what() << endl;
//		//		exit(-1);
//		//	}*/
//		//}
//		string& operator =(string s)
//		{
//			if (&s == this)
//			{
//				return *this;
//			}
//			swap(s);
//			return *this;
//		}
//	public:
//
//		string& operator +=(const char* str)
//		{
//			append(str);
//			return *this;
//		}
//
//		string& operator +=(char ch)
//		{
//			Push_back(ch);
//			return *this;
//		}
//
//		string& operator +=(const string& s)
//		{
//			append(s.c_str());
//			return *this;
//		}
//
//		string& append(const string& s)
//		{
//			append(s.c_str());
//			return *this;
//		}
//	public:
//
//		string& append(size_t n, char ch)
//		{
//			reserve(_size + n);
//			for (size_t i = 0; i < n; i++)
//			{
//				Push_back(ch);
//			}
//		}
//
//
//		void reserve(size_t a)
//		{
//			if (a > _capacity)
//			{
//				char* tmp = new char[a + 1];
//				strcpy(tmp, _str);
//				delete[] _str;
//				_str = tmp;
//				_capacity = a;
//			}
//		}
//
//		void Push_back(char ch)
//		{
//			if (_size == _capacity)
//			{
//				reserve(_capacity == 0 ? 4 : _capacity * 2);
//			}
//			_str[_size++] = ch;
//			_str[_size] = '\0';
//		}
//		void Insert(size_t pos, const char* str)
//		{
//			assert(pos <= _size);
//			size_t len = strlen(str);
//			if (_size + len > _capacity)
//			{
//				reserve((_size + len) * 2);
//			}
//			size_t end = _size + len;
//			while (end >= pos + len)
//			{
//				_str[end] = _str[end - len];
//				--end;
//			}
//			strncpy(_str + pos, str, len);
//			_size += len;
//		}
//
//		void append(const char* str)
//		{
//			/*size_t len = strlen(str);
//			if (_size + len > _capacity)
//			{
//				reserve((_size + len)*2);
//			}
//			strcpy(_str + _size, str);
//			_size += len;*/
//			Insert(_size, str);
//
//		}
//
//		string& Insert(size_t pos, char ch)
//		{
//			assert(pos <= _size);
//			if (_size == _capacity)
//			{
//				reserve(_capacity == 0 ? 4 : _capacity * 2);
//			}
//			size_t end = _size + 1;
//			while (end > pos)
//			{
//				_str[end] = _str[end - 1];
//				end--;
//			}
//			return *this;
//
//		}
//		void erase(size_t pos, size_t len = npos)
//		{
//			assert(pos < _size);
//			if (pos == npos || pos + len >= _size)
//			{
//				_str[pos] = '\0';
//				_size = pos;
//			}
//			else {
//				strcpy(_str + pos, _str + (pos + len));
//				_size -= len;
//			}
//		}
//		//size_t find(char ch, size_t pos = 0);
//		//size_t find(const char*sub, size_t pos = 0);
//		//size_t rfind(char ch, size_t pos = npos);
//		//size_t rfind(const char ch, size_t pos = npos);
//		//bool operator>(const string& s);
//		//bool operator>=(const string& s);
//		//bool operator<(const string& s);
//		//bool operator<=(const string& s);
//		//bool operator==(const string& s);
//		//bool operator!=(const string& s);
//
//
//
//
//
//		~string()
//		{
//			delete[] _str;
//			_str = nullptr;
//			_capacity = _size = 0;
//		}
//
//		size_t size()const
//		{
//			return _size;
//		}
//
//	private:
//		size_t _size;
//		size_t _capacity;
//		char* _str;
//		const static size_t npos = -1;
//	};
//	using std::ostream;
//	using std::istream;
//	ostream& operator <<(ostream& out,const string& sq)
//	{
//		for (size_t i = 0; i < sq.size();i++)
//		{
//			out << sq[i];
//		}
//		return out;
//	}
//
//	istream& operator >>(istream& in, string& sq)
//	{
//		char ch=in.get();
//		while (ch != ' ' && ch != '\n')
//		{
//			sq+=ch;
//			ch = in.get();
//
//		}
//		return in;
//	}
//}


class string

{

public:

	void swap(string&s)
	{
		::swap(s._str, _str);
	}

	string(const char* str = "")
	{
		size_t len = strlen(str);
		_str = new char[len+1];
		strcpy(_str, str);
	}

	string(const string&s)
	{
		string tmp(s._str);
		swap(tmp);
	}

	string& operator=(const string& s)
	{
		string tmp(s);
		swap(tmp);
		return *this;
	}

	~string()
	{
		delete[] _str;
		_str = nullptr;
	}

private:

	char* _str;

};
//
//