在c＆＃x2b;＆＃x2b;中，如何使用私有变量是一系列对象？

Question

我正在尝试学习C ++，并弄清楚如何访问作为对象数组的私人成员变量。我的目标是试图打印出对象数组中的数据。假设我的标题看起来像这样。

using namespace std;

const unsigned MAX_RESULTS = 10;

class StudentRecords{
public:
  StudentRecords();

  //bunch of other getters and setters here

  Result GetResults() const; //my lame attempt at trying to access the obj-array private var

private:
  Result results[MAX_RESULTS]; // array of Result of MAX_RESULTS number of elements
  //+other private variables
};

ostream& operator <<( ostream& os, const StudentRecords& R);

在上面，应该有一个称为结果的私有结果对象数组，该对象具有Max_Results的大小，应该在这里10。现在，使用我的超载运算符＆＆lt;这个想法是将结果内容打印到“文件”以说话。由于它是一个数组，所以我想使用for循环打印出数组中的所有结果。

Result StudentRecords::GetResults() const
{
    return results[MAX_RESULTS];
}

ostream & operator <<( ostream & os, const StudentRecords& R )
{
  for(unsigned i = 0; i < SomeNumber; i++)
  {
      os << R.GetResults()[i] << '\n'; //this won't work of course see error
  }
  return os;
}

会有一个错误说明：

error: no match for 'operator[]' (operand types are 'Result' and 'unsigned int')|

我已经超载了＆lt;＆lt;我的结果类中的运算符为了打印该类中的值。问题是我不知道如何通过结果阵列迭代。从我搜索的内容来看，我了解您可以在此处使用某种指针函数： c ++：数组的设置和获取器

当我尝试以这样的方式编写功能时：

Result* GetResults() const;

我会发现一个错误说明：

error: cannot convert 'const Result' to 'Result*' in return|

抛弃 *允许代码编译，但可以预见，我从我的我那里得到了一堆垃圾值大批。因此，假设我的班级有一系列对象，而这些对象有自己的变量，那么我如何从我的对象数组中打印出值？感谢您的帮助。

Answer 1

Result StudentRecords::GetResults() const
{
    return results[MAX_RESULTS];
}

这是一个常见的新手误解。因为您声明将数组作为结果[max_results]您认为结果[max_results]以某种方式意味着整个数组。但这不是，当您使用时， array []用于访问数组的各个元素。当然，索引max_results上没有元素，这已经过去了数组的末尾。

最重要的是，声明的语法和表达式语法不是相同的。

您可以执行这样的操作，

const Result* StudentRecords::GetResults() const
{
    return results;
}

这是返回数组的指针，而不是数组本身（实际上在C ++中不可能做到这一点）。但这应该足够近。

Answer 2

一种方法是使类的输出功能部分使其可以直接访问Resulte数组。尽管运营商＆lt;＆lt;从字面上看不到您的课程的一部分，但您可以通过将其声明为朋友来使其成为逻辑上的一部分。

class StudentRecords {
    friend ostream& operator <<( ost& os, const StudentRecords& R);
    // Rest of the class definition
};

ostream & operator <<(ostream & os, const StudentRecords& R)
{
    for(unsigned i = 0; i < MAX_RESULTS; i++) {
        os << R.results[i] << '\n';
    }
    return os;
}

另外，您可以通过定义打印数组并具有操作员＆lt;＆lt;调用该成员的成员函数来避免友谊。

class StudentRecords {
  public:
    void print_to(std::ostream& os) const
    {
        for(unsigned i = 0; i < MAX_RESULTS; i++) {
            os << results[i] << '\n';
        }
    }
    // Rest of the class definition
};

ostream & operator <<(ostream & os, const StudentRecords& R)
{
    R.print_to(os);
    return os;
}

请注意，这种方法是针对班级以外其他任何其他内容都需要访问结果数组的情况。如果您需要外部访问该数组，则不妨修复您的Getter（如其他答案中），并使用该公共访问权限进行打印。

Answer 3

正如各个人指出的那样，解决此问题时需要考虑各种各样的事情。

1. 对象数组的GETTER可以使用索引号（好的旧int i）来定位数组中的元素。例如，R.GetResult（i）
2. 声明不是表达式！在我的getter中，我使用了“返回结果[max_results];其中max_results是一个恒定的数字...但这最终含义是返回max_results-th元素的数组，显然不是打算。
3. 我将尝试尝试的一件事是为数组成员变量创建指针函数。
4. 建议快速了解矢量，因为声明“结果结果[max_results]”；就是说，用评论员的五颜六色的话说，“ C ++和C的邪恶混合，使事情比需要更复杂的事情变得更加复杂。”

Answer 4

另一种方法（并非总是一个好方法，但要牢记的方法）是保留返回数组的想法，而是从C风格数组升级到std :: Array。 std ::数组的行为很像C风格数组，但它不会腐烂到指针。这使得将数组往返函数和从功能传递变得更加容易。

    // In the class definition

    const std::array<Result, MAX_RESULTS> & GetResults() const {
        return results;
    }

  private:
    std::array<Result, MAX_RESULTS> results;

返回参考可以防止不必要的副本，并制作参考const可防止外部代码更改数据。

使用此类型的返回值，Expression r.getResults（）[i]在流操作员中变得有效。实际上，您的代码中可能只需要三个更改即可使用std ::数组，并且这些更改都在上述代码块中证明。

• 更改结果的类型。
• 更改getResults（）的返回类型。
• 拥有getResults（）返回简单的结果。

（虽然我还将getResults（）（）的定义夹住了，这只是为了我的方便，而不是修复程序的一部分。）

---

但是，我们仍然可以做得更好。名称max_results表明，数组中的可用结果比最大值少。使用somenumber而不是max_results在操作员＆lt;＆lt;中支持此推断。对于在编译时不知道有用大小的数组，std :: vector是一个更合适的解决方案。

与切换到std :: Array不同，转到std :: vector的开关将需要更改某些代码，而这些代码未包含在问题的一部分。例如，可能有一种添加结果的方法。与其跟踪已存储了多少结果，将新结果分配给下一个可用点并增加计数，而是将新方法是push_back（）新结果。一旦转换了所有内容，max_results常数应该不使用，因此可以消除（这是切换到向量的第一个好处）。

对于问题中的代码，更改与切换到std :: array时所做的相似。

  // In the class definition

  const std::vector<Result> & GetResults() const {
    return results;
  }

private:
  std::vector<Result> results;

与std :: Array方法一样，您的运算符＆lt;＆lt;将在您编写时工作，假设somenumber以某种方式设置为r.getResults（）。size（）。但是，您可以通过切换到基于范围的循环来进一步实施。

ostream & operator <<( ostream & os, const StudentRecords& R )
{
    // Range-based looping removes the need to track indices.
    for (const auto& result : R.GetResults())
    {
        os << result << '\n';
    }
    return os;
}

---

这些方法的缺点是“数组”或“向量”成为界面的一部分，而不是实现细节。这是关于哪种设计的判断呼吁。就个人而言，如果需要返回矢量，我倾向于将类似类似的

    // Container used to store `Result` objects.
    using ResultContainer = std::vector<Result>;

内容放在类别中，然后替换std :: vector＆lt; result＆gt;用resultscontainer std :: vector＆gt; >。这告诉您类的用户，他们可以假设resultContainer是一个容器，并且尝试基于范围的循环，但暗示不应假设特定于矢量的功能。 （含义很弱；更好的文档会更好。）这使您可以灵活地用不同的容器替换std :: vector，如果有理由这样做。