标签: circular-dependency

在我寻找一个可以处理多种语言并以增量方式构建代码的构建系统时，我发现 Bazel 是一个非常好的解决方案。然而，有一个问题我没有解决方案。

我有带有循环依赖关系的 C++ 代码。在问题解决之前，我需要一个可以构建此类代码的构建系统。我的问题是，Bazel 可以构建具有循环依赖的代码，尤其是 C++ 代码吗？如果是，有人可以分享指南或一些有用的链接吗？

我们正在做一些重构，但我们已经碰壁了。有两个服务类 AService 和 BService 做不同的工作，具有循环依赖关系。早些时候它们位于不同的库中，因此不存在循环依赖。但现在重构后，我们已将它们移至单个库中的单个包中。服务作业是将一些数据保存到 NoSQL 数据库中以供单独的用例使用。BService 作业与 AService 作业完全不同。AService需要BService来获取一些数据。BService需要AService将一些数据写入NoSQL数据库并读回。

如何通过使它们彼此依赖来解决循环依赖问题。有针对此类问题的设计模式吗？

class AService {
@Autowired
private BService bService;

}

class BService {
@Autowired
private AService aService;

}

我有这个问题：

我有 A 类，它是 B 类的朋友。A 类有一个vector<B>. 但我希望 B 类能够访问 A 类。

class A
{
   friend class B;
   static vector<B*> buffer;
}

Class B
{
public:
   B()
   {
      A::buffer.push_back(this);
   }
}

还有其他方法可以自动将 B 类添加到向量中吗？

感谢您的任何帮助！

当我有以下最小重现代码时：

启动.py

from __future__ import annotations

import a

a.py

from __future__ import annotations

from typing import Text

import b

Foo = Text

b.py

from __future__ import annotations

import a

FooType = a.Foo

我收到以下错误：

soot@soot:~/code/soot/experimental/amol/typeddict-circular-import$ python3 start.py
Traceback (most recent call last):
  File "start.py", line 3, in <module>
    import a
  File "/home/soot/code/soot/experimental/amol/typeddict-circular-import/a.py", line 5, in <module>
    import b
  File "/home/soot/code/soot/experimental/amol/typeddict-circular-import/b.py", line 5, in <module>
    FooType = a.Foo
AttributeError: partially initialized module 'a' has no attribute 'Foo' (most likely due to a …

好的,这就是我的错误:'Enemy'未在此范围内声明.错误在map.h文件中,即使map.h包含enemy.h,如图所示

#ifndef MAP_H_INCLUDED
#define MAP_H_INCLUDED

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

#include "enemy.h"

#define MAX_TILE_TYPES 20

using namespace std;

class Map{
        public:
        Map();
        void loadFile(string filename);
        int** tile;
        int** ftile;
        bool solid[MAX_TILE_TYPES];
        int width;
        int height;
        int tileSize;

        vector<Enemy> enemies;

};

#endif // MAP_H_INCLUDED

这是敌人

#ifndef ENEMY_H_INCLUDED
#define ENEMY_H_INCLUDED

#include "global.h"
#include "map.h"

class Enemy{
        public:
        Enemy();
        Enemy(float nx, float ny, float nstate);
        void update(Map lv);
        bool rectangleIntersects(float rect1x, float rect1y, float rect1w, float rect1h, float rect2x, float …

我有两个类，如下所示：

public class A{
private String id ;
private SortedMap<String,B> answer = new TreeMap<String,B>();
private String text;
}

public class B{
private String id = null ;
private SortedMap<String,A> question = new TreeMap<String,A>();
private String text = null;
}

有什么办法可以从上述类中删除循环依赖项？

我在两个不同的单元中创建了两个不同的类,我将如何创建循环引用？在Delphi中(类别在不同的单元中)

单元1:

Uses unit2;

type Ta = class(tobject)
   public
       b:Tb;
end;

单元2:

type Tb = class(tobject)
   public
       a:Ta;
end;

我正在尝试编译以下内容:

啊

#include "B.h"
class A {
    B * b;
    void oneMethod();
    void otherMethod();
};

A.cpp

#include "A.h"
void A::oneMethod() { b->otherMethod() }
void A::otherMethod() {}

BH

#include "A.h"
class B {
    A * a;
    void oneMethod();
    void otherMethod();
};

B.cpp

#include "B.h"       
void B::oneMethod() { a->otherMethod() }
void B::otherMethod() {}

到目前为止,我没有遇到使用前向声明的问题,但我现在可以使用它,因为我不能使用只有前向声明的类的atributtes或方法.

我怎么解决这个问题？

我们进行了一项练习,除非绝对必要,否则停止使用--start-group和--end-group进行静态链接.我们无条件地使用了这个,无论所讨论的静态库是否具有循环依赖性.我理解在我们取出无条件的--start-group和--end-group之后,链接器的压力较小,但只将它放在真正需要的地方.

我想知道动态链接库的这些选项的重要性.

ld.so运行时加载程序如何解决动态库的循环依赖关系(如果有的话)？

这提出了另一个问题,我们是否真的要担心动态库的--start-group和--end-group使用呢？

说实话,我还没有读到这个,但我觉得可以在这里问一下.

我有两个相互依赖的类:

// model.h
#include "facet.h"
class Model {
    ...
    std::map<int, std::vector<Facet*> > enqueue_list_;
}

// facet.h
#include "model.h"
class Facet {
    ...
    Model *parent_;
}

编译时,编译器显然非常沮丧.我用这样的前向类声明修复了它:

// model.h
#include "facet.h"
class Facet;
class Model {
    ...
    std::map<int, std::vector<Facet*> > enqueue_list_;
}

// facet.h
#include "model.h"
class Model;
class Facet {
    ...
    Model *parent_;
}

但我不喜欢这样做.这对我来说似乎很麻烦,很难维护.我认为通过使用头文件开始解决这类问题.有没有更好的方法来解决我错过的问题？我不想在其他类头文件中转发声明类.我觉得我在这里缺少一些重要的东西.如果我仍然遇到交叉依赖性投诉,那么头文件的确切意义何在？
提前谢谢,
马克斯

编辑

感谢您的快速回复.我接受了建议并删除了头文件中的包含,并完全切换到转发声明.我是正确的假设我仍然需要实际包含标头,如果类具有类似直接的类分配:

// facet.h
#include "point.h"
class Facet {
    ...
  private:
    Point normal_;
}

在尝试使用前向声明时,我遇到了错误.这确实是我必须要做的情况#include吗？