C ++ 11 bereichsbasierte for-Schleifen ohne Schleifenvariable

Möglicherweise gibt es einen Weg, es zu tun, aber ich sehr viel Zweifel, es wäre mehr elegant. Was haben Sie in, die erste Schleife ist schon der richtige Weg, es zu tun, die Begrenzung des Umfangs/Lebensdauer der loop-variable.

Ich würde Sie einfach ignorieren Sie die Warnung nicht verwendete variable (es ist nur eine Angabe aus dem compiler, dass etwas kann falsch sein, nachdem alle), oder verwenden Sie die compiler-Einrichtungen (sofern verfügbar) , schalten Sie einfach die Warnung an dieser Stelle.

Könnte es möglich sein, mit einer Art von #pragma je nach Umgebung, oder einige Implementierungen erlauben Sie, Dinge zu tun wie:

for (int x = 0; x < 10; ++x) {
    (void)x;

    //Other code goes here, that does not reference "x".
}

Ich habe gesehen, dass void trick verwendet, für die verwendeten Parameter in die Funktion stellen.

InformationsquelleAutor der Antwort paxdiablo

Vorausgesetzt 10 ist eine compile-Zeit-Konstante...

#include <cstddef>
#include <utility>
template<std::size_t N>
struct do_N_times_type {
  template<typename Lambda>
  void operator()( Lambda&& closure ) const {
    closure();
    do_N_times_type<N-1>()(std::forward<Lambda>(closure));
  }
};
template<>
struct do_N_times_type<1> {
  template<typename Lambda>
  void operator()( Lambda&& closure ) const {
    std::forward<Lambda>(closure)();
  }
};
template<>
struct do_N_times_type<0> {
  template<typename Lambda>
  void operator()( Lambda&& closure ) const {
  }
};

template<std::size_t N, typename Lambda>
void do_N_times( Lambda&& closure ) {
  do_N_times_type<N>()( std::forward<Lambda>(closure) );
};
#include <iostream>
void f() {
  std::cout << "did it!\n";
}
int main() {
  do_N_times<10>([&]{
    f();
  });
}

oder nur

int main() {
  do_N_times<10>(f);
}

Anderen lächerlichen Methoden:

Schreiben eine Reihe iterator (ich rufe meine index), produziert eine Reihe von iterator-auf integral-Typen (ich standardmäßig std::size_t). Geben Sie dann ein:

for( auto _:index_range(10) )

denen eine variable verwendet ( _ ), sieht aber überaus verwirrend.

Anderen verrückten Ansatz wäre es, erstellen Sie eine python-ähnlichen generator. Schreiben Sie ein wrapper-generator, die einen wiederholenden Bereich und erzeugt eine Funktion, die zurückgibt std::optional auf die value_type von der Palette ist nicht schwierig.

Können wir dann tun:

auto _ = make_generator( index_range(10) );
while(_()) {
}

erzeugt eine temporäre variable als gut, und ist sogar noch stumpfer.

Könnten wir schreiben eine looping-Funktion, die arbeitet auf Generatoren:

template<typename Generator, typename Lambda>
void While( Generator&& g, Lambda&& l ) {
  while(true) {
    auto opt = g();
    if (!opt) return;
    l(*opt);
  }
}

denen wir rufen Sie dann gerne:

While( make_generator( index_range(10) ), [&](auto&&){
  f();
});

aber dies erzeugt einige temporäre Variablen in der Funktion, und ist mehr lächerlich als die Letzte, und stützt sich auf Eigenschaften von C++1y, die noch nicht einmal abgeschlossen.

Denen meine versuche, um eine variable zu erstellen-weniger Weg, etwas zu wiederholen, 10-mal.

Aber wirklich, ich würde einfach nur die Schleife.

Können Sie fast sicher blockieren Sie die Warnung durch Tippen x=x;

Oder schreiben Sie eine Funktion

template<typename Unused>
void unused( Unused&& ) {}

- und call - unused(x); -- die variable x verwendet wird, und sein name ist im inneren, damit der compiler keine Warnung über es in.

Also versuchen Sie dies:

template<typename Unused>
void unused( Unused&& ) {}
for(int x{};x<10;++x) {
  unused(x);
  f();
}

sollte unterdrückt die Warnung, und eigentlich einfach zu verstehen.

InformationsquelleAutor der Antwort Yakk - Adam Nevraumont

Es gibt keinen Weg, um eine Palette für Arbeit für einfach Iteration über mehrere Nummern.

C++11-range-based-loops erfordern reichten Ausdruck kann sein:

• ein array oder
• eine Klasse, die entweder
  • Member-Funktionen begin() und end() oder
  • frei verfügbaren Funktionen begin() und end() (über ADL)

Außerdem: Ein Bereich für erzeugt etwas overhead:

for ( for_range_declaration : expression ) statement

erweitert, um

range_init = (expression)
{
  auto && __range = range_init;
  for ( auto __begin = begin_expr,
  __end = end_expr;
  __begin != __end;
  ++__begin ) {
    for_range_declaration = *__begin;
    statement;
  }
}

Wo begin_expr und end_expr sind erhältlich über array Inspektion oder begin() /end() Paare.

Ich denke nicht, dass das wirklich "sauberer" als eine einfache for-Schleife. Vor allem in Bezug auf die Leistung.
Keine Anrufe, nur eine schlichte Schleife.

Nur so kann ich herausfinden, um es eleganter (wo elegant ist klar unterliegt meiner Meinung nach) ist mit einer Größe oder Datentyp ohne Vorzeichen hier:

for(size_t x(0U); x<10U; ++x) f();

InformationsquelleAutor der Antwort Pixelchemist

Meiner Meinung nach, die Sie missbrauchen, die range-based-loop. Die range-based-Loop-Schleife sollte verwendet werden, wenn die Logik ist: "für jedes element in der Auflistung etwas tun". Die ganze Idee ist, um loszuwerden, die index-variable, da es nicht wichtig ist. Wenn Sie eine Sammlung, sollten Sie sich für ein instrument es sich mit den nötigen APIs, um zu ermöglichen, range-basierte iteration. Wenn Sie nicht über eine Sammlung, die Sie haben kein Geschäft zu verwenden range-based-loop (eigentlich ist das, was der compiler impliziert in der nicht-so-informativ). In dieser situation ist eine normale for/while-Schleife ist die Natürliche Wahl.

InformationsquelleAutor der Antwort SomeWittyUsername

diese Werke in GCC und clang und jeder compiler unterstützt die gnu-Attribute:

for( [[gnu::unused]] auto x : boost::irange(0,10) ) {

sollte und kompilieren in c++11 compiler kann aber nicht unterdrückt die Warnung, wenn der compiler nicht erkennen, die der gnu-Attribute.

InformationsquelleAutor der Antwort atb