第三十四课：数组操作符的重载----------狄泰软件学院

一、string还可以通过数组访问操作符访问单个字符

#include<iostream>
#include<sstream>
using namespace std;
int main()
{
    string s = "ab13cf34";
    int n = 0;
    for(int i = 0; i < s.length(); i++)
    {
        if(isdigit(s[i]))
        {
            n++;
        }
    }
    cout << n << endl;
    return 0;
}
最后n的值为4

二、引出的问题：类的对象怎么支持数组的下标访问？

class Test
{
 public:
};
int main()
{
    Test t;
    cout<< t[0] <<enld;//报错
    return 0;
}

一个被忽略的事实：

1.数组访问操作符是c/c++中的内置操作符（与加减乘除一样地位，可以被重载）
2.数组访问符的原生意义是数组访问和指针访问

a[n] <====> *(a+n) <===> *(n+a) <====> n[a]

#include<iostream>
using namespace std;
int main()
{
    int a[5];
    for(int i = 0; i < 5; i++)
    {
        *(a + i) = i;
    }
    for(int i = 0; i < 5; i++)
    {
        cout << i[a] <<endl;//相当于a[i]
    }
    return 0;
}

二、重载数组操作符

1.只能通过类的成员函数重载
2.重载函数能且只能使用一个参数
3.可以定义不同参数的不同重载函数
可以将字符串作为下标来访问数组，通过数组类的方法

#include<iostream>
using namespace std;
class Test
{
private:
    int a[5];
public:
    int& operator[](int i)//返回引用是为了可以做左值
    {
        return a[i];
    }

    int& operator[](const char* s)
    {
        if(s=="1st")
        {
            return a[0];
        }
        else if(s=="2nd")
        {
            return a[1];
        }
        else if(s=="3rd")
        {
            return a[2];
        }
        else if(s=="4th")
        {
            return a[3];
        }
        else if(s=="5th")
        {
            return a[4];
        }

        return a[0];
    }   
};
int main()
{
    Test t;
    for(int i = 0; i < 5; i++)
    {
        t[i] = i;
    }

    for(int i = 0; i < 5; i++)
    {
        cout << t[i] << endl;
    }

    cout << endl;

    cout << t["1st"] << endl;//可以将字符串作为下标来访问数组
    cout << t["2nd"] << endl;
    cout << t["3rd"] << endl;
    cout << t["4th"] << endl;
    cout << t["5th"] << endl;
    return 0;
}

三、数组类的完善

array.h
#ifndef _ARRAY_H_
#define _ARRAY_H_
#include<iostream>
class Array
{
private:
    int m_length;
    int *m_poiter;
    Array(int length);
    Array(const Array& obj);
    bool construct();
public:
    int get_length();
//  bool set_data(int index, int data);
//  bool get_data(int index, int& data);    
    static Array* NewInsrance(int length);
    int& operator [] (int index);
    Array& self();
    ~Array();
};
#endif

array.cpp
#include"array.h"
Array::Array(int length)
{
    m_length = length;      
}
bool Array::construct()
{
    bool ret = true;
    m_poiter = new int[m_length];
    if(m_poiter)
    {
        for(int i = 0; i < m_length; i++)
           {
            m_poiter[i] = 0;
        }
    }
    else
    {
        ret = false;
    }
    return ret;
}

Array*  Array::NewInsrance(int length)
{
    Array* ret = new Array(length);
    if(!(ret && ret->construct()))
    {
        delete ret;
        ret = NULL;     
    }
    return ret;
}

int Array::get_length()
{
    return m_length;
}
/*
bool Array::set_data(int index, int data)
{
    bool ret = ((0 <= index)&&(index<get_length()));
    if(ret)
    {
        m_poiter[index] = data;
    }
    return ret; 
}

bool Array::get_data(int index, int& data)
{
    bool ret = ((0<=index) && (index<get_length()));
    if(ret)
    {
        data = m_poiter[index];
    }
    return ret;
}
*/
int& Array::operator [] (int index)
{
    return m_poiter[index];
}

Array& Array::self()
{
    return *this;
}

Array::~Array()
{
    delete[] m_poiter;
}

main.cpp
#include"array.h"
using namespace std;
int main()
{
    Array* array = Array::NewInsrance(5);
    if(array != NULL)
    {
        Array& a = array->self();
        cout << a.get_length()<<endl;
        cout << endl;
        for(int i = 0; i < a.get_length(); i++)
        {
            a[i] = i+1;
        }

        for(int i = 0; i < a.get_length(); i++)
        {

            cout <<a[i] << endl;

        }
    }

    delete array;
    return 0;
}

小结：

1.string类最大程度兼容了c字符串的访问方式
2.数组访问符重载能够使得对象模拟数组的行为
3.只能通过类的成员函数重载数组操作符
4.重载能且只能有一个参数