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

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.

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.

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 << '.';
}

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?".

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.

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);
}