263

为什么编译器不让我转发声明 typedef？

假设这是不可能的，保持我的包含树小的最佳做法是什么？

4

10 回答 10

184

你可以做前向typedef。但是要做

typedef A B;

您必须先转发声明A：

class A;

typedef A B;
于 2009-04-30T00:55:33.467 回答
51

对于像我这样希望在某些 C++ 代码中向前声明使用 typedef 定义的 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;
 }
于 2010-01-19T18:06:37.263 回答
33

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

长表：

class MyClass;
typedef MyClass myclass_t;

简写：

typedef class MyClass myclass_t;
于 2011-08-05T02:01:02.477 回答
17

在 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);
于 2009-04-30T01:04:10.920 回答
9

因为要声明一个类型，需要知道它的大小。您可以转发声明一个指向该类型的指针，或者 typedef 一个指向该类型的指针。

如果你真的想要，你可以使用 pimpl idiom 来减少包含。但是如果你想使用类型而不是指针，编译器必须知道它的大小。

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

于 2009-04-30T00:25:24.990 回答
8

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

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

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

有趣的是，当使用指针或引用class或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
于 2014-01-02T10:34:12.353 回答
2

我有同样的问题，不想弄乱不同文件中的多个 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
于 2016-10-05T13:30:30.877 回答
2

我用继承和构造函数继承（？）替换了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;
于 2019-06-25T15:12:38.803 回答
1

正如 Bill Kotsias 所指出的，保持点的 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;
};
于 2017-05-23T13:28:59.740 回答
0

像@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
>>
{
};
于 2018-06-12T01:11:48.470 回答