第十一章使用类

C 自学笔记 第十一章使用类，内容包含： 1. 运算符重载 2. 计算时间：一个运算符的重载示例 3. 友元 4. 重载运算符：作为成员函数还是非成员函数 5. 再谈重载：一个矢量类 6. 类的自动转换和强制转换类型

第十一章 使用类

• 1. 运算符重载
  • 定义
    • operator op ( )
  • 表示法
    • 1. 运算符重载表示法
      • district2 = sid + sara；
    • 2. 函数表示法
      • sid.operator +(sara);
        • 隐式调用sid类
          • 作为类使用类方法
        • 显示使用sara类
          • 作为参数
• 2. 计算时间：一个运算符的重载示例
  • 1. 添加加法运算符
    • 运算符重载表示法
      • Sum = coding + fixing ;
    • 函数表示法
      • Sum = coding.operator+(fixing);
  • 2. 重载限制
    • 限制
      • 1. 重载后的运算符至少有一个操作数是用户定义的类型
      • 2. 使用运算符不能违反运算符原来的语法规则
      • 3. 不能创建新运算符
      • 4. 不能重载某些运算符
        • P316
      • 5. 以下运算符只能在成员函数中重载
        • 1. = 赋值运算符
          • 在类中，没有对赋值运算符重载，则自动调用与赋值语句右侧匹配的构造函数
          • class Num； Num a； a = 10 》》》 a（10）
        • 2. （）函数调用运算符
        • 3. [ ] 下标运算符
        • 4. -> 通过指针访问类成员的运算符
        • 5. 原因
          • 以上符号在类中有默认的函数，如果进行（重载），在非成员函数重载
          • 造成二义性
  • 3. 其他重载运算符
    • 1. 注意函数声明是用 operator op 替代函数名即可
    • 2. 函数定义记得加 类名和作用域解析运算符
• 3. 友元
  • 1. 定义
    • 1. 友元函数
    • 2. 友元类
    • 3. 友元成员函数
  • 2. 使用用途
    • 在使用*时遇到问题
      • 在重载二元运算符时常用
      • 1. A * 2.5 与 2.5 * A 不相同
      • 2. 因为* 左边必须是类调用对象
    • 解决方法
      • 1. 固定使用方式 A * 2.5
      • 2. 使用非成员函数，使之能操作类成员
        • 友元函数
  • 3. 创建友元
    • 定义
      • 1. 不属于类的成员函数，但可以访问类成员
    • 步骤
      • 1||| 放在类声明中，并在原型前加上关键字 friend
        • A. 不是成员函数，不能使用成员运算符来调用
        • B. 不是成员函数，但与成员函数的访问权限相同
      • 2||| 编写函数定义，因为不是成员函数，不用加限定符 Time:: ，定义中也不用加 friend
    • 例子
      • friend Time operator*(double m ,const Time& t );
      • A = 2.5 * B
        • >>
          • A = operator * (2.5 , B)
    • 取巧
      • return B * 2.5
  • 4. 常用的友元：重载<<运算符
    • 1. 如果和 * 一样采用类方法进行重载，则会产生 trip << cout 的迷惑操作
    • 2. << 的第一种重载版本
      • 采用友元函数
    • 3. << 的第二种重载版本
      • 返回值返回的是ostream的引用，可用于连续的输出
• 4. 重载运算符：作为成员函数还是非成员函数
  • 方式
    • 1. 非成员函数
      • 友元函数
      • 将使用多个参数
    • 2. 成员函数
      • 会隐式调用它被调用的对象
  • 不能同时编写，会导致二义性错误以至于编译出错
• 5. 再谈重载：一个矢量类
  • P326
• 6. 类的自动转换和强制转换类型
  • 1. 定义
    • 1. 接受一个参数的构造函数为将类型与该参数相同的值转化为类提供了蓝图
    • 2. 只有一个参数的构造函数才能作为转换函数 （或只有一个参数需要赋值，其他都有初始化）
      • 1. 类stonewt
        • stonewt myCat；
        • myCat = 19.6；
      • 2. 程序将使用构造函数 stonewt（double）来创建一个临时的stonewt对象，并将19.6作为初始化值，随后，采用逐成员赋值的方式，将该临时对象的内容复制到myCat中，称为隐式转换
        • 注意，可能若成员中有指针，成员直接赋值可能引起错误
  • 2. 如何关闭这种隐式转换
    • 1. 使用关键字 explict
    • 2. 注意显示转换仍然可行
      • 1. stonewt myCat；
      • 2. myCat = 19.6；
        • X
      • 3. 子主题
      • 4. myCat = Stonewt （19.6）；
        • √
      • 5. myCat =（Stonewt） 19.6 ；
        • √
    • 3. 如果在声明中没有使用explict，则可用于以下的隐式转换
      • 1. 将Stonewt对象初始化为 double 值时
      • 2. 将double值赋给Stonewt对象时
      • 3. 将double值 传递给接受Stonewt参数的函数时
      • 4. 返回值被声明为Stonewt的函数试图返回double值时
      • 5. 在上述任一一种情况中，使用可转换为double的内置类型时
        • 注意二步转换
        • 但注意不能存在二义性
  • 3. 转换函数
    • 1. 定义
      • 将类类型转换为内置类型
        • 是用户定义的强制类型转换
      • 注意转换函数不是构造函数
    • 2. 如何使用
      • Stonewt wolfe（285.7）；
      • double host = double （wolfe）；
      • double thinker = （double） wolfe；
      • 或double star = wolfe；
    • 3. 如何定义
      • operator typeName （）；
        • operator int（）const；
        • operator double（）const；
      • 注意
        • 1. 转换函数必须是类方法
          • 通过类方法进行调用
          • 所以不需要调用
        • 2. 转换函数不能指定返回类型
        • 3. 转换函数不能有参数
      • 调用
        • 1. double p_wt = poppins；
        • 2. int(poppins);
  • 4. 自动类型转换
    • 假设定义了多个转换函数，应注意函数调用过程中的二义性问题