C++ 指向战列舰程序c+中求和级别的指针+；

大家周日快乐

我试图自学C++，所以我正在做战舰计划。 这个版本相当标准。玩家输入一个单元格的坐标，试图击中一艘船。说明船只是否被击中的程序。如果一艘船占用的所有单元格都被命中，程序将打印一条消息，说明该船沉没。每次尝试后，程序都会通过向电路板显示所有成功的尝试（分别标记为

“*”

或

“x”

）来打印当前状态

我遇到的问题是在我的Board类中编写level函数，它总结了船上所有的级别

所以我为战舰准备了一块这样的板

   a b c d e f g h i j
  +-------------------+
 0|                   |
 1|                   |
 2|                   |
 3|                   |
 4|                   |
 5|                   |
 6|                   |
 7|                   |
 8|                   |
 9|                   |
  +-------------------+

这是我的板头文件，用于上下文：

#ifndef BOARD_H
#define BOARD_H
#include "Ship.h"
#include <vector>
class Board
{
  public:
    Board(void);
    void addShip(char type, int x1, int y1, int x2, int y2);
    void print(void);
    void hit(char c, int i);
    int level(void);
  private:
    std::vector<Ship *> shipList;
    char score[10][10];
    Ship *shipAt(int x, int y);
};
#endif

这是我的ship类（可能不必阅读所有内容，所以我只需输入level函数）

#include "Ship.h"
#include <iostream>
#include <stdexcept>
using namespace std;

//LOTS OF CODE I OMITTED FOR BREVITY


int Ship::level (void) const
{
    return lev;
}





    }

函数返回受保护变量的当前值

以下是我到目前为止对Board.cpp的介绍（很抱歉代码太长，但有必要为这个问题提供上下文）：

#包括“Board.h”
#包括“Ship.h”
#包括
使用名称空间std；
#包括
#包括
#包括
//成员函数定义
董事会：董事会（无效）
{
//字符分数[10][10]=“”；
字符分数[10][10]={{{'}；
}
空板：：添加（字符类型，int-x1，int-y1，int-x2，int-y2）
{
if（shipList.size（）迭代
Ship
s列表，并累加每个
Ship
的级别。返回累加值

int Board::level(void)
{
    int lev = 0;
    std::vector<Ship *>::iterator iter = shipList.begin();
    std::vector<Ship *>::iterator end = shipList.end();
    for ( ; iter != end; ++iter )
    {
       lev += (*iter)->level();
    }

    return lev;
}

int Board:：level（无效）
{
int-lev=0；
std:：vector:：iterator iter=shipList.begin（）；
std:：vector:：iterator end=shipList.end（）；
对于（；iter！=结束；++iter）
{
lev+=（*iter）->level（）；
}
返回lev；
}
迭代
配送
的列表，并累加每个
配送
的级别。返回累加值

int Board::level(void)
{
    int lev = 0;
    std::vector<Ship *>::iterator iter = shipList.begin();
    std::vector<Ship *>::iterator end = shipList.end();
    for ( ; iter != end; ++iter )
    {
       lev += (*iter)->level();
    }

    return lev;
}

int Board:：level（无效）
{
int-lev=0；
std:：vector:：iterator iter=shipList.begin（）；
std:：vector:：iterator end=shipList.end（）；
对于（；iter！=结束；++iter）
{
lev+=（*iter）->level（）；
}
返回lev；
}
迭代
配送
的列表，并累加每个
配送
的级别。返回累加值

int Board::level(void)
{
    int lev = 0;
    std::vector<Ship *>::iterator iter = shipList.begin();
    std::vector<Ship *>::iterator end = shipList.end();
    for ( ; iter != end; ++iter )
    {
       lev += (*iter)->level();
    }

    return lev;
}

int Board:：level（无效）
{
int-lev=0；
std:：vector:：iterator iter=shipList.begin（）；
std:：vector:：iterator end=shipList.end（）；
对于（；iter！=结束；++iter）
{
lev+=（*iter）->level（）；
}
返回lev；
}
迭代
配送
的列表，并累加每个
配送
的级别。返回累加值

int Board::level(void)
{
    int lev = 0;
    std::vector<Ship *>::iterator iter = shipList.begin();
    std::vector<Ship *>::iterator end = shipList.end();
    for ( ; iter != end; ++iter )
    {
       lev += (*iter)->level();
    }

    return lev;
}

int Board:：level（无效）
{
int-lev=0；
std:：vector:：iterator iter=shipList.begin（）；
std:：vector:：iterator end=shipList.end（）；
对于（；iter！=结束；++iter）
{
lev+=（*iter）->level（）；
}
返回lev；
}
我建议通过
ShipList
为循环（C++11）建立一个范围，以获取每个
Ship
指针并累积级别：

int Board::level() {
  int level = 0;
  for(Ship* ship : shipList)
    level += ship->level();
  return level;
}

我认为这看起来比基于迭代器或索引的for循环更干净，尤其是当元素是指针时。
我建议通过
ShipList
使用基于范围的for循环（C++11），以获取每个
Ship
指针并累积级别：

int Board::level() {
  int level = 0;
  for(Ship* ship : shipList)
    level += ship->level();
  return level;
}

我认为这看起来比基于迭代器或索引的for循环更干净，尤其是当元素是指针时。
我建议通过
ShipList
使用基于范围的for循环（C++11），以获取每个
Ship
指针并累积级别：

int Board::level() {
  int level = 0;
  for(Ship* ship : shipList)
    level += ship->level();
  return level;
}

我认为这看起来比基于迭代器或索引的for循环更干净，尤其是当元素是指针时。
我建议通过
ShipList
使用基于范围的for循环（C++11），以获取每个
Ship
指针并累积级别：

int Board::level() {
  int level = 0;
  for(Ship* ship : shipList)
    level += ship->level();
  return level;
}

我认为这比循环的迭代器或索引更干净，尤其是当元素是指针时。
我想你没抓住重点，请读。而且用C++，它不是<代码> int级（空）<代码>，而是<代码> int级（）。对不起，我必须把这个长度放进去，因为它需要清楚地传达这个问题。好的，我很感激输入。我会尽我最大的努力来为你们解决我的问题。<代码>等级（无效）<代码>相当于C++中的代码>（）/<代码>。所以，<代码>级别（无效）不是无效的，但它是多余的。它不是一个很坏的实践，它只是…不寻常。你可以查看一些中型C++项目来了解当前的C++趋势。我想你没抓住重点，请阅读。C++用的不是代码> int级别（无效）< /C>（而是代码< int级别）。对不起，我必须把这个长度放进去，因为它需要清楚地传达这个问题。好的，我很感激输入。我会尽我最大的努力来为你们解决我的问题。<代码>等级（无效）<代码>相当于C++中的代码>（）/<代码>。所以，<代码>级别（无效）不是无效的，但它是多余的。它不是一个很坏的实践，它只是…不寻常。你可以查看一些中型C++项目来了解当前的C++趋势。我想你没抓住重点，请阅读。C++用的不是代码> int级别（无效）< /C>（而是代码< int级别）。对不起，我必须把这个长度放进去，因为它需要清楚地传达这个问题。好的，我很感激输入。我会尽我最大的努力来为你们解决我的问题。<代码>等级（无效）<代码>相当于C++中的代码>（）/<代码>。所以，<代码>级别（无效）不是无效的，但它是多余的。这不是一个很坏的实践，它只是…不寻常。你可以查看一些中型的C++项目来了解当前的C++趋势。我想你没抓住要点，请重新考虑。