《重构：改善既有代码的设计》代码实践之第七章

最新推荐文章于 2021-02-19 17:30:00 发布

giantmfc123

最新推荐文章于 2021-02-19 17:30:00 发布

阅读量185

点赞数

分类专栏：重构

本文链接：https://blog.csdn.net/mafucun1988/article/details/89391376

版权

重构专栏收录该内容

84 篇文章 3 订阅

订阅专栏

在对象之间搬移特性

Move field：搬移字段
move method: 搬移方法
extract class: 类由于承担过多责任而变的臃肿不堪，将一部分责任分离出去
inline class:类太"不负责任"，将它融入另一个类中
hide delegate:一个类使用了另一个类，将这种关系隐藏起来
remove middle man: 解决隐藏委托而导致拥有者的接口经常变化的问题
introduce foreign method: 当不能访问某个类的源码，又想把其他责任移进这个不可修改的类时，如果想加入的只是一两个函数。
introduce local extension:当不能访问某个类的源码，又想把其他责任移进这个不可修改的类时，如果想加入的不止一两个函数。

1. 搬移函数 move method

名称：搬移函数 move method
概要：在该函数最常引用的类中建立一个有着类似行为的新函数。将旧函数编程一个单纯的委托函数，或是将旧函数完全移除。
动机：在程序中，有个函数与其所驻类之外的另一个类进行更多交流，调用后者，或者被后者调用。

做法：
- 检查源类中被源函数所使用的一切特性（包括字段和函数），考虑它们是否应该被搬移
- 检查源类的子类和超类，看看是否有该函数的其他声明。如果出现其他声明，可能无法进行搬移，除非目标类中也同样表现出多态性。
- 在目标类中声明这个函数
- 将源函数的代码复制到目标函数中。调整目标函数，使之能够正常运行。如果目标函数中使用了源类中的特性，你得决定如何从目标函数引用源对象。如果目标类中没有相应的引用机制，就把源对象的引用当作参数，传给新建立的目标函数。如果源函数中包含异常处理，你得判断逻辑上应该由哪个类来处理这个异常。如果由源类来负责，就把异常处理留在原地。
- 编译目标类
- 决定如何从源函数正确引用目标对象。如果有现成的字段或者函数能够取得目标对象，如果没有，就建立一个。如果还是不行，就在源类中新建一个字段来保存目标对象。
- 修改源函数，使之成为一个纯委托函数
- 编译，测试
- 决定是否删除源函数，或者将它作为一个委托函数保留下来。如果经常在源对象中引用目标函数，就将源函数作为委托函数保留下来会比较简单。
- 如果要移除源函数，请将源类中对源函数的所有调用，替换为对目标函数的调用。
- 编译，测试
代码演示

修改之前的代码：

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class AccountType
{
public:
    bool isPremium();
private:
    int m_type;
};
class Account
{
public:
   double overdraftCharge();
   double bankCharge();
private:
   AccountType m_type;
   int m_daysOverdrawn;
};


#endif // REFACTORMOVE_H



///.cpp
#include "RefactorMove.h"


double Account::overdraftCharge()
{
        if (isPremium())
    {
        double result = 10;
        if (m_daysOverdrawn> 7)
        {
            result += (m_daysOverdrawn- 7) * 0.85;
        }
        return result;
    }
    return daysOverdrawn* 1.75;    
}

double Account::bankCharge()
{
    double result = 4.5;
    if (m_daysOverdrawn > 0)
    {
        result += m_type.overdraftCharge(m_daysOverdrawn);
    }
    return result;
}

bool AccountType::isPremium()
{
    return m_type > 0;
}

由于每种账户都有自己的“透支金额计费规则”，所以要把overdraftCharge()搬移到AccountType类中。对于overdraftCharge()的每一个特性，都要考虑是否搬走。isPremium是AccountType类， result是临时变量，所以要搬移。由于m_daysOverdrawn不会随账户类型而变化，所以留下来。当使用源类的特性时，有四种选择，本例中选第4种。
1）将这个特性也移到目标类中
2）建立或使用一个从目标类到源类的引用关系
3）将源对象当作参数传给目标函数
4）如果所需特性是个变量，将它当作参数传给目标函数
修改之后的代码：

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class AccountType
{
public:
    bool isPremium();
    double overdraftCharge(int daysOverdrawn);
private:
    int m_type;
};
class Account
{
public:
//   double overdraftCharge();
   double bankCharge();
private:
   AccountType m_type;
   int m_daysOverdrawn;
};


#endif // REFACTORMOVE_H
///.cpp
#include "RefactorMove.h"


//double Account::overdraftCharge()
//{
//    return m_type.overdraftCharge(m_daysOverdrawn);
//}

double Account::bankCharge()
{
    double result = 4.5;
    if (m_daysOverdrawn > 0)
    {
        result += m_type.overdraftCharge(m_daysOverdrawn);
    }
    return result;
}

bool AccountType::isPremium()
{
    return m_type > 0;
}

double AccountType::overdraftCharge(int daysOverdrawn)
{
    if (isPremium())
    {
        double result = 10;
        if (daysOverdrawn > 7)
        {
            result += (daysOverdrawn - 7) * 0.85;
        }
        return result;
    }
    return daysOverdrawn* 1.75;
}

如果需要源类的多个特性，就要将源对象传给目标函数。如果目标函数需要太多的源类特性，就要进一步重构。

2. 搬移字段 move field

名称：搬移字段 move field
概要：在目标类新建一个字段，修改源字段的所有用户，令它们改用新字段。
动机：在程序中，有个字段被其所驻类之外的另一个类更多的用到。

做法：
- 如果字段的访问级别是public，使用encapsulate field将它封装起来
- 编译，测试
- 在目标类中建立与源字段相同的字段，并同时建立相应的设值/取值函数
- 编译目标类
- 决定如何从源函数正确引用目标对象。如果有现成的字段或者函数能够取得目标对象，如果没有，就建立一个。如果还是不行，就在源类中新建一个字段来保存目标对象。
- 删除源字段
- 将所有对源字段的引用替换为对某个目标函数的调用。如果需要读取该变量，调用目标类的取值函数。如果需要设置该变量，调用目标类的设值函数。
- 编译，测试
代码演示

修改之前的代码：

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class AccountType
{
public:
    bool isPremium();
    double overdraftCharge(int daysOverdrawn);
private:
    int m_type;
};
class Account
{
public:
//   double overdraftCharge();
   double bankCharge();
   double interestForAmount_days(double amount, int days);
private:
   AccountType m_type;
   int m_daysOverdrawn;
   double m_interestRate;
};


#endif // REFACTORMOVE_H



///.cpp
#include "RefactorMove.h"

double Account::interestForAmount_days(double amount, int days)
{
    return m_interestRate *amount * days / 365;
}

我想要把m_interestRate搬移到AccountType类中。
修改之后的代码：

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class AccountType
{
public:
    bool isPremium();
    double overdraftCharge(int daysOverdrawn);
    void SetInterestRate(double interestRate);
    double GetInterestRate();

private:
    int m_type;
    double m_interestRate;
};
class Account
{
public:
    //   double overdraftCharge();
    double bankCharge();
    double interestForAmount_days(double amount, int days);
private:
    AccountType m_type;
    int m_daysOverdrawn;
    //double m_interestRate;
};


#endif // REFACTORMOVE_H

///.cpp
double Account::interestForAmount_days(double amount, int days)
{
    return m_type.GetInterestRate() *amount * days / 365;
}
void AccountType::SetInterestRate(double interestRate)
{
    m_interestRate = interestRate;
}

double AccountType::GetInterestRate()
{
    return m_interestRate;
}

如果源类中有很多函数已经使用了m_interestRate，可以先运用self encapsulate field. 给m_interestRate增加取值/设值函数。

3. 提炼类 extract class

名称：提炼类 extract class
概要：建立一个新类，将相关的字段和函数从旧类搬移到新类。
动机：某个类做了应该由两个类做的事。或者开发后期出现的子类化方式，如果你发现子类化只影响类的部分特性，或者发现某些特性需要以一种方式来子类化，某些特性需要以另一种方式子类化，这就意味着你需要分解原来的类。

做法：
- 决定如何分解类所负的责任
- 建立一个新类，用以表现从旧类中分离出来的责任。如果旧类剩下的责任与旧类名称不符，为旧类更名。
- 建立“从旧类访问新类”的连接关系。有可能需要一个双向连接。但是在真正需要它之前，不要建立“从新类通往旧类”的连接。
- 对于你想搬移的每一个字段，运用move field搬移之。
- 每次搬移后，编译，测试
- 使用 move method将必要函数搬移到新类。先搬移较低层次函数（也就是“被其他函数调用”多于“调用其他函数”者），再搬移较高层函数
- 每次搬移后，编译，测试
- 检查，精简每个类的接口。如果你建立起双向连接，检查是否可以将它改为单向连接
- 决定是否公开新类。如果你需要公开它，就要决定让它成为引用对象还是不可变的值对象。
代码演示

修改之前的代码：

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class Person
{
public:
    QString GetName();
    QString GetTelephoneNumber();
    QString GetOfficeAreaCode();
    void SetOfficeAreaCode(QString officeAreaCode);
    QString GetOfficeNumber();
    void SetOfficeNumber(QString officeNumber);
private:
    QString m_Name;
    QString m_OfficeNumber;
    QString m_OfficeAreaCode;
};

#endif // REFACTORMOVE_H



///.cpp
#include "RefactorMove.h"

QString Person::GetName()
{
    return m_Name;
}

QString Person::GetTelephoneNumber()
{
    return "(" + m_OfficeAreaCode + ") " +m_OfficeNumber;
}

QString Person::GetOfficeAreaCode()
{
    return m_OfficeAreaCode;
}

void Person::SetOfficeAreaCode(QString officeAreaCode)
{
    m_OfficeAreaCode = officeAreaCode;
}

QString Person::GetOfficeNumber()
{
    return m_OfficeNumber;
}

void Person::SetOfficeNumber(QString officeNumber)
{
    m_OfficeNumber = officeNumber;
}

1）将与电话号码相关的行为分离到一个独立类中。定义TelephoneNumber类来管理电话号码。
2）使用move method 将相关函数移动到TelephoneNumber类
3）考虑TelephoneNumber类的公开性和访问方式
修改之后的代码：

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class TelephoneNumber
{
public:
    void SetAreaCode(QString areaCode);
    QString GetAreaCode();
    QString GetTelephoneNumber();
    QString GetNumber();
    void SetNumber(QString officeNumber);
private:
    QString m_AreaCode;
    QString m_Number;
};

class Person
{
public:
    QString GetName();

    QString GetOfficeAreaCode();
    void SetOfficeAreaCode(QString officeAreaCode);

private:
    QString m_Name;
    QString m_OfficeAreaCode;
    TelephoneNumber m_TelephoneNumber;
};


#endif // REFACTORMOVE_H

///.cpp
QString Person::GetName()
{
    return m_Name;
}

QString TelephoneNumber::GetTelephoneNumber()
{
    return "(" + m_AreaCode + ") " +m_Number;
}

QString Person::GetOfficeAreaCode()
{
    return m_TelephoneNumber.GetAreaCode();
}

void Person::SetOfficeAreaCode(QString officeAreaCode)
{
    m_TelephoneNumber.SetAreaCode(officeAreaCode);
}

QString TelephoneNumber::GetNumber()
{
    return m_Number;
}

void TelephoneNumber::SetNumber(QString officeNumber)
{
    m_Number = officeNumber;
}

4. 将类内联化 inline class

名称：将类内联化 inline class
概要：某个类没有做太多的事情，将这个类的所有特性搬移到另一个类中，然后移除原类。
动机： inline class 正好与extract class相反。如果一个类不再承担足够责任，不再由单独存在的理由。挑选这个“萎缩类”的最频繁用户，将其塞入另一个类中。

做法：
- 在目标类身上声明源类的public 协议，并将其中所有函数委托至源类。如果“以一个独立接口表示源类函数”更合适，就应该在内联之前先使用extract interface
- 修改所有源类引用点，改为引用目标类。将源类声明为private，以斩断包之外的所有引用可能。同时修改源类的名称，编译器可以捕捉一些隐藏的引用点。
- 编译，测试
- 运用move method 和move field将源类的特性全部搬移到目标类
代码演示

修改之前的代码：

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class TelephoneNumber
{
public:
    void SetAreaCode(QString areaCode);
    QString GetAreaCode();
    QString GetTelephoneNumber();
    QString GetNumber();
    void SetNumber(QString officeNumber);
private:
    QString m_AreaCode;
    QString m_Number;
};

class Person
{
public:
    QString GetName();

    QString GetOfficeAreaCode();
    void SetOfficeAreaCode(QString officeAreaCode);

private:
    QString m_Name;
    QString m_OfficeAreaCode;
    TelephoneNumber m_TelephoneNumber;
};


#endif // REFACTORMOVE_H

///.cpp
QString Person::GetName()
{
    return m_Name;
}

QString TelephoneNumber::GetTelephoneNumber()
{
    return "(" + m_AreaCode + ") " +m_Number;
}

QString Person::GetOfficeAreaCode()
{
    return m_TelephoneNumber.GetAreaCode();
}

void Person::SetOfficeAreaCode(QString officeAreaCode)
{
    m_TelephoneNumber.SetAreaCode(officeAreaCode);
}

QString TelephoneNumber::GetNumber()
{
    return m_Number;
}

void TelephoneNumber::SetNumber(QString officeNumber)
{
    m_Number = officeNumber;
}

修改之后的代码：
1）在person中声明TelephoneNumber的所有“可见”(public)函数。
2）找到TelephoneNumber的所有用户，转而使用person的接口
3）反复使用move method 和move field，直到TelephoneNumber不存在

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class Person
{
public:
    QString GetName();
    QString GetTelephoneNumber();
    QString GetOfficeAreaCode();
    void SetOfficeAreaCode(QString officeAreaCode);
    QString GetOfficeNumber();
    void SetOfficeNumber(QString officeNumber);
private:
    QString m_Name;
    QString m_OfficeNumber;
    QString m_OfficeAreaCode;
};

#endif // REFACTORMOVE_H



///.cpp
#include "RefactorMove.h"

QString Person::GetName()
{
    return m_Name;
}

QString Person::GetTelephoneNumber()
{
    return "(" + m_OfficeAreaCode + ") " +m_OfficeNumber;
}

QString Person::GetOfficeAreaCode()
{
    return m_OfficeAreaCode;
}

void Person::SetOfficeAreaCode(QString officeAreaCode)
{
    m_OfficeAreaCode = officeAreaCode;
}

QString Person::GetOfficeNumber()
{
    return m_OfficeNumber;
}

void Person::SetOfficeNumber(QString officeNumber)
{
    m_OfficeNumber = officeNumber;
}

5. 隐藏“委托关系” hide delegate

名称：隐藏“委托关系” hide delegate
概要：客户通过一个委托来调用另一个对象。在服务类上建立客户所需的所有函数，用以隐藏委托关系。
动机：每个对象都应该尽量少的了解系统的其他部分

做法：
- 对于每一个委托关系中的函数，在服务对象端建立一个简单的委托函数
- 调整客户，令它只调用服务对象提供的函数
- 每次调整后，编译并测试
- 如果将来不再有任何客户需要取用delegate(受托类)，便可移除服务对象中的相关访问函数
- 编译，测试
代码演示

修改之前的代码：

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class Department;
class Person
{
public:
    QString GetName();
    QString GetOfficeAreaCode();
    void SetOfficeAreaCode(QString officeAreaCode);
    Department* GetDepartment();
    void SetDepartment(Department *pdepartment);

private:
    QString m_Name;
    QString m_OfficeAreaCode;
    TelephoneNumber m_TelephoneNumber;
    Department *m_pDepartment;
};
class Department
{
public:
    Department(Person manager);
    Person GetManager();
private:
    QString m_ChargeCode;
    Person m_Manager;
};
#endif // REFACTORMOVE_H

///.cpp

Department* Person::GetDepartment()
{
    return m_pDepartment;
}

void Person::SetDepartment(Department *pdepartment)
{
    m_pDepartment = pdepartment;
}

Department::Department(Person manager)
{
    m_Manager = manager;
}

Person Department::GetManager()
{
    return m_Manager;
}
///main.cpp
    Person person;
    Department department(person);
    Person manager = person.GetDepartment()->GetManager();

如果客户希望指导某人的经理是谁，他必须要先取得Department对象。
manager = person.GetDepartment()->GetManager();
这样的编码就是对客户揭露了Department的工作原理。如果对客户隐藏Department,可以减少耦合。
于是，在Person中建立一个简单的委托函数。
修改之后的代码：

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class Person
{
public:
Person GetManager();
};

#endif // REFACTORMOVE_H

///.cpp
#include "RefactorMove.h"
Person Person::GetManager()
{
    return m_pDepartment->GetManager();
}
///main.cpp
    Person person;
    Department department(person);
    Person manager = person.GetManager();

6. 移除中间人 remove middle man

名称：移除中间人 remove middle man
概要：某个类做了过多的简单委托动作，让客户直接调用受托类
动机：每当客户使用受托类的新特性，就要在服务端增加一个简单委托函数，当受托类越来越多的时候，就会导致服务类完全变成了一个“中间人”

做法：
- 建立一个函数，用以获得受托对象
- 对于每个委托函数，在服务类中删除该函数，并让需要调用该函数的客户转为调用受托对象
- 处理每个委托函数后，编译，测试
代码演示

修改之前的代码：

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H
class Department;
class Person
{
public:
    QString GetName();
    QString GetOfficeAreaCode();
    void SetOfficeAreaCode(QString officeAreaCode);
    Department* GetDepartment();
    void SetDepartment(Department *pdepartment);
    Person GetManager();

private:
    QString m_Name;
    QString m_OfficeAreaCode;
    TelephoneNumber m_TelephoneNumber;
    Department *m_pDepartment;
};
class Department
{
public:
    Department(Person manager);
    Person GetManager();
private:
    QString m_ChargeCode;
    Person m_Manager;
};


#endif // REFACTORMOVE_H

///.cpp
#include "RefactorMove.h"
Department* Person::GetDepartment()
{
    return m_pDepartment;
}

void Person::SetDepartment(Department *pdepartment)
{
    m_pDepartment = pdepartment;
}

Person Person::GetManager()
{
    return m_pDepartment->GetManager();
}

Department::Department(Person manager)
{
    m_Manager = manager;
}

Person Department::GetManager()
{
    return m_Manager;
}


///main.cpp
    Person person;
    Department department(person);
    Person manager = person.GetManager();

修改之后的代码：

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class Department;
class Person
{
public:
    QString GetName();
    QString GetOfficeAreaCode();
    void SetOfficeAreaCode(QString officeAreaCode);
    Department* GetDepartment();
    void SetDepartment(Department *pdepartment);

private:
    QString m_Name;
    QString m_OfficeAreaCode;
    TelephoneNumber m_TelephoneNumber;
    Department *m_pDepartment;
};
class Department
{
public:
    Department(Person manager);
    Person GetManager();
private:
    QString m_ChargeCode;
    Person m_Manager;
};
#endif // REFACTORMOVE_H

///.cpp

Department* Person::GetDepartment()
{
    return m_pDepartment;
}

void Person::SetDepartment(Department *pdepartment)
{
    m_pDepartment = pdepartment;
}

Department::Department(Person manager)
{
    m_Manager = manager;
}

Person Department::GetManager()
{
    return m_Manager;
}
///main.cpp
    Person person;
    Department department(person);
    Person manager = person.GetDepartment()->GetManager();

7. 引入外加函数 introduce foreign method

名称：引入外加函数 introduce foreign method
概要：在客户类中建立一个函数，并以第一参数形式传入一个服务类实例
动机：如果正在使用一个类，为你提供了需要的所有服务。而你想要增加新的服务，这个类却无法供应。你不得不在客户端编码，补足你要的那个函数。而这个函数本应该在提供服务的类中实现。增加的函数个数为1-2个。
做法：
- 在客户类中建立一个函数，用来提供你需要的功能。这个函数不应该调用客户类的任何特性，如果它需要一个值，就把该值当作参数传给它。
- 以服务类实例作为该函数的第一个参数。
- 将该函数注释为：“外加函数，应该在服务类实现”
代码演示

修改之前的代码：

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H
class Date
{
public:
    Date(int year, int month, int day);
    int GetYear();
    int GetMonth();
    int GetDay();
private:
    int m_Year;
    int m_Month;
    int m_Day;
};

#endif // REFACTORMOVE_H

///.cpp
Date::Date(int year, int month, int day)
{
    m_Year = year;
    m_Month = month;
    m_Day = day;
}

int Date::GetYear()
{
    return  m_Year;
}

int Date::GetMonth()
{
    return  m_Month;
}

int Date::GetDay()
{
    return m_Day;
}

///main.cpp
Date date1(2019, 4, 18);
Date newStart = Date(date1.GetYear(), date1.GetMonth(), date1.GetDay() + 1);

修改之后的代码：

///main.cpp
Date NextDay(Date date)
{
    return Date(date.GetYear(), date.GetMonth(), date.GetDay() + 1);
}
Date date1(2019, 4, 18);
Date newStart = NextDay(date1);

8. 引入本地扩展 introduce local extension

名称：引入本地扩展 introduce local extension
概要：需要为服务类提供一些额外函数，但你无法修改这个类。建立一个新类，使它包含这些额外函数。让这个扩展品成为源类的子类或包装类。
动机：如果正在使用一个类，为你提供了需要的所有服务。而你想要增加新的服务，这个类却无法供应。你不得不在客户端编码，补足你要的那个函数。而这个函数本应该在提供服务的类中实现。增加的函数个数超过2个。

做法：
- 建立一个扩展类，将它作为原始类的子类或包装类
- 在扩展类中加入转型构造函数。转型构造函数是指“接受原对象作为参数”的构造函数。如果采用子类化方案，转型构造函数应该调用适当的超类构造函数。如果采用包装类方案，那么转型构造函数应该将它得到的传入参数以实例变量的形式保存起来，用作接受委托的原对象。
- 在扩展类中加入新特性。
- 根据需要，将原对象替换为扩展对象
- 将针对原始类定义的所有外加函数搬移到扩展类中。
代码演示

修改之前的代码：

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H
class Date
{
public:
    Date(int year, int month, int day);
    int GetYear();
    int GetMonth();
    int GetDay();
private:
    int m_Year;
    int m_Month;
    int m_Day;
};

#endif // REFACTORMOVE_H

///.cpp
Date::Date(int year, int month, int day)
{
    m_Year = year;
    m_Month = month;
    m_Day = day;
}

int Date::GetYear()
{
    return  m_Year;
}

int Date::GetMonth()
{
    return  m_Month;
}

int Date::GetDay()
{
    return m_Day;
}

///main.cpp
Date date1(2019, 4, 18);
Date newStart = Date(date1.GetYear(), date1.GetMonth(), date1.GetDay() + 1);

修改之后的代码：

///.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H
class Date
{
public:
    Date(int year, int month, int day);
    int GetYear();
    int GetMonth();
    int GetDay();
private:
    int m_Year;
    int m_Month;
    int m_Day;
};
//子类
class MfDateSub : public Date
{
public:
    MfDateSub(int year, int month, int day);
    MfDateSub(Date *pdate);
    MfDateSub NextDay();
};
//包装类
class MfDateWrap
{
public:
    MfDateWrap(int year, int month, int day);
    MfDateWrap(Date *pdate);
    //为原始类提供所有函数的委托
    int GetYear();
    int GetMonth();
    int GetDay();
    Date NextDay();
private:
    Date *m_pOrigin;
    
};

#endif // REFACTORMOVE_H

///.cpp
Date::Date(int year, int month, int day)
{
    m_Year = year;
    m_Month = month;
    m_Day = day;
}

int Date::GetYear()
{
    return  m_Year;
}

int Date::GetMonth()
{
    return  m_Month;
}

int Date::GetDay()
{
    return m_Day;
}

MfDateSub::MfDateSub(int year, int month, int day):Date(year, month,day)
{
}

MfDateSub::MfDateSub(Date *pdate):Date(pdate->GetYear(), pdate->GetMonth(),pdate->GetDay())
{

}

MfDateSub MfDateSub::NextDay()
{
    return MfDateSub(GetYear(),GetMonth(),GetDay() + 1);
}

MfDateWrap::MfDateWrap(int year, int month, int day)
{
    m_pOrigin = new Date(year, month, day);
}

MfDateWrap::MfDateWrap(Date *pdate)
{
    m_pOrigin = pdate;
}

int MfDateWrap::GetYear()
{
    return m_pOrigin->GetYear();
}

int MfDateWrap::GetMonth()
{
    return m_pOrigin->GetMonth();
}

int MfDateWrap::GetDay()
{
    return m_pOrigin->GetDay();
}

Date MfDateWrap::NextDay()
{
    return  Date(GetYear(), GetMonth(), GetDay() + 1);
}

///main.cpp
    Date date1(2019, 4, 18);
    Date *newStart = new MfDateSub(&date1);
    MfDateWrap newStart2 = MfDateWrap(&date1);

问题：对于包装类有个特殊问题：如何处理“接受原始类之实例为参数”的函数？例如：bool after(Date date);
解决方案：由于无法改变原始类，所以只能使包装类上的after()函数可以接受包装类或原始类的对象。但原始类的afte()函数只能接受原始类对象，不接受包装类对象。
aWrapper.after(aDate); // OK
aWrapper.after(anotherWrapper);// OK
aDate.after(aWrapper); //not work

giantmfc123

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
《重构：改善既有代码的设计》代码实践之第七章

在对象之间搬移特性Move field：搬移字段 move method: 搬移方法 extract class: 类由于承担过多责任而变的臃肿不堪，将一部分责任分离出去 inline class:类太"不负责任"，将它融入另一个类中 hide delegate:一个类使用了另一个类，将这种关系隐藏起来 remove middle man: 解决隐藏委托而导致拥有者的接口经常变...
复制链接

扫一扫