C++11 range-based for loop: how to ignore value?

Question

I have a C++ container and I want to run a loop the same number of times as there are elements in that container. But I do not care about the values in the container during the loop. For example:

for (const auto& dummy : input) {
    cout << '.';
}

The only problem is, dummy is an unused variable and I have instructed the compiler to prohibit those.

Two inelegant solutions I have come up with are to say (void)dummy; in the loop body to silence the compiler, or to use an old-style for loop from 0 to distance(begin(input), end(input)).

I tried omitting the variable name but that failed to compile (no big surprise).

I'm using GCC 4.7.2.

Answer 1

No need for explicit loops.

use std::begin;
use std::end;
std::cout << std::string(std::distance(begin(input), end(input)), '.');

Or in non-generic context:

std::cout << std::string(input.size(), '.');

---

If you want to do something more complicated in the loop, just go with (void)dummy;, really. It's clear, well-known and works.

Also look at <algorithm>; what you are implementing may be better implemented in terms of those functions. C++ Seasoning is a nice talk about this.

Answer 2

As all decent suggestions are only comments (some belonging to deleted answers by now), I'll gather them here. Bottom line is: you shouldn't be looping at all.

Instead, use the size of the container and do whatever you want to do that many times. Proposed variants of the code you gave:

cout << string(input.size(), '.'); // @Matt
std::fill_n(std::ostream_iterator<char>(std::cout), input.size(), '.'); // @Hilborn

And the ones that still loop (not recommended:

std::for_each(input.begin(), input.end(), [](type) { std::cout << '.'; }); // @Rapptz
std::transform(input.begin(), input.end(), std::ostream_iterator<char>(std::cout),
[] (auto&&) { return '.'; }); // @hilborn

Hint: pick the first one. It's not only the shortest, it expresses what you are doing in the clearest way possible.

Answer 3

If the operation that you actually want to perform is the trivial one that you wrote in your example, a much better way to achieve what you want is:

std::cout << std::string{boost::distance(input), '.'};

Otherwise, if you just want to loop over a range and perform an operation for each element, ignoring the element value, the for_each <algorithm> is exactly what you want.

• Using boost:

  #include <boost/range/algorithm.hpp>
  boost::for_each(input, [](auto&& /*ignored*/) { /* do stuff */; });
  

• Using the STL:

  #include <algorithm>
  std::for_each(std::begin(input), std::end(input), [](auto&& /*ignored*/) { 
    /* do stuff */; 
  });
  

Note that within the lambda you cannot break or continue, but you can return early to achieve the same behavior.

Still, you should take a look at the other STL algorithms and choose the one that matches your intent best (it will generally also be the fastest).

Answer 4

for (const auto& dummy __attribute__((unused)) : input) {
    cout << '.';
}

as you are using gcc anyways. As a c++11 attribute this is written as (thanks to Jonathan Wakely)

for (const auto& dummy [[gnu::unused]] : input) {
    cout << '.';
}

Answer 5

Another option is to place a call to a dummy inline function.

Define a dummy function.

template <typename T> void noop(T const& t){} 

Use the dummy function.

for (const auto& dummy : input) {
    noop(dummy);
}

Answer 6

Well, you can silence the warning with a pragma: #pragma GCC diagnostic push #pragma GCC diagnostic error "-Wunused-variable" /code here/ #pragma GCC diagnostic pop

But I urge you not to do that. Given the tradeoffs, the "(void)dummy" option is better. I also urge you not to do a dummy inline function as advized by R Sahu, as this just obfuscates your code and unnecessary complexity.

I think in this case billz and moo-juice gave good advice. You are probably better off doing this with an old style for loop.

I can think of one situation where you might want to use the options discussed here. If the container "input" is of a type where getting the size requires traversing the range, and if the code in question is going to be in a performance critical area, you may find it worthwhile to optimize out iterating over the loop twice. In that case use: (void) dummy; // silence uneccessary warning.

However this is almost certainly not the case in the example code you have posted, where io operations will dominate, making this a premature optmization.

Remember that you code will be read many more times than it will be written, so focus on what makes the code most readable. Using new C++ features is only a benefit if it bring an increase in the readability, maintainability, or flexibility of your code -- or if it brings a meaningful performance improvement.

In the case of the example you've posted, your guiding principle should be "what the easiest for a colleague to read?".

Answer 7

template<typename F>
void repeat(std::size_t n, F&&f){
  if(!n) return;
  while(--n) f();
  std::forward<F>(f)(); // enable rvalue operator()
}
template<class C,class=void>struct has_size:std::false_type{};
template<class C>struct has_size<C,decltype(
  std::declval<C>().size(),void()
)>:std::true_type{};
template<typename C>
std::size_t size_helper(C&&c,std::false_type){
  using std::begin; using std::end;
  return std::distance(begin(c),end(c));
}
template<typename C>
std::size_t size_helper(C&&c, std::true-type){
  return c.size();
}
template<typename C>
std::size_t size(C&&c){
  return size_helper(c, has_size<C>());
}

then:

repeat(size( source ),[&]{
  std::cout<<".";
});

should work with standard containers and arrays at nearly optimal efficiency. It does count all of the elements in a forward_list before starting the repeat code.