Предварительное объявление класса C++

Чтобы new T скомпилировался, T должен быть полным типом. В вашем случае, когда вы говорите new tile_tree_apple внутри определения tile_tree::tick, 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 в этих методах гарантированно относятся к полным типам, поскольку прямых ссылок больше нет!

Используйте предварительное объявление, когда это возможно.

Предположим, вы хотите определить новый класс B, который использует объекты класса A.

1. B использует только ссылки или указатели на A. Используйте предварительное объявление, тогда вам не нужно включать <A.h>. Это, в свою очередь, немного ускорит компиляцию.

   class A ;
   
   class B 
   {
     private:
       A* fPtrA ;
     public:
       void mymethod(const& A) const ;
   } ;
   

2. B происходит от A или B явно (или неявно) использует объекты класса A. Затем вам нужно включить <A.h>

   #include <A.h>
   
   class B : public A 
   {
   };
   
   class C 
   {
     private:
       A fA ;
     public:
       void mymethod(A par) ;   
   }
   

Предварительное объявление — это «неполный тип», единственное, что вы можете сделать с таким типом, — создать экземпляр указателя на него или сослаться на него в функции объявление (т. е. и тип аргумента или возвращаемого значения в прототипе функции). В строке 52 кода вы пытаетесь создать экземпляр объекта.

В этот момент компилятор не знает ни размера объекта, ни его конструктора, поэтому не может создать экземпляр объекта.

У меня было это:

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;
}

...

Got the same grief as in the original question. Only solved by moving the definition of paulzSprite to after that of spriteFrame. Shouldn't the compiler be smarter than this (VC++, VS 11 Beta)?

И кстати, я полностью согласен с замечанием Клиффорда выше: «Указатели не вызывают утечек памяти, плохое кодирование вызывает утечки памяти». ИМХО, это верно и для многих других новых функций «умного кодирования», которые не должны заменять понимание того, что вы на самом деле просите компьютер сделать.

Проблема в том, что 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; это называется нарезка.

Что вы хотите, так это вернуть указатель на новый 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>();
}

класс 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;};        
};

еще одна вещь: возвращать тайл, а не ссылку на тайл, не очень хорошая идея, если только тайл не является примитивным или очень «маленьким» типом.

Чтобы сделать что-либо, кроме объявления указателя на объект, вам нужно полное определение.

Лучшее решение – перенести реализацию в отдельный файл.

Если вы должны сохранить это в заголовке, переместите определение после обоих объявлений:

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;};

создаст объект в куче, который вы не сможете уничтожить впоследствии, если только вы не сделаете какой-нибудь уродливый взлом. Кроме того, ваш объект будет нарезан. Не делайте этого, верните указатель.

Для выполнения *new tile_tree_apple должен быть вызван конструктор tile_tree_apple, но в этом месте компилятор ничего не знает о tile_tree_apple, поэтому он не может использовать конструктор.

Если вы положите

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

в отдельном файле cpp, который имеет определение класса tile_tree_apple или включает заголовочный файл, который имеет определение, все будет работать нормально.