-1

我正在为我正在学习的 c++ 类开发一个项目，但我无法找出一些编译器错误。我的文件应该编写一个基类 sprite，它具有多态函数 draw，其他 4 个类继承自该函数。但是我无法弄清楚这些编译器问题！

main.cpp：在函数“int main()”中：

main.cpp:72:47：警告：扩展初始化列表仅适用于 -std=c++0x 或 -std=gnu++0x [默认启用]

main.cpp:72:47：错误：从初始化列表分配给数组

main.cpp:73:23: 错误：“）”标记之前的预期主表达式

main.cpp:74:21: 错误：“）”标记之前的预期主表达式

main.cpp:75:22: 错误：“）”标记之前的预期主表达式

main.cpp:76:20: 错误：“）”标记之前的预期主表达式

main.cpp:81:13: 警告：删除数组“Sprite array [4]”[默认启用]

这是我的代码！

#include "drawing.h"
class Sprite
{
  friend class Shadow;
  friend class Speedy;
  friend class Bashful;
  friend class Pokey;
private:
  int row;
  int col;
public:
  int getCol()
  {
    return col;
  }
  int getRow()
  {
    return row;
  }
  void setPosition(int x, int y)
  {
    row = x;
    col = y;
  }
  virtual void draw()
  {
    drawErrorMessage(row, col);
  }
};

class Shadow: public Sprite
{
public:
  virtual void draw()
  {
    drawShadow(row,col);
  }
};
class Speedy: public Sprite
{
public:
  virtual void draw()
  {
    drawSpeedy(row,col);
  }
};

class Bashful: public Sprite
{
public:
  virtual void draw()
  {
    drawBashful(row,col);
  }
};
class Pokey: public Sprite
{
public:
  virtual void draw()
  {
    drawPokey(row,col);
  }
};

int main()
{
  Sprite array[4];
  beginDrawing();
  array = {Shadow(),Speedy(),Bashful(),Pokey()};
  ((Shadow) (array[0]*)).setPosition(5,10);
 ((Speedy)(array[1]*)).setPosition(5,44);
 ((Bashful)(array[2]*)).setPosition(22,44);
 ((Pokey)(array[3]*)).setPosition(22,10);
  array[0].draw();
  array[1].draw();
  array[2].draw();
  array[3].draw();
  delete [] array;
  endDrawing();
}
4

1 回答 1

1

您正在做的事情存在各种问题：

1）您正在尝试将初始化列表分配给数组：

array = {Shadow(),Speedy(),Bashful(),Pokey()};

这是有效的 C++11，但不是有效的 C++98。

2) 即使您使用的是 C++11，这也是一件不幸的事情，因为将 a 分配Shadow给 aSprite会导致切片（将分配 the 的Sprite子对象Shadow，但不会分配其余的Shadow） . 请参阅什么是对象切片？更多示例。

3）您正在尝试delete[]堆栈分配的数组：

Sprite array[4];
//...
delete [] array;

一般来说，只调用delete[]你的东西new[]。简单（无关）示例：

int *arr = new int[4];
delete [] arr;

在这个问题的上下文中，您分配的是数组的元素，而不是数组本身，并且是您需要删除的元素（使用deleteand not delete[]，因为它们是使用 and not 分配的new）new[]。

4) 您试图对动态类型为Sprite. 数组的每个元素都是一个Sprite. 您可能的意思是有一个数组Sprite*，每个元素都可以指向 aShadow或 aSpeedy或 ... 此时，指向的对象的动态类型将是Shadow,Speedy等，并进行多态调用这样array[i]->draw()才有意义。

5) 此语法无效：

((Shadow) (array[0]*)).setPosition(5,10);

我假设您正在尝试（根据下面的指针数组思考）执行以下操作：

(*static_cast<Shadow*>(array[0])).setPosition(5,10);

实际上，您几乎可以肯定只是想要：

array[0]->setPosition(5,10);

一般来说，您的代码没有做正确的事情。你可能想要更像这样的东西：

class Sprite
{
private:
    int col, row;
public:
    virtual ~Sprite() {}

    virtual void draw()
    {
        drawErrorMessage(row, col);
    }

    int getCol() const
    {
        return col;
    }

    int getRow() const
    {
        return row;
    }

    void setPosition(int row_, int col_)
    {
        row = row_;
        col = col_;
    }
};

class Shadow : public Sprite
{
public:
    /*virtual*/ void draw()
    {
        drawShadow(row, col);
    }
};

// etc.

int main()
{
    const int SPRITE_COUNT = 4;
    Sprite *array[SPRITE_COUNT];
    array[0] = new Shadow;
    array[0]->setPosition(5, 10);
    // etc.
    beginDrawing();
    for(int i = 0; i < spriteCount; ++i)
    {
        array[i]->draw();
        delete array[i]; // note: polymorphic deletion, hence the need for a virtual destructor
    }
    endDrawing();
    return 0;
}
于 2013-05-23T00:20:23.643 回答