C++ 使用两个相同的typedef是否不好？如何避免？

由于循环依赖关系，您对某些类使用前向声明：

//B.h
class A;
class B
{
public:
   void foo(A* a);
};
typedef SmartPtr<B> BPtr;

//A.h
class B;
class A
{
public:
   void foo(B* b);
};
typedef SmartPtr<A> APtr;

显然，我不能向前声明

APtr

或

BPtr

。有效的方法是重新使用

typedef

：

//B.h
class A;
typedef SmartPtr<A> APtr;
class B
{ 
public:
   void foo(APtr a);
};
typedef SmartPtr<A> APtr;

//A.h
class B;
typedef SmartPtr<B> BPtr;
class A
{ 
public:
   void foo(BPtr b);
};
typedef SmartPtr<A> APtr;

//B.h
甲级；
类型DEF SmartPtr APtr；
B类
{ 
公众：
void foo（APtr a）；
};
类型DEF SmartPtr APtr；
//A.h
乙级;；
typedef SmartPtr BPtr；
甲级
{ 
公众：
void foo（BPtr b）；
};
类型DEF SmartPtr APtr；

---

但我不确定这是否是正确的解决方案。有没有一个标准的方法可以做到这一点？我所做的是错误的还是危险的？

假设你对这些周期性依赖有很好的理由，为什么不这样做：

// defs.h
class A;
class B;
typedef SmartPtr<A> APtr;
typedef SmartPtr<B> BPtr;

//B.h
#include "defs.h"
class B
{
public:
   void foo(APtr a);
};

//A.h
#include "defs.h"
class A
{
public:
   void foo(BPtr b);
};

//defs.h
甲级；
乙级;；
类型DEF SmartPtr APtr；
typedef SmartPtr BPtr；
//B.h
#包括“defs.h”
B类
{
公众：
void foo（APtr a）；
};
//A.h
#包括“defs.h”
甲级
{
公众：
void foo（BPtr b）；
};

在公共标头中声明智能指针和类转发一次，并将其包括在内：

fwd.h:

class A;
class B;
typedef SmartPtr<A> APtr;
typedef SmartPtr<B> BPtr;

---

问题基本上归结为该代码是否正常：

#include <memory>

struct A;

typedef std::unique_ptr<A> APtr;

struct A {};

typedef std::unique_ptr<A> APtr;

在您的情况下，它们都将APtr声明为std:：unique\u ptr的别名。A在一个声明中是不完整的类型，而在另一个声明中是完整的类型并不重要，因为该声明不需要A的完整性（如果是完整的，则在第一个typedef处会出现编译错误）

---

简而言之：它之所以有效，是因为您没有真正“使用”typedef，您只是多次声明相同的typedef，这很好。

有趣的一点是，+1。但我更喜欢其他答案提出的解决方案。看起来更清楚。我确实想到了这一点，但我认为存在另一种方式。你可能是对的，其他方式确实存在。但最好的解决方案往往是最简单的。

#include "fwd.h"

struct A {
    void foo(BPtr a);
};

#include <memory>

struct A;

typedef std::unique_ptr<A> APtr;

struct A {};

typedef std::unique_ptr<A> APtr;

extern int i;
extern int i;
extern int i, i, i, i, i, i, i;