Làm cách nào để tránh các vòng lặp “for” với điều kiện “if” bên trong chúng bằng C ++?

Với hầu hết tất cả các mã tôi viết, tôi thường giải quyết các vấn đề giảm tập hợp trên các bộ sưu tập mà cuối cùng kết thúc với các điều kiện "nếu" ngây thơ bên trong chúng. Đây là một ví dụ đơn giản:

for(int i=0; i<myCollection.size(); i++)
{
     if (myCollection[i] == SOMETHING)
     {
           DoStuff();
     }
}

Với các ngôn ngữ chức năng, tôi có thể giải quyết vấn đề bằng cách giảm tập hợp thành một tập hợp khác (dễ dàng) và sau đó thực hiện tất cả các thao tác trên tập hợp đã giảm của mình. Trong mã giả:

newCollection <- myCollection where <x=true
map DoStuff newCollection

Và trong các biến thể C khác, như C #, tôi có thể giảm bằng mệnh đề where như

foreach (var x in myCollection.Where(c=> c == SOMETHING)) 
{
   DoStuff();
}

Hoặc tốt hơn (ít nhất là đối với mắt tôi)

myCollection.Where(c=>c == Something).ToList().ForEach(d=> DoStuff(d));

Phải thừa nhận rằng tôi đang thực hiện rất nhiều sự pha trộn mô hình và phong cách dựa trên chủ quan / ý kiến, nhưng tôi không thể không cảm thấy rằng tôi đang thiếu một thứ thực sự cơ bản có thể cho phép tôi sử dụng kỹ thuật ưa thích này với C ++. Ai đó có thể khai sáng cho tôi?

IMHO sẽ dễ dàng hơn và dễ đọc hơn khi sử dụng vòng lặp for với if bên trong nó. Tuy nhiên, nếu điều này gây khó chịu cho bạn, bạn có thể sử dụng for_each_ifnhư sau:

template<typename Iter, typename Pred, typename Op> 
void for_each_if(Iter first, Iter last, Pred p, Op op) {
  while(first != last) {
    if (p(*first)) op(*first);
    ++first;
  }
}

Usecase:

std::vector<int> v {10, 2, 10, 3};
for_each_if(v.begin(), v.end(), [](int i){ return i > 5; }, [](int &i){ ++i; });

Bản thử trực tiếp

Boost cung cấp các phạm vi có thể được sử dụng dựa trên phạm vi. Phạm vi có lợi thế mà họ không sao chép cấu trúc dữ liệu cơ bản, họ chỉ đơn thuần cung cấp một 'xem' (có nghĩa là, begin(), end()cho phạm vi và operator++(), operator==()cho iterator). Điều này có thể bạn quan tâm: http://www.boost.org/libs/range/doc/html/range/reference/adaptors/reference/filtered.html

#include <boost/range/adaptor/filtered.hpp>
#include <iostream>
#include <vector>

struct is_even
{
    bool operator()( int x ) const { return x % 2 == 0; }
};

int main(int argc, const char* argv[])
{
    using namespace boost::adaptors;

    std::vector<int> myCollection{1,2,3,4,5,6,7,8,9};

    for( int i: myCollection | filtered( is_even() ) )
    {
        std::cout << i;
    }
}

Thay vì tạo một thuật toán mới, như câu trả lời được chấp nhận, bạn có thể sử dụng một thuật toán hiện có với một hàm áp dụng điều kiện:

std::for_each(first, last, [](auto&& x){ if (cond(x)) { ... } });

Hoặc nếu bạn thực sự muốn một thuật toán mới, ít nhất hãy sử dụng lại for_eachở đó thay vì sao chép logic lặp:

template<typename Iter, typename Pred, typename Op> 
  void
  for_each_if(Iter first, Iter last, Pred p, Op op) {
    std::for_each(first, last, [&](auto& x) { if (p(x)) op(x); });
  }

Ý tưởng tránh

for(...)
    if(...)

cấu trúc như một phản vật chất quá rộng.

Hoàn toàn tốt khi xử lý nhiều mục khớp với một biểu thức nhất định từ bên trong một vòng lặp và mã không thể rõ ràng hơn thế. Nếu quá trình xử lý phát triển quá lớn để phù hợp với màn hình, đó là lý do chính đáng để sử dụng chương trình con, nhưng điều kiện vẫn tốt nhất được đặt bên trong vòng lặp, tức là

for(...)
    if(...)
        do_process(...);

rất thích

for(...)
    maybe_process(...);

Nó trở thành phản vật chất khi chỉ có một phần tử khớp với nhau, bởi vì khi đó sẽ rõ ràng hơn khi tìm kiếm phần tử và thực hiện xử lý bên ngoài vòng lặp.

for(int i = 0; i < size; ++i)
    if(i == 5)

là một ví dụ cực đoan và hiển nhiên của điều này. Tinh tế hơn, và do đó phổ biến hơn, là mẫu nhà máy như

for(creator &c : creators)
    if(c.name == requested_name)
    {
        unique_ptr<object> obj = c.create_object();
        obj.owner = this;
        return std::move(obj);
    }

Điều này khó đọc, bởi vì không rõ ràng rằng mã nội dung sẽ được thực thi một lần duy nhất. Trong trường hợp này, tốt hơn nên tách riêng phần tra cứu:

creator &lookup(string const &requested_name)
{
    for(creator &c : creators)
        if(c.name == requested_name)
            return c;
}

creator &c = lookup(requested_name);
unique_ptr obj = c.create_object();

Vẫn có một ifbên trong a for, nhưng từ ngữ cảnh, nó trở nên rõ ràng nó làm gì, không cần phải thay đổi mã này trừ khi tra cứu thay đổi (ví dụ: thành a map) và ngay lập tức rõ ràng rằng create_object()nó chỉ được gọi một lần, bởi vì nó không bên trong một vòng lặp.

Đây là một nhanh tương đối tối thiểu filter chức năng .

Nó có một vị ngữ. Nó trả về một đối tượng hàm có thể lặp lại.

Nó trả về một có thể lặp lại có thể được sử dụng trong một for(:)vòng lặp.

template<class It>
struct range_t {
  It b, e;
  It begin() const { return b; }
  It end() const { return e; }
  bool empty() const { return begin()==end(); }
};
template<class It>
range_t<It> range( It b, It e ) { return {std::move(b), std::move(e)}; }

template<class It, class F>
struct filter_helper:range_t<It> {
  F f;
  void advance() {
    while(true) {
      (range_t<It>&)*this = range( std::next(this->begin()), this->end() );
      if (this->empty())
        return;
      if (f(*this->begin()))
        return;
    }
  }
  filter_helper(range_t<It> r, F fin):
    range_t<It>(r), f(std::move(fin))
  {
      while(true)
      {
          if (this->empty()) return;
          if (f(*this->begin())) return;
          (range_t<It>&)*this = range( std::next(this->begin()), this->end() );
      }
  }
};

template<class It, class F>
struct filter_psuedo_iterator {
  using iterator_category=std::input_iterator_tag;
  filter_helper<It, F>* helper = nullptr;
  bool m_is_end = true;
  bool is_end() const {
    return m_is_end || !helper || helper->empty();
  }

  void operator++() {
    helper->advance();
  }
  typename std::iterator_traits<It>::reference
  operator*() const {
    return *(helper->begin());
  }
  It base() const {
      if (!helper) return {};
      if (is_end()) return helper->end();
      return helper->begin();
  }
  friend bool operator==(filter_psuedo_iterator const& lhs, filter_psuedo_iterator const& rhs) {
    if (lhs.is_end() && rhs.is_end()) return true;
    if (lhs.is_end() || rhs.is_end()) return false;
    return lhs.helper->begin() == rhs.helper->begin();
  }
  friend bool operator!=(filter_psuedo_iterator const& lhs, filter_psuedo_iterator const& rhs) {
    return !(lhs==rhs);
  }
};
template<class It, class F>
struct filter_range:
  private filter_helper<It, F>,
  range_t<filter_psuedo_iterator<It, F>>
{
  using helper=filter_helper<It, F>;
  using range=range_t<filter_psuedo_iterator<It, F>>;

  using range::begin; using range::end; using range::empty;

  filter_range( range_t<It> r, F f ):
    helper{{r}, std::forward<F>(f)},
    range{ {this, false}, {this, true} }
  {}
};

template<class F>
auto filter( F&& f ) {
    return [f=std::forward<F>(f)](auto&& r)
    {
        using std::begin; using std::end;
        using iterator = decltype(begin(r));
        return filter_range<iterator, std::decay_t<decltype(f)>>{
            range(begin(r), end(r)), f
        };
    };
};

Tôi đã đi tắt đón đầu. Một thư viện thực sự phải tạo ra các trình lặp thực sự, chứ không phải là các trình lặp for(:)giả mạo đủ tiêu chuẩn như tôi đã làm.

Tại thời điểm sử dụng, nó trông như thế này:

int main()
{
  std::vector<int> test = {1,2,3,4,5};
  for( auto i: filter([](auto x){return x%2;})( test ) )
    std::cout << i << '\n';
}

cái đó khá đẹp và bản in

1
3
5

Ví dụ trực tiếp .

Có một bổ sung được đề xuất cho C ++ được gọi là Rangesv3 thực hiện loại điều này và hơn thế nữa. boostcũng có sẵn phạm vi bộ lọc / vòng lặp. boost cũng có những người trợ giúp làm cho việc viết ở trên ngắn hơn nhiều.

Một phong cách được sử dụng đủ để đề cập, nhưng vẫn chưa được đề cập, là:

for(int i=0; i<myCollection.size(); i++) {
  if (myCollection[i] != SOMETHING)
    continue;

  DoStuff();
}

Ưu điểm:

• Không thay đổi mức thụt lề DoStuff();khi độ phức tạp của điều kiện tăng lên. Về mặt logic, DoStuff();phải ở cấp cao nhất của forvòng lặp, và đúng như vậy.
• Ngay lập tức làm cho nó rõ ràng rằng lặp loop qua SOMETHINGs của bộ sưu tập, mà không đòi hỏi người đọc để xác minh rằng không có gì sau khi kết thúc là }của ifkhối.
• Không yêu cầu bất kỳ thư viện hoặc macro hoặc chức năng trợ giúp nào.

Nhược điểm:

• continue, giống như các câu lệnh điều khiển luồng khác, bị lạm dụng theo những cách dẫn đến mã khó theo dõi đến mức một số người phản đối bất kỳ cách sử dụng nào của chúng: có một kiểu mã hợp lệ mà một số người tuân theo thì tránh continue, kiểu đó tránh breakkhác trong a switch, tránh returnkhác với ở cuối một hàm.

for(auto const &x: myCollection) if(x == something) doStuff();

Trông khá giống với C ++ - một forcách hiểu cụ thể đối với tôi. Đối với bạn?

Nếu DoStuff () sẽ phụ thuộc vào tôi bằng cách nào đó trong tương lai thì tôi sẽ đề xuất biến thể che mặt nạ bit không nhánh được đảm bảo này.

unsigned int times = 0;
const int kSize = sizeof(unsigned int)*8;
for(int i = 0; i < myCollection.size()/kSize; i++){
  unsigned int mask = 0;
  for (int j = 0; j<kSize; j++){
    mask |= (myCollection[i*kSize+j]==SOMETHING) << j;
  }
  times+=popcount(mask);
}

for(int i=0;i<times;i++)
   DoStuff();

Trong đó popcount là bất kỳ hàm nào thực hiện đếm dân số (đếm số bit = 1). Sẽ có một số quyền tự do để đưa ra những ràng buộc nâng cao hơn với tôi và những người hàng xóm của họ. Nếu điều đó không cần thiết, chúng tôi có thể tháo vòng trong và làm lại vòng ngoài

for(int i = 0; i < myCollection.size(); i++)
  times += (myCollection[i]==SOMETHING);

Theo sau là một

for(int i=0;i<times;i++)
   DoStuff();

Ngoài ra, nếu bạn không quan tâm đến việc sắp xếp lại bộ sưu tập, phân vùng std :: rất rẻ.

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

void DoStuff(int i)
{
    std::cout << i << '\n';
}

int main()
{
    using namespace std::placeholders;

    std::vector<int> v {1, 2, 5, 0, 9, 5, 5};
    const int SOMETHING = 5;

    std::for_each(v.begin(),
                  std::partition(v.begin(), v.end(),
                                 std::bind(std::equal_to<int> {}, _1, SOMETHING)), // some condition
                  DoStuff); // action
}

Tôi kinh ngạc về sự phức tạp của các giải pháp trên. Tôi sẽ đề xuất một cách đơn giản #define foreach(a,b,c,d) for(a; b; c)if(d)nhưng nó có một vài thiếu sót rõ ràng, ví dụ, bạn phải nhớ sử dụng dấu phẩy thay vì dấu chấm phẩy trong vòng lặp của bạn và bạn không thể sử dụng toán tử dấu phẩy trong ahoặc c.

#include <list>
#include <iostream>

using namespace std; 

#define foreach(a,b,c,d) for(a; b; c)if(d)

int main(){
  list<int> a;

  for(int i=0; i<10; i++)
    a.push_back(i);

  for(auto i=a.begin(); i!=a.end(); i++)
    if((*i)&1)
      cout << *i << ' ';
  cout << endl;

  foreach(auto i=a.begin(), i!=a.end(), i++, (*i)&1)
    cout << *i << ' ';
  cout << endl;

  return 0;
}

Một giải pháp khác trong trường hợp i: s là quan trọng. Cái này xây dựng một danh sách điền vào các chỉ mục để gọi doStuff () cho. Một lần nữa, điểm chính là tránh phân nhánh và đổi nó lấy chi phí số học có thể chuyển đổi.

int buffer[someSafeSize];
int cnt = 0; // counter to keep track where we are in list.
for( int i = 0; i < container.size(); i++ ){
   int lDecision = (container[i] == SOMETHING);
   buffer[cnt] = lDecision*i + (1-lDecision)*buffer[cnt];
   cnt += lDecision;
}

for( int i=0; i<cnt; i++ )
   doStuff(buffer[i]); // now we could pass the index or a pointer as an argument.

Dòng "ma thuật" là dòng tải bộ đệm tính toán số học làm ướt để giữ giá trị và giữ nguyên vị trí hoặc để đếm lên vị trí và thêm giá trị. Vì vậy, chúng tôi đánh đổi một nhánh tiềm năng cho một số lôgic học và số học và có thể một số lần truy cập bộ nhớ cache. Một kịch bản điển hình khi điều này sẽ hữu ích là nếu doStuff () thực hiện một số lượng nhỏ các phép tính có thể chuyển hướng và bất kỳ nhánh nào ở giữa các cuộc gọi có thể làm gián đoạn các đường ống đó.

Sau đó, chỉ cần lặp qua bộ đệm và chạy doStuff () cho đến khi chúng ta đạt đến cnt. Lần này chúng ta sẽ lưu trữ i hiện tại trong bộ đệm để chúng ta có thể sử dụng nó trong lệnh gọi doStuff () nếu chúng ta cần.

Người ta có thể mô tả mẫu mã của bạn là áp dụng một số chức năng cho một tập hợp con của một dải ô, hay nói cách khác: áp dụng nó cho kết quả của việc áp dụng một bộ lọc cho toàn bộ dải ô.

Điều này có thể đạt được theo cách đơn giản nhất với thư viện range-v3 của Eric Neibler ; mặc dù nó hơi chướng mắt, vì bạn muốn làm việc với các chỉ số:

using namespace ranges;
auto mycollection_has_something = 
    [&](std::size_t i) { return myCollection[i] == SOMETHING };
auto filtered_view = 
    views::iota(std::size_t{0}, myCollection.size()) | 
    views::filter(mycollection_has_something);
for (auto i : filtered_view) { DoStuff(); }

Nhưng nếu bạn sẵn sàng bỏ qua các chỉ số, bạn sẽ nhận được:

auto is_something = [&SOMETHING](const decltype(SOMETHING)& x) { return x == SOMETHING };
auto filtered_collection = myCollection | views::filter(is_something);
for (const auto& x : filtered_collection) { DoStuff(); }

IMHO đẹp hơn.

PS - Thư viện phạm vi chủ yếu đi vào tiêu chuẩn C ++ trong C ++ 20.

Tôi sẽ chỉ đề cập đến Mike Acton, anh ấy chắc chắn sẽ nói:

Nếu bạn phải làm điều đó, bạn có vấn đề với dữ liệu của mình. Sắp xếp dữ liệu của bạn!