Surcharge de l'opérateur d'incrémentation / décrémentation

Opérateur d'incrémentation ++, opérateur de décrémentation - il y a des points pré / post. Afin de distinguer si l'opérateur surchargé est pré ou post opérateur, C ++ stipule:

L'opérateur précédent est surchargé en tant qu'opérateur unaire

//重载为成员函数时
T & operator ++()
T & operator --()
//重载为全局函数时
T & operator ++ (T&)
T & operatot -- (T&)

L'opérateur post est surchargé en tant qu'opérateur binaire et écrit un autre paramètre inutile

//重载为成员函数时
T & operator ++(int n)
T & operator --(int n)
//重载为全局函数时
T & operator ++(T &,int n)
T & operator --(T &,int n)

Mais lorsqu'il n'y a pas de surcharge post-opérateur mais de surcharge pré-opérateur, dans VS, obj ++ appelle également la pré-surcharge. En dev, l'erreur de compilation obj ++

class CDemo{
    
    
    int n;
    public:
    CDemo(int i=0):n(i){
    
    }
    CDemo operator++(int);//后置
    CDemo &operator++();//前置
    friend CDemo operator--(CDemo &, int);//全局后置
    friend CDemo &operator--(CDemo &);//全局前置
    friend ostream & operator<<(ostream &os,const  CDemo &d);
};
ostream &operator <<(ostream & os,const CDemo & d){
    
    
    os << d.n;
    return os;
}
CDemo CDemo::operator++(int){
    
    //成员后置
    CDemo tmp(*this);
    n++;
    return tmp;
}
CDemo & CDemo::operator++(){
    
    //成员前置
    n++;
    return *this;
}
CDemo operator--(CDemo & d,int){
    
    //全局后置
    CDemo tmp(d);
    d.n--;
    return tmp;
}
CDemo & operator--(CDemo & d){
    
    //全局前置
    d.n--;
    return d;
}

int main() {
    
    
    CDemo d(5);
    cout << (d++) << ',';//等价于d.operator++(0),成员
    cout << d << ',';
    cout << (++d) << ',';//等价于d.operator++(),成员
    cout << d << ',';
    cout << endl;
    cout << (d--) << ',';//等价于operator--(d,0),全局
    cout << d << ',';
    cout << (--d) << ',';//等价于operator--(d),全局
    cout << d << ',';
    cout << endl;
    return 0;
}

Lors de l'écriture de la surcharge de l'opérateur <<, j'ai trouvé un problème, c'est-à-dire que la référence du deuxième paramètre à CDemo doit être une référence constante, et compilée sans const. Cependant, l'utilisation de dev est un peu déroutante.

ostream &operator <<(ostream & os,CDemo & d){
    
    
    os << d.n;
    return os;
}