CPlusPlusThings
/
c++2.0
/
c++11
/
move.cpp

//
// Created by light on 19-11-4.
//

#include <iostream>
#include <cstring>
#include <vector>
#include <list>
#include <typeinfo>
#include <deque>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

using namespace std;

class MyStringNoMove {
public:
    static size_t DCtor;    // default-ctor
    static size_t Ctor;     // ctor
    static size_t CCtor;    // copy-ctor
    static size_t CAsgn;    // copy-assignment
    static size_t MCtor;    // move-ctor
    static size_t MAsgn;    // move-assignment
    static size_t Dtor;     // dtor
private:
    char *_data;
    size_t _len;

    void _init_data(const char *s) {
        _data = new char[_len];
        memcpy(_data, s, _len);
        _data[_len] = '\0';
    };
public:
    MyStringNoMove() : _data(NULL), _len(0) { ++DCtor; }

    MyStringNoMove(const char *p) : _len(strlen(p)) {
        ++Ctor;
        _init_data(p);
    }

    // copy ctor
    MyStringNoMove(const MyStringNoMove &str) : _len(str._len) {
        ++CCtor;
        _init_data(str._data);
    }


    // copy assignment
    MyStringNoMove &operator=(const MyStringNoMove &str) {
        ++CAsgn;
        if (this != &str) {
            if (_data) delete _data;
            _len = str._len;
            _init_data(str._data);
        } else {

        }
        return *this;
    }

    ~MyStringNoMove() {       // dtor 默认是noexcept
        ++Dtor;
        if (_data)
            delete _data;
    }

    bool
    operator<(const MyStringNoMove &rhs) const {
        return string(this->_data) < string(rhs._data);
    }

    bool
    operator==(const MyStringNoMove &rhs) const {
        return string(this->_data) == string(rhs._data);
    }

    char *get() const {
        return _data;
    }
};

size_t MyStringNoMove::DCtor = 0;    // default-ctor
size_t MyStringNoMove::Ctor = 0;     // ctor
size_t MyStringNoMove::CCtor = 0;    // copy-ctor
size_t MyStringNoMove::CAsgn = 0;    // copy-assignment
size_t MyStringNoMove::MAsgn = 0;    // move-assignment
size_t MyStringNoMove::MCtor = 0;    // move-ctor
size_t MyStringNoMove::Dtor = 0;     // dtor
// move aware class

class MyString {
public:
    static size_t DCtor;    // default-ctor
    static size_t Ctor;     // ctor
    static size_t CCtor;    // copy-ctor
    static size_t CAsgn;    // copy-assignment
    static size_t MCtor;    // move-ctor
    static size_t MAsgn;    // move-assignment
    static size_t Dtor;     // dtor
private:
    char *_data;
    size_t _len;

    void _init_data(const char *s) {
        _data = new char[_len];
        memcpy(_data, s, _len);
        _data[_len] = '\0';
    };
public:
    MyString() : _data(NULL), _len(0) { ++DCtor; }

    MyString(const char *p) : _len(strlen(p)) {
        ++Ctor;
        _init_data(p);
    }

    // copy ctor
    MyString(const MyString &str) : _len(str._len) {
        ++CCtor;
        _init_data(str._data);
    }

    // move ctor
    MyString(MyString &&str) noexcept: _data(str._data), _len(str._len) {
        ++MCtor;
        str._len = 0;
        str._data = NULL;   // 重要
    }

    // copy assignment
    MyString &operator=(const MyString &str) {
        ++CAsgn;
        if (this != &str) {
            if (_data) delete _data;
            _len = str._len;
            _init_data(str._data);
        } else {

        }
        return *this;
    }

    // move assignment
    MyString &operator=(MyString &&str) {
        ++MAsgn;
        if (this != &str) {
            if (_data) delete _data;
            _data = str._data;
            _len = str._len;
            str._len = 0;
            str._data = NULL;
        } else {

        }
        return *this;
    }

    ~MyString() {       // dtor 默认是noexcept
        ++Dtor;
        if (_data)
            delete _data;
    }

    bool
    operator<(const MyString &rhs) const {
        return string(this->_data) < string(rhs._data);
    }

    bool
    operator==(const MyString &rhs) const {
        return string(this->_data) == string(rhs._data);
    }

    char *get() const {
        return _data;
    }
};

size_t MyString::DCtor = 0;    // default-ctor
size_t MyString::Ctor = 0;     // ctor
size_t MyString::CCtor = 0;    // copy-ctor
size_t MyString::CAsgn = 0;    // copy-assignment
size_t MyString::MAsgn = 0;    // move-assignment
size_t MyString::MCtor = 0;    // move-ctor
size_t MyString::Dtor = 0;     // dtor
namespace std {
    template<>
    struct hash<MyStringNoMove> : public __hash_base<size_t, MyStringNoMove> {
        size_t
        operator()(const MyStringNoMove &s) const noexcept {
            return hash<string>()(string(s.get()));
        }
    };

    template<>
    struct hash<MyString> : public __hash_base<size_t, MyString> {
        size_t
        operator()(const MyString &s) const noexcept {
            return hash<string>()(string(s.get()));
        }
    };
}

template<typename T>
void output_static_data(const T &myStr) {
    cout << typeid(myStr).name() << "==" << endl;
    cout << "CCtor=" << T::CCtor
         << ",MCtor=" << T::MCtor
         << ",CAsgn=" << T::CAsgn
         << ",MAsgn=" << T::MAsgn
         << ",Dtor=" << T::Dtor
         << ",Ctor=" << T::Ctor
         << ",DCtor=" << T::DCtor
         << endl;
}


template<typename M, typename NM>
void test_moveable(M c1, NM c2, long &value) {
    cout << "\n\ntest, with moveable elements" << endl;
    typedef typename iterator_traits<typename M::iterator>::value_type V1type;
    clock_t timeStart = clock();
    for (long i = 0; i < value; i++) {
        string buf = to_string(i);
        auto ite = c1.end();
        c1.insert(ite, V1type(buf.c_str()));
    }
    cout << "construction,milli-seconds:" << clock() - timeStart << endl;
    cout << "size()=" << c1.size() << endl;
    output_static_data(*(c1.begin()));

    // 容器本身操作
    timeStart = clock();
    M c11(c1);
    cout << "copy, milli-seconds: " << (clock() - timeStart) << endl;
    timeStart = clock();
    M c12(move(c1));
    cout << "move copy, milli-seconds: " << (clock() - timeStart) << endl;
    timeStart = clock();
    c11.swap(c12);
    cout << "swap, milli-seconds: " << (clock() - timeStart) << endl;

    //測試 non-moveable
    cout << "\n\ntest, with non-moveable elements" << endl;
    typedef typename iterator_traits<typename NM::iterator>::value_type V2type;
    timeStart = clock();
    for (long i = 0; i < value; ++i) {
        string buf = to_string(i);
        auto ite = c2.end();
        c2.insert(ite, V2type(buf.c_str()));
    }

    cout << "construction, milli-seconds : " << (clock() - timeStart) << endl;
    cout << "size()= " << c2.size() << endl;
    output_static_data(*(c2.begin()));

    // 容器本身操作
    timeStart = clock();
    NM c21(c2);
    cout << "copy, milli-seconds : " << (clock() - timeStart) << endl;

    timeStart = clock();
    NM c22(std::move(c2));
    cout << "move copy, milli-seconds : " << (clock() - timeStart) << endl;

    timeStart = clock();
    c21.swap(c22);
    cout << "swap, milli-seconds: " << (clock() - timeStart) << endl;
}

int main() {
    long value = 3000;           // vector 测试结果的MCtor与CCtor结果大于3000000,是因为vector的动态扩容,当容量不够的时候,会动态分配并进行拷贝。
//    test_moveable(vector<MyString>(), vector<MyStringNoMove>(), value);
//    test_moveable(list<MyString>(), list<MyStringNoMove>(), value);
//    test_moveable(deque<MyString>(), deque<MyStringNoMove>(), value);
//    test_moveable(multiset<MyString>(), multiset<MyStringNoMove>(), value);
//    test_moveable(unordered_multiset<MyString>(), unordered_multiset<MyStringNoMove>(), value);
    return 0;
}