Question

我不得不在C++号申请中与电话簿相似:附有STL联系人名单的类别议程。在接触等级方面,组合是一个称为“接触”的基流体(抽象的)和衍生类别“友好”和“接触类型”。

例如,这些班级采用了一种称为“新”的虚拟方法,将联络人的姓名重新命名。

现在,我必须执行Composite patterns,增加另一种类型的接触,即联系人(从联系人那里获得的福利),其中也包括一系列联系人(也可列入STL清单),这些联系可以是“传单”类型,也可以是公司。

因此,Company是化合物类型。

www.un.org/Depts/DGACM/index_spanish.htm 问题是:。如何以及我如何执行STL? 在“传单”类接触和公司内部收集中,我是否找到与某个名字的联系(通过获得Name功能或建议我先餐)?

换言之,我如何利用统一的功能定义来tra树,以找到可能与之相匹配的树木?

我希望我非常清楚。

Answer 1

这样做的一个途径是:

virtual contact* contact::findContact(std::string name)
{
    if(m_name == name) {return this;}
    return NULL;
}

然后:

contact * Company::findContact(std::string name)
{
    if(!contact::findContact(name) )
    {
        //For each contact in the contact list, findContact(name)
        //If we find something, return that.
        //Otherwise return null.
    }
    return this;
}

你们再做的是,在不照顾到哪类 no(传单或其他)的情况下,要求每个节点找到你们重新寻找的东西。然后,每个节点检查自己的孩子,并检查有孩子的孩子。

Answer 2

List is the wrong type for a large type of contacts since you might have a O(N) to find the last contact or even to find no contact.
I suggest you to use a hash map (unordered_map from boost/tr1) or a regular map so you will be able to find them by ID or their name using a key.
Also sounds like a company should just be a tree of contacts.
You can find tree implementations here.
You transvase through the tree to find the node you need.

Answer 3

“我必须实施复合型态,增加另一种接触类型,即联系人(从联系人那里获得的福利),其中还包括一系列联系人(也可列入STL清单),这些联系人可以是“传单”型,也可以是公司”。

你们可以为公司创建一种精炼的复合炉子。

class Company : public Contact {
    std::list<Contact *> contactList;

    //snip...other private members
    friend class CompanyIterator;
    friend class ConstCompanyIterator;
  public:

     // nested iterator classes
     class CompanyIterator : public std::iterator<std::forward_iterator_tag, Contact *> {

          friend class Company;
          // pair<>.first is the iterator obtain by calling begin()
          // pair<>.second is the end iterator
          std::stack< std::pair< std::list<Contact *>::iterator, 
                      std::list<Contact *>::iterator> > iters_stack;

          Contact *pCurrentContact;
          Company *pCompany; // This is the top level company which will be iterated.

        public:

          explicit CompanyIterator(Company &c);

          // Required forward iterator methods follow
          CompanyIterator();
          CompanyIterator(const CompanyIterator&);
          CompanyIterator& operator=(const CompanyIterator& other);
          Contact &operator*() const;
          Contact *operator->() const;
          CompanyIterator& operator++();
          CompanyIterator operator++(int);

          bool operator==(const CompanyIterator& x) const;
          bool operator!=(const CompanyIterator& x) const;
     };

     // nested iterator class
     class ConstCompanyIterator : public std::iterator<std::forward_iterator_tag, 
          const Contact *> {

          friend class Company;
          // We use CompanyIterator to implement ConstCompanyIteraor  
           CompanyIterator inner_iter; // fwd operations here,
                                      // using "const_cast<Company *>(this)->method()"
        public:

          explicit ConstCompanyIterator(const Company & dir);

          // This ctor will function as a cast operator, to convert a CompanyIterator
          // into a ConstCompanyIterator
          ConstCompanyIterator(const CompanyIterator &iter);

          // Required forward iterator methods follow
          ConstCompanyIterator();
          ConstCompanyIterator(const ConstCompanyIterator&);
          ConstCompanyIterator& operator=(const ConstCompanyIterator& other);

          const Contact &operator*() const;
          const Contact *operator->() const;

          ConstCompanyIterator& operator++();
          ConstCompanyIterator operator++(int);

          bool operator==(const ConstCompanyIterator& x) const;
          bool operator!=(const ConstCompanyIterator& x) const;
     };

    typedef CompanyIterator iterator;
    typedef ConstCompanyIterator const_iterator;

    iterator begin();
    iterator end();

    const_iterator begin() const;
    const_iterator end() const;

    // snip... other Company public methods
};

为实施上述前导器方法,见。大部分执行都是在名录上。混凝土编码是用于模拟档案系统的复合模式。班级名录是合成物。一级档案是传单。 Node是基地组成部分。

寻找者——如果愿意的话

 FindIfFunctor {
      std::string name;
    public:
     FindIfFunctor(const std::string& n) : name(n) {} 
     bool operator()(const Contact& c) { return c.getName().compare(name); }
 };

最后,发现:

 Company c;
 // snip... stuff gets added to company
 string someName("IBM");

 find_if(c.begin(), c.end(), FindIfFunctor(someName));

友情链接