Question

我有两个A和B类

A.hpp

#include <vector>
#include <algorithm>
#include "B.hpp"

class A {
public:
  void sortTrans() { std::sort(trans_.begin(), trans_.end(), sortStruct); }
  unsigned int name() { return name_; }
private:
  std::vector<B*> trans_;
  unsigned int name_;
};

B.hpp：

class A;

class B {
  A& source_;
  A& dest_;
  unsigned int choice_;
};

现在我想通过选择和名称的值对trans_进行排序，因此我写了

struct sort {
  bool operator()(B* t1, B* t2) {
    if (t1->choice < t2->choice)
        return true;
    if (t1->dest_.name() < t2->dest_.name())
        return true;
    return false;
  }
} sortStruct;

但现在我面临着打破循环依赖的问题。 A的定义在A.hpp中，B在B.hpp中的定义。在B.hpp中，我使用A和A的前向去除，包括B.hpp。但是我必须在哪里（或如何）放置sortStruct，因为它使用了A和B的定义。而且我总是得到错误

Wrong usage of forward declaration A

感谢您的帮助。

Answer 1

两个标题都可以使用正向递减，因为它们都不是真的（需要）依赖于另一个。

A.hpp

#ifndef A_HPP
#define A_HPP
#include <vector>

class B;

class A {
public:
  void sortTrans();
  unsigned name();
private:
  std::vector<B*> trans_;
  unsigned int attr1_;
  unsigned int attr2_;
};
#endif

B.hpp

#ifndef B_HPP
#define B_HPP_
class A;

class B {
  A& source_;
  A& dest_;
  unsigned choice_;
};
#endif

A.cpp

#include "A.hpp"
#include "B.hpp"
#include <algorithm>

// I can't really define this with your B as given ...
struct SortB {
    bool operator()(B *x, B *y) {
        if (x->choice_ < y->choice_)
            return true;
        if (x->dest_.name() < y->dest_.name())
            return true;
        return false;
    }
 };

void A::sortTrans()
{
    std::sort(trans_.begin(), trans_.end(), SortB());
}

注意我还没有展示如何访问B :: choice_和B :: dest_，因为这是一个设计决定，我没有足够的信息来做出好的猜测。

您可以将它们公开为公开（在这种情况下B基本上是一个结构），将访问者成员添加到B，或者将B.hpp中的前向声明SortB添加为朋友。

Answer 2

您可以将operator()的声明B.hpp和实施 - 发送到B.cpp（照例）

// B.hpp
class A;

class B {
  A& source_;
  A& dest_;
};

SortB {
  bool operator()(B* a, B* b); // can be implemented in B.cpp
};

SortB的实施无需了解class A：

// B.cpp
bool SortB::operator()(B* t1, B* t2) {
    if (t1->attr1() < t2->attr1())
        return true;
    if (t1->attr2() < t2->attr2())
        return true;
    return false;
}

A.hpp中的代码无需进行太多更改：

// A.hpp
#include "B.hpp"

class A {
public:
  void sortTrans() { std::sort(trans_.begin(), trans_.end(), SortB()); }
private:
  std::vector<B*> trans_;
  unsigned int attr1_;
  unsigned int attr2_;
};

Answer 3

如果一个类有引用成员，则需要提供构造函数/复制构造函数。你有没有提供B

还注意到t1->attr2()＆lt; t2->attr2()不正确。它应该是t1->attr1_和t2->attr2_

Answer 4

您的排序功能可能与您的意图不同。它可能应该像

if (b1->choice < b2->choice)
    return true;
if (b1->choice == b2->choice && b1->name < b2->name)
    return true;
return false;

如果您没有选择==运算符，则必须使用＆lt;操作员反转并否定完成相同的功能

c ++打破排序算法对象的循环依赖

4 个答案: