3.7 将单向关联改为双向

【1】单向、双向关联

单向和双向关联的区别：两个类是否需要互相知道。

如果类A需要知道类B，而类B也需要知道类A，那么这两个类就应该是双向关联的。如果类A只需要知道类B，而类B不需要知道类A，那么就是单向关联。

【2】将单向关联改为双向

范例：

2.1 order类

order.h

#ifndef ORDER
#define ORDER

#include <QString>
#include "customer.h"

// 订单类
class Order
{
public:
    Order(int nId = 1, QString name = QString(), Customer* pCustomer = NULL);

    int getId();
    void setId(int nId);
    QString getName();
    void setName(QString name);
    // 获取订单的客户对象
    Customer* getCustomer();
    // 设置订单的客户对象
    void setCustomer(Customer *pObj);

private:
    int m_nId;
    QString m_name;
    Customer *m_pCustomer;
};

#endif // ORDER

order.cpp

#include "order.h"

// 订单类
Order::Order(int nId, QString name, Customer* pCustomer)
    : m_nId(nId)
    , m_name(name)
    , m_pCustomer(pCustomer)
{
    if (m_pCustomer)
    {
        m_pCustomer->friendOrders().insert(m_nId);
    }
}

int Order::getId()
{
    return m_nId;
}
void Order::setId(int nId)
{
    m_nId = nId;
}
QString Order::getName()
{
    return m_name;
}
void Order::setName(QString name)
{
    m_name = name;
}

// 获取订单的客户对象
Customer* Order::getCustomer()
{
    return m_pCustomer;
}

// 设置订单的客户对象
void Order::setCustomer(Customer *pObj)
{
    if (m_pCustomer == pObj)
    {
        return; // 如果订单的客户本来就是pObj，那么直接退出。
    }

    if (m_pCustomer != NULL)
    {
        m_pCustomer->friendOrders().remove(m_nId); // 从原客户的订单集合中删除这个订单项
    }
    m_pCustomer = pObj;  // 更换客户对象
    if (m_pCustomer != NULL)
    {
        m_pCustomer->friendOrders().insert(m_nId); // 在新客户的订单集合中添加这个订单项
    }
}

 2.2 customer类

customer.h

#ifndef CUSTOMER
#define CUSTOMER

#include <QString>
#include <QSet>

class Order;
// 客户类
class Customer
{
public:
    Customer(QString name = QString("sys"));
    // 获取客户的订单集合
    QSet<int>& friendOrders();

    // 获取客户名称
    QString getName();
    // 设置客户名称
    void setName(QString name);

    void addOrder(Order* pOrder);
private:
    QString m_name;
    QSet<int> m_orders;
};
#endif // CUSTOMER

 customer.cpp

#include "customer.h"
#include "order.h"

// 客户类
// 获取客户的订单集合
Customer::Customer(QString name) : m_name(name)
{
}

QSet<int>& Customer::friendOrders()
{
    return m_orders;
}

// 获取客户名称
QString Customer::getName()
{
    return m_name;
}

// 设置客户名称
void Customer::setName(QString name)
{
    m_name = name;
}

// 添加订单项
void Customer::addOrder(Order* pOrder)
{
    if (pOrder != NULL)
    {
        pOrder->setCustomer(this);
    }
}

 2.3 main函数

#include "customer.h"
#include "order.h"

void main()
{
    Customer* pCustomerLiu = new Customer("liu");
    QList<Order*> orders;
    for (int i = 0; i < 10; ++i)
    {
        // 创建10个订单，使其客户对象均为liu
        orders.append(new Order(i + 1, QString("item%1").arg(i + 1), pCustomerLiu));
    }

    Customer* pCustomerSun = new Customer("sun");
    orders.back()->setCustomer(pCustomerSun); // 最后一个订单的客户对象修改为sun

    Customer* pCustomerQin = new Customer("qin");
    orders.at(0)->setCustomer(pCustomerQin); // 第一个订单的客户对象修改为qin

    Order* pNewOrder = new Order(110, QString("item110"), NULL);
    pNewOrder->setCustomer(pCustomerQin); // 新建一个订单，设置其客户对象为qin
}

【3】总结

两个类都需要使用对方特性，但其间只有一条单向连接。添加一个反向指针，并使修改函数能够同时更新两条连接。

Good Good Study, Day Day Up.

顺序 选择 循环 总结