c++重载操作符研究之 operator ->()

本章是介绍重载操作符 -> 的研究，上代码先

 

#include "stdafx.h"
#include <iostream>
#include <string>


template<typename T>
class A1 {
public:
    A1(T* t) : m_imp(t) {
        std::cout << "A1()" << std::endl;
    }
    ~A1() {
        std::cout << __FUNCTION__ << std::endl;
    }

    T* operator ->() {
        std::cout << __FUNCTION__ << std::endl;
        return m_imp;
    }
private:
    T* m_imp;
};

template<typename T>
class A2 {
public:
    A2(T* t) : m_imp(t) {}

    A1<T> operator ->() {
        std::cout << __FUNCTION__ << std::endl;
        A1<T> a(m_imp);
        return a;
    }
private:
    T* m_imp;
};

template<typename T>
class A3 {
public:
    A3(T* t) : m_imp(t) {}

    A2<T> operator ->() {
        std::cout << __FUNCTION__ << std::endl;
        A2<T> a(m_imp);
        return a;
    }
private:
    T* m_imp;
};

class Test {
public:
    void show() {
        std::cout << m_a << std::endl;
    }
private:
    int m_a;
};

template<typename T>
class B1 {
public:
    B1(T* t) : m_imp(t) {
        std::cout << __FUNCTION__ << std::endl;
    }
    B1(T& t) : m_imp(&t) {
        std::cout << __FUNCTION__ << std::endl;
    }
    T* operator->() {
        std::cout << __FUNCTION__ << std::endl;
        return m_imp;
    }
private:
    T* m_imp;
};

int _tmain(int argc, _TCHAR* argv[])
{
    Test* pt = new Test();

    A1<Test> a1(pt);
    a1->show();
    a1.A1::operator ->()->show();

    A2<Test> a2(pt);
    a2->show();
    // 可自动推导出如下式
    // a2.A2::operator ->().A1::operator ->()->show();

    A3<Test> a3(pt);
    a3->show();
    // 可自动推导出如下式
    // a3.A3<Test>::operator ->().A2::operator ->().A1::operator ->()->show();

    B1<Test> b1(pt);
    b1->show();

    B1<B1<Test> > b2(b1);
    b2->operator ->()->show();
    b2.B1<B1<Test> >::operator ->()->B1<Test>::operator ->()->show();
    // b2->show(); 错误，不能递归推导

	return 0;
}

基于以上代码，可以看出 对->运算符的重载,编译器无法进行递归推导.

这种递归推导，编译器可以在编译期处理，为什么编译器不处理这种递归推导，留待思考

以上代码在vc编译器测试通过。