Effective C++ 条款24 若所有参数皆需类型转换,请为此采用non-member函数

灰太狼 2022-05-18 08:07 133阅读 0赞

1. 通常,将只接受拷贝构造函数声明为explict是一个不错的主意,因为这可以避免自动的隐式类型转换所带来的错误,但有些情况下,使类支持隐式类型转换是可行的,例如自定义的数值类型:

class Rational {
      public:
        Rational(int a = 0, int b = 1) : _numerator(a), _denominator(b),_result(a/b) {
        }
        //不好的写法
    //    const Rational operator*(const Rational &rhs) const {
    //        return (numerator() * rhs.numerator()) / (denominator() * rhs.denominator());
    //    }
        int numerator() const {
            return _numerator;
        }
        int denominator() const {
            return _denominator;
        }
        float result()const{
            return _result;
        }
      private:
        int _numerator   = 0;
        int _denominator = 1;
        float _result = 0;
    };

2. 就1中例子而言,如果想要为Rational类定义数值运算,例如operator\*,那么将其声明为non-member-non-friend函数比member函数对混合运算的支持度更好,例如,以下两个函数:

const Rational operator*(const Rational &rhs) const {
            return (numerator() * rhs.numerator()) / (denominator() *rhs.denominator());
    }
    const Rational operator*(const Rational &lhs, const Rational &rhs) {
        return Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());
    }

后者对于Rational和int类型混合运算的支持度显然比前者高:

虽然对于

Rational result=oneHalf*1;//oneHalf是Rational类型对象

两者都能胜任,但对于

Rational result=1*oneHalf;//oneHalf是Rational类型对象

只有后者可以调用,这是由于member函数含有一层语义:函数的第一个参数必须是函数所属的类类型对象.

另外,由于可以通过numerator()和denominator()访问类成员,因此最好不要把operator\*声明为friend以免降低封装性.

//
    //  main.cpp
    //  条款24：若所有参数皆需类型壮汉，请为此采用non-member函数
    //
    //  Created by 于磊 on 2018/7/21.
    //  Copyright © 2018 于磊. All rights reserved.
    //
    /*
     *考虑有理数乘法，重载算数运算符，为满足交换律，如a * 2 = x.operator *2 2*a = 2.operator*a
     *非explicit构造函数需要对参数进行类型转换，如果某个函数要对所有参数进行类型转换，这个函数必须是个non-member
     */
    #include <iostream>
    
    class Rational {
      public:
        Rational(int a = 0, int b = 1) : _numerator(a), _denominator(b),_result(a/b) {
        }
        //不好的写法
    //    const Rational operator*(const Rational &rhs) const {
    //        return (numerator() * rhs.numerator()) / (denominator() * rhs.denominator());
    //    }
        int numerator() const {
            return _numerator;
        }
        int denominator() const {
            return _denominator;
        }
        float result()const{
            return _result;
        }
      private:
        int _numerator   = 0;
        int _denominator = 1;
        float _result = 0;
    };
    const Rational operator*(const Rational &lhs, const Rational &rhs) {
        return Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());
    }
    int main(int argc, const char * argv[]) {
        Rational r1(1,20);
        Rational r2(1,2);
        Rational t = r1*2;              //隐式转换Rational类型与int类型,编译器先查找成员函数，在在外部查找
        return 0;
    }