auto | auto& | auto&&

【1】应用示例

#include <vector>
#include <cassert>
#include <string>
#include <iostream>
using namespace std;

class String
{
public:
    String();
    String(int n, char c);
    String(const char* source);
    String(const String& s);
    String(String&& s);
    String& operator=(char* s);
    String& operator=(const String& s);
    String& operator=(String&& s);
    ~String();

    char& operator[](int i);
    const char& operator[](int i) const;
    String& operator+=(const String& s);
    String& operator+=(const char* s);

    friend ostream& operator<<(ostream& out, String& s);
    friend ostream& operator<<(ostream& out, const String& s);
    friend istream& operator>>(istream& in, String& s);

    friend bool operator<(const String& left, const String& right);
    friend bool operator>(const String& left, const String& right);
    friend bool operator==(const String& left, const String& right);
    friend bool operator!=(const String& left, const String& right);

    int getSize() const;
    void setSize(int nSize);
    char* getData() const;
    void setData(char* pData);

private:
    void init();

private:
    int m_size;
    char* m_data;
};

void String::init()
{
    m_data = new char[1];
    assert(m_data != NULL);
    *m_data = '';
    m_size = 0;
}

String::String()
{
    cout << "call String()" << endl;
    init();
}

String::String(int n, char c)
{
    cout << "call String(int n, char c)" << endl;
    m_data = new char[n + 1];
    assert(m_data != NULL);
    m_size = n;
    char* temp = m_data;
    while (n--)
    {
        *temp++ = c;
    }
    *temp = '';
}

String::String(const char* source)
{
    cout << "call String(const char* source)" << endl;
    if (NULL == source)
    {
        init();
    }
    else
    {
        m_size = strlen(source);
        m_data = new char[m_size + 1];
        assert(m_data != NULL);
        strcpy_s(m_data, (m_size + 1), source);
    }
}
String::String(const String& s)
{
    cout << "call String(const String& s)" << endl;
    m_data = new char[s.m_size + 1];
    assert(m_data != NULL);
    strcpy_s(m_data, (s.m_size + 1), s.m_data);
    m_size = s.m_size;
}

String::String(String&& s)
{
    cout << "call move ctor" << endl;
    m_data = s.getData();
    m_size = s.getSize();
    s.setData(NULL);
    s.setSize(0);
}

String& String::operator=(char* s)
{
    cout << "call operator=(char* s)" << endl;

    if (m_data != NULL)
    {
        delete []m_data;
    }
    m_size = strlen(s);
    m_data = new char[m_size + 1];
    assert(m_data != NULL);
    strcpy_s(m_data, (m_size + 1), s);
    return (*this);
}

String& String::operator=(const String& s)
{
    cout << "call operator=(const String& s)" << endl;

    if (this == &s)
    {
        return *this;
    }
    if (m_data != NULL)
    {
        delete []m_data;
    }
    m_size = strlen(s.m_data);
    m_data = new char[m_size + 1];
    assert(m_data != NULL);
    strcpy_s(m_data, (m_size + 1), s.m_data);
    return (*this);
}

String& String::operator=(String&& s)
{
    cout << "call move operator=" << endl;

    if (this == &s)
    {
        return (*this);
    }
    if (m_data != NULL)
    {
        delete[]m_data;
    }
    m_data = s.getData();
    m_size = s.getSize();
    s.setData(NULL);
    s.setSize(0);
    return (*this);
}

String::~String()
{
    if (m_data != NULL)
    {
        delete[]m_data;
        m_data = NULL;
        m_size = 0;
    }
}

char& String::operator[](int i)
{
    return m_data[i];
}

const char& String::operator[](int i) const
{
    return m_data[i];
}

String& String::operator+=(const String& s)
{
    int len = m_size + s.m_size + 1;
    char* pTemp = m_data;
    m_data = new char[len];
    assert(m_data != NULL);
    strcpy_s(m_data, (m_size + 1), pTemp);
    strcat_s(m_data, len, s.m_data);
    m_size = len - 1;
    delete[]pTemp;
    return (*this);
}

String& String::operator+=(const char* s)
{
    if (NULL == s)
    {
        return (*this);
    }
    int len = m_size + strlen(s) + 1;
    char* pTemp = m_data;
    m_data = new char[len];
    assert(m_data != NULL);
    strcpy_s(m_data, (m_size + 1), pTemp);
    strcat_s(m_data, len, s);
    m_size = len - 1;
    delete[]pTemp;
    return (*this);
}

int String::getSize() const
{
    return m_size;
}

void String::setSize(int nSize)
{
    this->m_size = nSize;
}

char* String::getData() const
{
    return m_data;
}

void String::setData(char* pData)
{
    if (NULL == pData)
    {
        init();
    }
    else
    {
        m_data = pData;
    }
}

ostream& operator<<(ostream& out, String& s)
{
    for (int i = 0; i < s.getSize(); ++i)
    {
        out << s[i] << " ";
    }
    return out;
}

ostream& operator<<(ostream& out, const String& s)
{
    for (int i = 0; i < s.getSize(); ++i)
    {
        out << s[i] << " ";
    }
    return out;
}

istream& operator>>(istream& in, String& s)
{
    char p[50];
    in.getline(p, 50);
    s = p;
    return in;
}

bool operator<(const String& left, const String& right)
{
    int i = 0;
    while (left[i] == right[i] && left[i] != 0 && right[i] != 0)
        i++;

    return (left[i] - right[i] < 0);
}

bool operator>(const String& left, const String& right)
{
    int i = 0;
    while (left[i] == right[i] && left[i] != 0 && right[i] != 0)
        i++;

    return (left[i] - right[i] > 0);
}

bool operator==(const String& left, const String& right)
{
    int i = 0;
    while (left[i] == right[i] && left[i] != 0 && right[i] != 0)
        i++;

    return (left[i] == right[i]);
}

bool operator!=(const String& left, const String& right)
{
    int i = 0;
    while (left[i] == right[i] && left[i] != 0 && right[i] != 0)
        i++;

    return (left[i] != right[i]);
}

int main()
{
    std::vector<String> stringVector;

    String str(3, 'a');
    String str1(str);
    String str2("asdf");
    String str3 = str2;

    cout << "str: " << str << endl;
    cout << "str1: " << str1 << endl;
    cout << "str2: " << str2 << endl;
    cout << "str3: " << str3 << endl;

    stringVector.push_back(str);
    stringVector.push_back(str1);
    stringVector.push_back(str2);
    stringVector.push_back(str3);

    // 第一种方式
    cout << "the first way: " << endl;
    for (auto item : stringVector)
    {
        cout << item << endl;
    }

    // 第二种方式：引用，可以修改元素值
    cout << "the second way: " << endl;
    for (auto& item : stringVector)
    {
        item += "baidu";
        cout << item << endl;
    }

    // 第三种方式
    cout << "the third way: " << endl;
    for (auto & const item : stringVector)
    {
        cout << item << endl;
    }

    // 第四种方式
    cout << "the four way: " << endl;
    for (auto const & item : stringVector)
    {
        cout << item << endl;
    }

    // 第五种方式：万能引用 
    //参考：https://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers
    cout << "the five way: " << endl;
    for (auto&& item : stringVector)
        cout << item << endl;

    // 第六种方式
    cout << "the six way: " << endl;
    for (auto& item : { "abc", "def", "hij" })
        cout << item << endl;

    // 第七种方式
    cout << "the seven way: " << endl;
    for (auto& item : { 100, 200, 300 })
        cout << item << endl;

#if 0
    // 第七种方式：编译错误
    cout << "the seven way: " << endl;
    for (int& item : { 100, 200, 300 })
        cout << item << endl;
#endif

    system("pause");
}

good good study, day day up.