#include<stdio.h>
#include <iostream>
#include <set>
#include"sort.hpp"
#include<vector>
using namespace std;
//int main()
//{
//    int f = 10;
//    int&& rr = move(f);
//    int& r = rr;
//   vector<int> v = { 1,2,3,4,5 };
// 
//
////    int a = 10,b = 20;
////    const int& ra = (a + b);
////
////    &func();
////    std::set<int> myset;
////    std::set<int>::iterator itlow, itup;
////
////    for (int i = 1; i < 10; i++) 
////        myset.insert(i * 10); // 10 20 30 40 50 60 70 80 90
////
////    itlow = myset.lower_bound(30);                //       ^
////    itup = myset.upper_bound(60);                 //                   ^
////
////    myset.erase(itlow, itup);                     // 10 20 70 80 90
////
////    std::cout << "myset contains:";
////    for (std::set<int>::iterator it = myset.begin(); it != myset.end(); ++it)
////        std::cout << ' ' << *it;
////    std::cout << '\n';
//
//    return 0;
//}
#include<assert.h>
namespace zjy
{
    class string
    {
    public:
        typedef char* iterator;
        iterator begin()
        {
            return _str;
        }
        iterator end()
        {
            return _str + _size;
        }
        string(const char* str = "")
            :_size(strlen(str))
            , _capacity(_size)
        {
            //cout << "string(char* str)" << endl;
            _str = new char[_capacity + 1];
            strcpy(_str, str);
        }
        // s1.swap(s2)
        void swap(string& s)
        {
            std::swap(_str, s._str);
            std::swap(_size, s._size);
            std::swap(_capacity, s._capacity);
        }
        // 拷贝构造
        string(const string& s)
            :_str(nullptr)
        {
            cout << "string(const string& s) -- 深拷贝" << endl;
            string tmp(s._str);
            swap(tmp);
        }
        // 赋值重载
        string& operator=(const string& s)
        {
            cout << "string& operator=(string s) -- 深拷贝" << endl;
            string tmp(s);
            swap(tmp);
            return *this;
        }
        // 移动构造
        string(string&& s)
            :_str(new char('\0'))
            , _size(0)
            , _capacity(0)
        {
            cout << "string(string&& s) -- 移动语义" << endl;
            swap(s);
        }
        // 移动赋值
        string& operator=(string&& s)
        {
            cout << "string& operator=(string&& s) -- 移动语义" << endl;
            swap(s);
            return *this;
        }
        ~string()
        {
            delete[] _str;
            _str = nullptr;
        }
        char& operator[](size_t pos)
        {
            assert(pos < _size);
            return _str[pos];
        }
        void reserve(size_t n)
        {
            if (n > _capacity)
            {
                char* tmp = new char[n + 1];
                strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
                _capacity = n;
            }
        }
        void push_back(char ch)
        {
            if (_size >= _capacity)
            {
                size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
                reserve(newcapacity);
            }

            _str[_size] = ch;
            ++_size;
            _str[_size] = '\0';
        }
        //string operator+=(char ch)
        string& operator+=(char ch)
        {
            push_back(ch);
            return *this;
        }
        const char* c_str() const
        {
            return _str;
        }
    private:
        char* _str;
        size_t _size;
        size_t _capacity; // 不包含最后做标识的\0
    };
}

int main()
{

   zjy::string str1 = "123456";
    cout << "str1" << str1.c_str() << endl;
    zjy::string str2(move(str1));
    cout << "str1" << str1.c_str() << endl;
    cout << "str2" << str2.c_str() << endl;

    return 0;
}