标准容器封装和基于范围的 for 循环

Question

我正在设计一个 class，它有两个标准向量作为成员。我希望能够在矢量元素上使用基于范围的 for 循环，我想出了这个解决方案

#include <iostream>
#include <vector>

using namespace std;

class MyClass {
public:
  void addValue1(int val){data1_.push_back(val);}
  void addValue2(int val){data2_.push_back(val);}
  vector<int> const & data1() const {return data1_;}
  vector<int> const & data2() const {return data2_;}
  // ...
private:
  vector<int> data1_;
  vector<int> data2_;
  // ...
};

void print1(MyClass const & mc) {
  for (auto val : mc.data1()){
    cout << val << endl;
  }
}

void print2(MyClass const & mc) {
  for (auto val : mc.data2()){
    cout << val << endl;
  }
}

int main(){
  MyClass mc;
  mc.addValue1(1);
  mc.addValue1(2);
  mc.addValue1(3);
  print1(mc);
}

显然，定义 begin() 和 end() 函数的替代方案没有意义，因为我有两个不同的向量。

我想请教以下问题：

所提出的解决方案的一个缺点是无法更改两个向量的内容（由于 const 限定符）。如果我需要修改矢量元素，我该如何修改代码？ 编辑：修改应保留封装
考虑到数据封装，你认为return一个（const）对两个向量的引用是不好的做法吗？

Answer 1

使用 gsl::span<int> 和 gsl::span<const int> 之类的东西。

这是一个最小的：

template<class T>
struct span {
  T* b = 0; T* e = 0;
  T* begin() const { return b; }
  T* end() const { return e; }
  span( T* s, T* f ):b(s),e(f) {}
  span( T* s, std::size_t len ):span(s, s+len) {}
  template<std::size_t N>
  span( T(&arr)[N] ):span(arr, N) {}
  // todo: ctor from containers with .data() and .size()

  // useful helpers:
  std::size_t size() const { return end()-begin(); }
  bool empty() const { return size()==0; }
  T& operator[](std::size_t i) const { return begin()[i]; }
  T& front() const { return *begin(); }
  T& back() const { return *(std::prev(end())); }

  // I like explicit defaults of these:
  span() = default;
  span(span const&) = default;
  span& operator=(span const&) = default;
  ~span() = default;
};

现在你可以写：

span<int const> data1() const {return {data1_.data(), data1_.size()};}
span<int const> data2() const {data2_.data(), data2_.size()};}
span<int> data1() {return {data1_.data(), data1_.size()};}
span<int> data2() {data2_.data(), data2_.size()};}

Answer 2

A shortcoming of the proposed solution is that the contents of the two vectors cannot be changed (due to the const qualifier). In the case I need to modify the vector elements how can I modify the code?

首先，您应该添加 data1() 和 data2() 非常量版本，return 引用 data1_ 和 data2_成员

vector<int> const & data1() const {return data1_;}
vector<int> const & data2() const {return data2_;}

vector<int> & data1() {return data1_;}
vector<int> & data2() {return data2_;}

其次：如果您想修改 print1() 中的元素（例如），您必须接收 mc 作为非常量引用

// ..........vvvvvvvvv   no more const
void print1 (MyClass & mc) {

所以你可以改变 mc.

第三：在基于范围的循环中，您必须将 val 定义为参考，这样您就可以修改它，同时修改向量中的参考值

// ........V   by reference
for ( auto & val : mc.data1() ) {
   ++val ;  // this modify the value in the vector inside mc
   cout << val << endl;
}

Considering data encapsulation, do you think it is bad practice to return a (const) reference to the two vectors?

恕我直言：如果引用是 const，则完全不是：这是一个很好的做法，因为允许安全使用该成员而无需复制它。

如果引用不是 const，我认为声明成员 public 没有太大区别。

标准容器封装和基于范围的 for 循环

Standard containers encapsulation and range-based for loops

c++

containers

encapsulation

c++11

c++14