第34课 - 数组操作符的重载

1、问题
            string类对象还具备C方式字符串的灵 
            活性吗？还能直接访问单个字符吗？ 

2、字符串类的兼容性
            string类最大限度的考虑了C字符串的兼容性 
            可以按照使用C字符串的方式使用string对象
string s= "alb2c3d4e";   
int n = 0;  
  
for(int i = O; i<s.length(); i++)   
{      
    if (isdigit (s[i]))   
    {   
        n++;   
    }  
}   

3、编程实验
用C方式使用string类     34-1.cpp
#include <iostream>  
#include <string>  
  
using namespace std;  
  
int main()  
{  
    string s = "a1b2c3d4e";  
    int n = 0;  
          
    for(int i = 0; i<s.length(); i++)  
    {  
        if( isdigit(s[i]) )  
        {  
            n++;  
        }  
    }  
      
    cout << n << endl;  
      
    return 0;  
}  

                


                                g++ VS2015 BCC均是此结果

4、问题
            类的对象怎么支持数组的下标访问？

5、重载数组访问操作符
        被忽略的事实。。。 
                －数组访问符是C/C++中的内置操作符 
                －数组访问符的原生意义是数组访问和指针运算 
        


6、实例分析
指针与数组的复习     34-2.cpp
#include <iostream>  
#include <string>  
  
using namespace std;  
  
int main()  
{  
    int a[5] = {0};  
      
    for(int i=0; i<5; i++)  
    {  
        a[i] = i;  
    }  
      
    for(int i=0; i<5; i++)  
    {  
        cout << *(a + i) << endl;    // cout << a[i] << endl;  
    }  
      
    cout << endl;  
      
    for(int i=0; i<5; i++)  
    {  
        i[a] = i + 10;    // a[i] = i + 10;  
    }  
      
    for(int i=0; i<5; i++)  
    {  
        cout << *(i + a) << endl;  // cout << a[i] << endl;  
    }  
      
    return 0;  
}  

                        


            数组访问操作符( [ ] ) 
                 - 只能通过类的成员函数重载 

                －重载函数能且仅能使用—个参数 
                －可以定义不同参数的多个重载函数 

7、编程实验
重载数组访问操作符     34-3.cpp
#include <iostream>  
#include <string>  
  
using namespace std;  
  
class Test  
{  
    int a[5];  
public:  
    int& operator [] (int i)  //返回引用
    {  
        return a[i];  
    }  
      
    int& operator [] (const string& 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 length()  
    {  
        return 5;  
    }  
};  
  
int main()  
{  
    Test t;  
      
    for(int i=0; i<t.length(); i++)  
    {  
        t[i] = i;  //为什么返回引用的原因，返回的t.operator[](i)本身就为值，值赋值？
    }  
      
    for(int i=0; i<t.length(); i++)  
    {  
        cout << t[i] << endl;  
    }  
      
    cout << t["5th"] << endl;  
    cout << t["4th"] << endl;  
    cout << t["3rd"] << endl;  
    cout << t["2nd"] << endl;  
    cout << t["1st"] << endl;  
      
    return 0;  
}  

                        


8、编程实验
数组类的完善     IntArray.cpp

IntArray.h
#ifndef _INTARRAY_H_  
#define _INTARRAY_H_  
  
class IntArray  
{  
private:  
    int m_length;  
    int* m_pointer;  
      
    IntArray(int len);  
    IntArray(const IntArray& obj);  
    bool construct();  
public:  
    static IntArray* NewInstance(int length);   
    int length();  
    bool get(int index, int& value);  
    bool set(int index ,int value);  
    int& operator [] (int index);  
    IntArray& self();  
    ~IntArray();  
};  
  
#endif  

IntArray.cpp
#include "IntArray.h"  
  
IntArray::IntArray(int len)  
{  
    m_length = len;  
}  
  
bool IntArray::construct()  
{  
    bool ret = true;  
      
    m_pointer = new int[m_length];  
      
    if( m_pointer )  
    {  
        for(int i=0; i<m_length; i++)  
        {  
            m_pointer[i] = 0;  
        }  
    }  
    else  
    {  
        ret = false;  
    }  
      
    return ret;  
}  
  
IntArray* IntArray::NewInstance(int length)   
{  
    IntArray* ret = new IntArray(length);  
      
    if( !(ret && ret->construct()) )   
    {  
        delete ret;  
        ret = 0;  
    }  
          
    return ret;  
}  
  
int IntArray::length()  
{  
    return m_length;  
}  
  
bool IntArray::get(int index, int& value)  
{  
    bool ret = (0 <= index) && (index < length());  
      
    if( ret )  
    {  
        value = m_pointer[index];  
    }  
      
    return ret;  
}  
  
bool IntArray::set(int index, int value)  
{  
    bool ret = (0 <= index) && (index < length());  
      
    if( ret )  
    {  
        m_pointer[index] = value;  
    }  
      
    return ret;  
}  
  
int& IntArray::operator [] (int index)  
{  
    return m_pointer[index];  
}  
  
IntArray& IntArray::self()  
{  
    return *this;  
}  
  
IntArray::~IntArray()  
{  
    delete[]m_pointer;  
}  

main.cpp
#include <iostream>  
#include <string>  
#include "IntArray.h"  
  
using namespace std;  
  
int main()  
{  
    IntArray* a = IntArray::NewInstance(5);      
      
    if( a != NULL )  
    {  
        IntArray& array = a->self();  
          
        cout << "array.length() = " << array.length() << endl;  
      
        array[0] = 1;  //（*a)[0]=1;工程中尽量避免指针
          
        for(int i=0; i<array.length(); i++)  
        {    
            cout << array[i] << endl;  
        }  
    }  
      
    delete a;  
      
    return 0;  
}  

                    


9、小结
            string类最大程度的兼容了C字符串的用法 
            数组访问符的重载能够使得对象模拟数组的行为 
            只能通过类的成员函数重载数组访问符 
            重载函数能且仅能使用—个参数