Question

我有一个类层次结构，如下面的示例所示，其中State包含ZipCode列表和City s列表，每个列表包含指向ZipCode秒。

目标是能够更新ZipCode而无需更新City（或创建City的新实例）。

下面的C ++代码符合此要求，但它使用指针，我希望避免使用指针，因为this和that。 如何重新设计这个[天真]实现，以便它不依赖于指针？感谢您的帮助！

编辑：更新了以下代码，使用boost::shared_ptr代替原始指针。请注意，State，City和ZipCode只是示例名称，但结果却是糟糕的选择名称（我可以选择“A”，“B”和“ C“）因为实际代码允许等同于City来共享ZipCode s。

#include <iostream>
#include <vector>
#include <boost/shared_ptr.hpp>

using namespace std;

/**
 * Zone Improvement Plan (ZIP) code
 */
class ZipCode {
public:
    ZipCode() : code_(0), plus4_(0) {}
    ZipCode(int code, int plus4 = 0) : code_(code), plus4_(plus4) {}
    virtual ~ZipCode() {};

    int code() const { return code_; }
    int plus4() const { return plus4_; }
    void set_code(int code) { code_ = code; }
    void set_plus4(int plus4) { plus4_ = plus4; }

private:
    int code_;
    int plus4_;
};

typedef boost::shared_ptr<ZipCode> ZipPtr;

/**
 * City points to one or more zip codes
 */
class City {
public:
    const vector<ZipPtr>& zip() const { return zip_; }
    void add_zip_ptr(const ZipPtr x) { if (x != NULL) zip_.push_back(x); }

private:
    // TODO: this vector should be a hash set
    vector<ZipPtr> zip_;
};

/**
 * State contains cities, each of which has pointers to
 * zip codes within the state.
 */
class State {
public:
    const vector<City>& city() const { return city_; }
    const vector<ZipPtr>& zip() const { return zip_; }

    const ZipPtr zip_of(int code) const {
        for (size_t i = 0; i < zip_.size(); i++) {
            if (zip_[i]->code() == code) {
                return zip_[i];
            }
        }
        return ZipPtr();
    }

    void add_city(const City& x) { city_.push_back(x); }
    void add_zip(int code) { zip_.push_back(ZipPtr(new ZipCode(code))); }

private:
    // TODO: these vectors should be hash sets
    vector<City> city_;
    vector<ZipPtr> zip_;
};

int main() {
    State texas;
    City dallas, houston;

    // create state ZIPs
    texas.add_zip(75380);
    texas.add_zip(75381);
    texas.add_zip(77219);
    texas.add_zip(77220);

    // point city ZIPs to the ones we just created
    dallas.add_zip_ptr(texas.zip_of(75380));
    dallas.add_zip_ptr(texas.zip_of(75381));
    houston.add_zip_ptr(texas.zip_of(77219));
    houston.add_zip_ptr(texas.zip_of(77220));

    // print all ZIPs
    cout << "ZIPs in Texas: " << endl;
    const vector<ZipPtr>& zips = texas.zip();
    for (size_t i = 0; i < zips.size(); i++) {
        cout << "    " << zips[i]->code() << endl;
    }
    cout << "ZIPs in Dallas, Texas: " << endl;
    const vector<ZipPtr> zip_ptrs1 = dallas.zip();
    for (size_t i = 0; i < zip_ptrs1.size(); i++) {
        cout << "    " << zip_ptrs1[i]->code() << endl;
    }
    cout << "ZIPs in Houston, Texas: " << endl;
    const vector<ZipPtr> zip_ptrs2 = houston.zip();
    for (size_t i = 0; i < zip_ptrs2.size(); i++) {
        cout << "    " << zip_ptrs2[i]->code() << endl;
    }

    // change a state ZIP...
    cout << "Changing Houston's ZIP 77220..." << endl;
    ZipPtr z = texas.zip_of(77220);
    if (z != NULL) z->set_code(88888);

    // ...and show the ZIPs of the affected city
    cout << "ZIPs in Houston, Texas: " << endl;
    const vector<ZipPtr> zip_ptrs3 = houston.zip();
    for (size_t i = 0; i < zip_ptrs3.size(); i++) {
        cout << "    " << zip_ptrs3[i]->code() << endl;
    }

    return 0;
}

Answer 1

我认为情况是两个1：n关系

州：城市== 1：n
城市：邮政编码 == 1：n

基于此，我认为State包含

vector<ZipCode> zip_;

不健全。

我可能会这样做

class State {
    vector< City > cities_in_state_;
};

class City {
    vector< Zipcode > zips_in_city_;
};

这不需要指针。

Answer 2

除非您想复制ZipCode对象，否则您将属于此类用法（在your first link中描述）：

Bar实例实际上是托管的通过你的程序的其他部分，而Foo类只需要能够访问它。

这似乎是合法使用。

但是，您可能需要考虑复制选项（如果向量必须重新分配其数据，则永久性地避免问题）或从State汇总ZipCodes聚合Cities而不是分发他们ZipCodes。

该副本仅表示您停止使用City中的指针。汇总ZipCodes意味着您不会向州提供ZipCodes列表，而是给City个ZipCode个实例列表，并在调用zip_of时，将遍历城市并迭代他们的 ZipCode集合。

像C ++设计模式这样的东西可以避免指针？

2 个答案: