C++ []操作符与()操作符的重载

简介

在 C++ 中，在重载下标运算符 “[ ]” 时，认为它是一个双目运算符，例如 X[Y] 可以看成：

[ ]-----双目运算符;
X-----左操作数;
Y-----右操作数。

X[Y]; 可被解释为：X.operator[](Y);

下标运算符重载函数只能定义成员函数，其形式如下：

返回类型 类名::operator[ ] (形参){
  //函数体
}

注意：形参在此表示下标，C++ 规定只能有一个参数。

方式一

返回值类型 & operator[ ] (参数);

方式二

const 返回值类型 & operator[ ] (参数) const;

使用第一种声明方式，[ ]不仅可以访问元素，还可以修改元素。

使用第二种声明方式，[ ]只能访问而不能修改元素。在实际开发中，我们应该同时提供以上两种形式，这样做是为了适应 const 对象，因为通过 const 对象只能调用 const 成员函数，如果不提供第二种形式，那么将无法访问 const 对象的任何元素。

一、[]的重载

例 1：使用下标运算符重载函数做一个可变数组的例子

#include <iostream>
using namespace std;
class Array{
public:
    Array(int length = 0);
    ~Array();
public:
    int & operator[](int i);
    const int & operator[](int i) const;
public:
    int length() const { return m_length; }
    void display() const;
private:
    int m_length;  //数组长度
    int *m_p;  //指向数组内存的指针
};
Array::Array(int length): m_length(length){
    if(length == 0){
        m_p = NULL;
    }else{
        m_p = new int[length];
    }
}
Array::~Array(){
    delete[] m_p;
}
int& Array::operator[](int i){
    return m_p[i];
}
const int & Array::operator[](int i) const{
    return m_p[i];
}
void Array::display() const{
    for(int i = 0; i < m_length; i++){
        if(i == m_length - 1){
            cout<<m_p[i]<<endl;
        }else{
            cout<<m_p[i]<<", ";
        }
    }
}
int main(){
    int n;
    cin>>n;
    Array A(n);
    for(int i = 0, len = A.length(); i < len; i++){
        A[i] = i * 5;
    }
    A.display();
   
    const Array B(n);
    cout<<B[n-1]<<endl;  //访问最后一个元素
   
    return 0;
}

例 1：使用下标运算符重载函数做一个定长数组的例子

#pragma once

class Array {

public:
	int &operator[] (int i);
	const int &operator[] (int i)const;

private:
	int array[10];
};

int &Array::operator[] (int i)
{
	return array[i];
}

const int &Array::operator[] (int i)const
{
	return array[i];
}

#include <stdio.h>
#include "Array.h"

int main()
{
	Array art;
	art[0] = 10;

	int data = art[0];
	int &d = data;
	printf("data=%d, d=%d\n", data, d);
	return 0;
}

重载下标运算符“[ ]”时，返回一个 int 型的引用，可使重载的“[ ]”用在赋值语句的左边，因而在 main 函数中，array[i] 可以出现在赋值运算符的任何一边，使编程更灵活

二、小括号()的重载

重载”()”也是一个十分有意思的操作。在c/c++中。”()”操作符表示的是一个函数调用符号，同样，它只能够通过类的成员函数来重载：

class cls
{
public:
	cls() //构造函数
	{
		printf("Hello\r\n");
	}
	~cls() //析构函数
	{
	}
	
    void operator() ()  //重载"()"操作符，"()"内无操作数
    {
        printf("HelloWorld!\n");
    }

    void operator() (const char* str) //重载"()"，"()"内的操作数是字符串
    {
        printf("%s", str);
    }
};


int main(void)
{
    cls cc;

    cc();
    cc("Hello Windows\n");

    return 0;
}

输出如下：

cc();同时触发了构造函数和重载函数;
在main()函数中，cc是一个类，但是”cc();”这样的语法却是函数调用，在项目中这样的写法可以避免代码出现函数指针.