在C ++中对typedef的前向声明

为什么编译器不让我向前声明typedef？

假设这是不可能的，那么使我的包含树变小的最佳实践是什么？

您可以转发typedef。但是要做

typedef A B;

您必须先转发声明A：

class A;

typedef A B;

对于像我这样的人，他们希望向前声明使用typedef定义的C样式结构，在某些c ++代码中，我发现了一种解决方案，如下所示：

// a.h
 typedef struct _bah {
    int a;
    int b;
 } bah;

// b.h
 struct _bah;
 typedef _bah bah;

 class foo {
   foo(bah * b);
   foo(bah b);
   bah * mBah;
 };

// b.cpp
 #include "b.h"
 #include "a.h"

 foo::foo(bah * b) {
   mBah = b;
 }

 foo::foo(bah b) {
   mBah = &b;
 }

要“ fwd声明typedef”，您需要fwd声明一个类或结构，然后可以typedef声明类型。编译器可以接受多个相同的typedef。

长表：

class MyClass;
typedef MyClass myclass_t;

简写：

typedef class MyClass myclass_t;

在C ++中（但不是普通的C）时，它是完全合法的一个的typedef型的两倍，因此只要这两个定义是完全相同的：

// foo.h
struct A{};
typedef A *PA;

// bar.h
struct A;  // forward declare A
typedef A *PA;
void func(PA x);

// baz.cc
#include "bar.h"
#include "foo.h"
// We've now included the definition for PA twice, but it's ok since they're the same
...
A x;
func(&x);

由于要声明类型，因此需要知道其大小。您可以转发声明该类型的指针，或者typedef指向该类型的指针。

如果确实需要，可以使用pimpl惯用语来减少包含内容。但是，如果要使用类型而不是指针，则编译器必须知道其大小。

编辑：j_random_hacker在此答案中添加了一个重要的限定条件，基本上是需要知道使用该类型的大小，但是如果我们只需要知道该类型存在，则可以进行前向声明，以便创建指向该类型的指针或引用。类型。由于OP没有显示代码，但是抱怨它无法编译，因此我（可能是正确的）假设OP试图使用该类型，而不仅仅是引用它。

仅当您不打算使用类型本身（在此文件的范围内）而是使用指针或对其的引用时，才可以使用前向声明而不是 full 。 #include

要使用类型本身，编译器必须知道其大小-因此必须查看其完整声明-因此#include需要一个完整的。

但是，无论指针的大小如何，编译器都知道指针或引用的大小，因此前向声明就足够了-它声明类型标识符名称。

有趣的是，当使用指针或对classor struct类型的引用时，编译器可以处理不完整的类型，从而省去了向前声明指针类型的需要：

// header.h

// Look Ma! No forward declarations!
typedef class A* APtr; // class A is an incomplete type - no fwd. decl. anywhere
typedef class A& ARef;

typedef struct B* BPtr; // struct B is an incomplete type - no fwd. decl. anywhere
typedef struct B& BRef;

// Using the name without the class/struct specifier requires fwd. decl. the type itself.    
class C;         // fwd. decl. type
typedef C* CPtr; // no class/struct specifier 
typedef C& CRef; // no class/struct specifier 

struct D;        // fwd. decl. type
typedef D* DPtr; // no class/struct specifier 
typedef D& DRef; // no class/struct specifier 

我有同样的问题，不想弄乱不同文件中的多个typedef，所以我通过继承解决了它：

是：

class BurstBoss {

public:

    typedef std::pair<Ogre::ParticleSystem*, bool> ParticleSystem; // removed this with...

做了：

class ParticleSystem : public std::pair<Ogre::ParticleSystem*, bool>
{

public:

    ParticleSystem(Ogre::ParticleSystem* system, bool enabled) : std::pair<Ogre::ParticleSystem*, bool>(system, enabled) {
    };
};

像魅力一样工作。当然，我必须更改所有引用

BurstBoss::ParticleSystem

简单地

ParticleSystem

我用继承和构造函数继承（？）代替了typedef（using具体来说）。

原版的

using CallStack = std::array<StackFrame, MAX_CALLSTACK_DEPTH>;

已更换

struct CallStack // Not a typedef to allow forward declaration.
  : public std::array<StackFrame, MAX_CALLSTACK_DEPTH>
{
  typedef std::array<StackFrame, MAX_CALLSTACK_DEPTH> Base;
  using Base::Base;
};

这样，我就可以使用以下方式转发声明CallStack：

class CallStack;

正如Bill Kotsias指出的那样，将您的point的typedef详细信息保持私有并向前声明的唯一合理方法是继承。不过，您可以使用C ++ 11做到更好。考虑一下：

// LibraryPublicHeader.h

class Implementation;

class Library
{
...
private:
    Implementation* impl;
};

// LibraryPrivateImplementation.cpp

// This annoyingly does not work:
//
//     typedef std::shared_ptr<Foo> Implementation;

// However this does, and is almost as good.
class Implementation : public std::shared_ptr<Foo>
{
public:
    // C++11 allows us to easily copy all the constructors.
    using shared_ptr::shared_ptr;
};

像@BillKotsias一样，我使用继承，它对我有用。

我改变了这个烂摊子（这需要我声明* .h中的所有boost标头）

#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/moment.hpp>
#include <boost/accumulators/statistics/min.hpp>
#include <boost/accumulators/statistics/max.hpp>

typedef boost::accumulators::accumulator_set<float,
 boost::accumulators::features<
  boost::accumulators::tag::median,
  boost::accumulators::tag::mean,
  boost::accumulators::tag::min,
  boost::accumulators::tag::max
 >> VanillaAccumulator_t ;
std::unique_ptr<VanillaAccumulator_t> acc;

放入此声明（* .h）

class VanillaAccumulator;
std::unique_ptr<VanillaAccumulator> acc;

的实现（* .cpp）是

#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/moment.hpp>
#include <boost/accumulators/statistics/min.hpp>
#include <boost/accumulators/statistics/max.hpp>

class VanillaAccumulator : public
  boost::accumulators::accumulator_set<float,
    boost::accumulators::features<
      boost::accumulators::tag::median,
      boost::accumulators::tag::mean,
      boost::accumulators::tag::min,
      boost::accumulators::tag::max
>>
{
};