C++类前向声明

Question

当我尝试编译此代码时，我得到：

52 C:\Dev-Cpp\Projektyyy\strategy\Tiles.h invalid use of undefined type `struct tile_tree_apple' 
46 C:\Dev-Cpp\Projektyyy\strategy\Tiles.h forward declaration of `struct tile_tree_apple' 

我的代码的某些部分：

class tile_tree_apple;

class tile_tree : public tile
{
      public:
          tile onDestroy() {return *new tile_grass;};
          tile tick() {if (rand()%20==0) return *new tile_tree_apple;};
          void onCreate() {health=rand()%5+4; type=TILET_TREE;};        
};

class tile_tree_apple : public tile
{
      public:
          tile onDestroy() {return *new tile_grass;};
          tile tick() {if (rand()%20==0) return *new tile_tree;};
          void onCreate() {health=rand()%5+4; type=TILET_TREE_APPLE;}; 
          tile onUse() {return *new tile_tree;};       
};

我真的不知道该怎么做，我搜索了解决方案，但找不到与我的问题类似的任何内容...实际上，我有更多的类与父“tile”并且之前没问题...

编辑：

我决定将所有返回类型更改为指针以避免内存泄漏，但现在我得到：

27 C:\Dev-Cpp\Projektyyy\strategy\Tiles.h ISO C++ forbids declaration of `tile' with no type 
27 C:\Dev-Cpp\Projektyyy\strategy\Tiles.h expected `;' before "tick"

它仅在基类中，其他一切都好...中的每个函数返回 *tile 的tile类有这个错误......

一些 代码：

class tile
{
      public:
          double health;
          tile_type type;
          *tile takeDamage(int ammount) {return this;};
          *tile onDestroy() {return this;};
          *tile onUse() {return this;};
          *tile tick() {return this};
          virtual void onCreate() {};
};

Answer 1

尽可能使用前向声明。

假设您要定义一个使用 A 类对象的新类 B。

1. B 仅使用对 A 的引用或指针。使用前向声明则不需要包含 。这反过来会加快编译速度。

   A 类；
   
   B级 
   {
     私人的：
       A* fPtrA ;
     民众：
       void mymethod(const&A) const ;
   };
   

2. B 派生自 A 或 B 显式（或隐式）使用 A 类的对象。然后您需要包含

   #include <啊>;
   
   B 类：公共 A 
   {
   };
   
   C级 
   {
     私人的：
       一个fA；
     民众：
       void mymethod(A par) ;   
   }
   

Answer 2

为了使 new T 能够编译，T 必须是完整类型。在您的情况下，当您在 tile_tree::tick 的定义中说 newtile_tree_apple 时，tile_tree_apple 是不完整的（它已被向前声明，但是它的定义稍后在您的文件中）。尝试将函数的内联定义移动到单独的源文件中，或者至少将它们移动到类定义之后。

就像这样：

class A
{
    void f1();
    void f2();
};
class B
{
   void f3();
   void f4();
};

inline void A::f1() {...}
inline void A::f2() {...}
inline void B::f3() {...}
inline void B::f4() {...}

当您以这种方式编写代码时，这些方法中对 A 和 B 的所有引用都保证引用完整类型，因为不再有前向引用！

Answer 3

前向声明是一个“不完整类型”，您对此类类型唯一能做的就是实例化一个指向它的指针，或者在函数中引用它声明（即函数原型中的参数或返回类型）。在代码的第 52 行中，您尝试实例化一个对象。

此时编译器不知道对象的大小及其构造函数，因此无法实例化对象。

Answer 4

我有这个：

class paulzSprite;
...

struct spriteFrame
{
    spriteFrame(int, int, paulzSprite*, int, int);
    paulzSprite* pSprite; //points to the sprite class this struct frames
    static paulzSprite* pErase; //pointer to blanking sprite
    int x, y;
    int Xmin, Xmax, Ymin, Ymax; //limits, leave these to individual child classes, according to bitmap size
    bool move(int, int);
    bool DrawAt(int, int);
    bool dead;
};

spriteFrame::spriteFrame(int initx, int inity, paulzSprite* pSpr, int winWidth, int winHeight)
{
    x = initx;
    y= inity;
    pSprite = pSpr;
    Xmin = Ymin = 0;
    Xmax = winWidth - pSpr->width;
    Ymax = winHeight - pSpr->height;
    dead = false;
}

...

和原来的问题一样感到悲伤。
只能通过将 paulzSprite 的定义移动到 spriteFrame 的之后来解决。编译器不应该比这个更聪明吗（VC++，VS 11 Beta）？

顺便说一句，我完全同意克利福德上面的评论“指针不会导致内存泄漏，糟糕的编码会导致内存泄漏”。恕我直言，许多其他新的“智能编码”功能也是如此，这些功能不应取代理解您实际要求计算机执行的操作。

Answer 5

问题是 tick() 需要知道 tile_tree_apple 的定义，但它所拥有的只是它的前向声明。您应该将声明和定义分开，如下所示：

tile_tree.h

#ifndef TILE_TREE_H
#define TILE_TREE_H
#include "tile.h"

class tile_tree : public tile
{
public:
    tile onDestroy();
    tile tick();
    void onCreate();
};

#endif

tile_tree.cpp：

tile tile_tree::onDestroy() {
    return *new tile_grass;
}

tile tile_tree::tick() {
     if (rand() % 20 == 0)
         return *new tile_tree_apple;
}

void tile_tree::onCreate() {
    health = rand() % 5 + 4;
    type = TILET_TREE;
}

例外您遇到了一个主要问题：您正在分配内存（使用new），然后复制分配的对象并返回副本。这称为内存泄漏，因为您的程序无法释放它使用的内存。不仅如此，您还将 tile_tree 复制到 tile 中，这会丢弃使 tile_tree 与 不同的信息平铺；这称为切片。

您想要的是返回一个指向新tile的指针，并确保在某个时刻调用delete来释放内存：

tile* tile_tree::tick() {
     if (rand() % 20 == 0)
         return new tile_tree_apple;
}

更好的是返回一个智能指针这将为您处理内存管理：

#include <memory>

std::shared_ptr<tile> tile_tree::tick() {
     if (rand() % 20 == 0)
         return std::make_shared<tile_tree_apple>();
}

Answer 6

类tile_tree_apple 应在单独的.h 文件中定义。

tta.h:
#include "tile.h"

class tile_tree_apple : public tile
{
      public:
          tile onDestroy() {return *new tile_grass;};
          tile tick() {if (rand()%20==0) return *new tile_tree;};
          void onCreate() {health=rand()%5+4; type=TILET_TREE_APPLE;}; 
          tile onUse() {return *new tile_tree;};       
};

file tt.h
#include "tile.h"

class tile_tree : public tile
{
      public:
          tile onDestroy() {return *new tile_grass;};
          tile tick() {if (rand()%20==0) return *new tile_tree_apple;};
          void onCreate() {health=rand()%5+4; type=TILET_TREE;};        
};

另一件事：返回图块而不是图块引用并不是一个好主意，除非图块是原始类型或非常“小”类型。

Answer 7

要执行除声明指向对象的指针之外的任何操作，您需要完整的定义。

最好的解决方案是将实现移到单独的文件中。

如果您必须将其保留在标头中，请将定义移到两个声明之后：

class tile_tree_apple;

class tile_tree : public tile
{
  public:
      tile onDestroy();
      tile tick();
      void onCreate();        
};

class tile_tree_apple : public tile
{
  public:
      tile onDestroy();
      tile tick();
      void onCreate(); 
      tile onUse();       
};

tile tile_tree::onDestroy() {return *new tile_grass;};
tile tile_tree::tick() {if (rand()%20==0) return *new tile_tree_apple;};
void tile_tree::onCreate() {health=rand()%5+4; type=TILET_TREE;};        

tile tile_tree_apple::onDestroy() {return *new tile_grass;};
tile tile_tree_apple::tick() {if (rand()%20==0) return *new tile_tree;};
void tile_tree_apple::onCreate() {health=rand()%5+4; type=TILET_TREE_APPLE;}; 
tile tile_tree_apple::onUse() {return *new tile_tree;};       

重要 >

你有内存泄漏：

tile tile_tree::onDestroy() {return *new tile_grass;};

将在堆上创建一个对象，之后你无法销毁该对象，除非你做了一些丑陋的黑客行为。此外，您的对象将被切片。 不要这样做，返回一个指针。

Answer 8

要执行*newtile_tree_apple，应该调用tile_tree_apple的构造函数，但是在这个地方编译器对tile_tree_apple一无所知，所以它不能使用构造函数。

如果您放入

tile tile_tree::tick() {if (rand()%20==0) return *new tile_tree_apple;};

具有类tile_tree_apple 定义的单独cpp 文件或包含具有该定义的头文件，一切都会正常工作。