Изменение вектора родителя через наследников

#ifndef CHESS
#define CHESS
 
#include <iostream>
#include <vector>
#include <string>
#include <assert.h>
 
struct Pos {
  size_t x;
  size_t y;
};
 
class Figure {
 public:
  virtual std::string TextRepresentation() const = 0;
  virtual bool CanMove(const Pos &from, const Pos &to) = 0;
  virtual ~Figure() {}
};
 
class Cell {
 public:
  Figure *set_figure_inside_cell(Figure *figure) {
    auto old_figure = figure_inside_cell_;
    figure_inside_cell_ = figure;
    return old_figure;
  }
 
  Figure *remove_figure() {
    auto figure_inside_cell = figure_inside_cell_;
    figure_inside_cell_ = nullptr;
    return figure_inside_cell;
  }
 
  Figure *figure_inside_cell() const { return figure_inside_cell_; }
 
  std::string TextRepresentation() const {
    auto figure = figure_inside_cell();
    if (figure != nullptr) {
      return figure->TextRepresentation();
    }
    return ".";
  }
 
 private:
  Figure *figure_inside_cell_ = nullptr;
};
 
class Field {
 public:
  Field(size_t size = 8);
 
  std::string TextRepresentation() const {
    std::string text_representation;
    for (auto line : field_) {
      for (auto cell : line) {
        text_representation +=
            cell.TextRepresentation() + kCellSeparationSymbol;
      }
      text_representation += kLineSeparationSymbol;
    }
    return text_representation;
  }
 
  bool SetFigure(Figure *figure, const Pos &position) {
    auto is_position_valid = IsPositionValid(position);
 
    if (is_position_valid) {
      field_[position.y][position.x].set_figure_inside_cell(figure);
    }
    return is_position_valid;
  }
 
  void SetFigureBack(Figure *figure_from_cell, const Pos &from) {
    assert(field_[from.y][from.x].set_figure_inside_cell(figure_from_cell) ==
           nullptr);
  }
 
  bool MoveFigure(const Pos &from, const Pos &to) {
    auto are_positions_valid = IsPositionValid(from) && IsPositionValid(to);
    if (are_positions_valid) {
      auto figure_from_cell = field_[from.y][from.x].remove_figure();
      if (figure_from_cell && figure_from_cell->CanMove(from, to)) {
        auto figure_inside_destination_cell =
            field_[to.y][to.x].set_figure_inside_cell(figure_from_cell);
        if (figure_inside_destination_cell == nullptr) {
          return true;
        } else {
          SetFigureBack(figure_from_cell, from);
        }
      }
    }
    return false;
  }
 
 private:
  bool IsPositionValid(const Pos &pos) const {
    return pos.y < field_.size() && pos.x < field_[pos.y].size();
  }
 
  const char kCellSeparationSymbol = '\t';
  const char kLineSeparationSymbol = '\n';
 
  std::vector<std::vector<Cell> > field_;
};
 
Field::Field(size_t size) {
  field_.resize(size);
  for (size_t i = 0; i < size; ++i) {
    field_[i].resize(size);
  }
}
 
class Bishop : public Figure {
 public:
  std::string TextRepresentation() const override;
  bool CanMove(const Pos &from, const Pos &to) override;
};
 
class Rook : public Figure {
 public:
  std::string TextRepresentation() const override;
  bool CanMove(const Pos &from, const Pos &to) override;
};
 
#endif
 
/// -----------------------------
 
std::string Bishop::TextRepresentation() const { return "*"; }
 
bool Bishop::CanMove(const Pos &from, const Pos &to) {
  return true;
}  // todo fill with logic
 
std::string Rook::TextRepresentation() const { return "#"; }
 
bool Rook::CanMove(const Pos &from, const Pos &to) {
  return true;
}  // todo fill with logic
 
void ShowField(const Field &field) {
  std::cout << '\n' << field.TextRepresentation() << std::endl;
}
 
int main() {
  Field field;
  ShowField(field);
 
  Bishop b;
  Pos b_pos = {2, 2};
  std::cout << "set bishop figure success:" << field.SetFigure(&b, b_pos)
            << '\n';
 
  Rook r;
  Pos r_pos = {5, 2};
  std::cout << "set rook figure success:" << field.SetFigure(&r, r_pos) << '\n';
 
  ShowField(field);
 
  Pos new_b_pos = {3, 2};
  std::cout << "change bishop position success:"
            << field.MoveFigure(b_pos, new_b_pos);
 
  ShowField(field);
}