Цикл for с несколькими переменными
Вопрос
Нужно чтото на подобии этого:
for (int Low = 8, int Up = 11; low <= 116, int Up <= 120; low += 12, Up += 12)
Нужно чтобы Low и Up увеличивались одновременно.
Бог движок на котором мы написаны, а Библия компилятор, и верующие постоянно компилируют себя в нём.
Ответы
Можно примерно так
for (int low = 8, Up = 11; (low <= 116 && Up <= 120); low += 12, Up += 12);
А что, именно Вы хотите ?
Все ответы
Можно примерно так
for (int low = 8, Up = 11; (low <= 116 && Up <= 120); low += 12, Up += 12);
А что, именно Вы хотите ?
Главное соблюдать правильный синтаксис шаблона, а остальное ваши фантазии.
for ( инициализатор_for ; условие_for ; итератор_for )
Как дополнение к ответу Yatajga:
Про синтаксис цикла for хорошо написано в библиотеки msdn – for ement (C++) (правда для c++, но все это также справедливо и для c#).
Для связи [mail]
Как дополнение к ответу Yatajga:
Про синтаксис цикла for хорошо написано в библиотеки msdn – for ement (C++) (правда для c++, но все это также справедливо и для c#).
Для связи [mail]
Я читал в разделе C#, но там не было, а тут на английском, в любом случае я разобрался.
Бог движок на котором мы написаны, а Библия компилятор, и верующие постоянно компилируют себя в нём.
Источник
Обновл. 15 Сен 2020 |
Безусловно, наиболее используемым циклом в языке C++ является цикл for.
Цикл for
Цикл for в языке С++ идеален, когда известно необходимое количество итераций. Выглядит он следующим образом:
for (объявление переменных; условие; инкремент/декремент счетчика)
тело цикла;
Или, преобразуя for в эквивалентный цикл while:
{ // обратите внимание, цикл находится в блоке
объявление переменных;
while (условие)
{
тело цикла;
инкремент/декремент счетчика;
}
} // переменные, объявленные внутри цикла, выходят из области видимости здесь
Переменные, определенные внутри цикла for, имеют специальный тип области видимости: область видимости цикла. Такие переменные существуют только внутри цикла и недоступны за его пределами.
Выполнение цикла for
Цикл for в C++ выполняется в 3 шага:
Шаг №1: Объявление переменных. Как правило, здесь выполняется определение и инициализация счетчиков цикла, а точнее – одного счетчика цикла. Эта часть выполняется только один раз, когда цикл выполняется впервые.
Шаг №2: Условие. Если оно равно false, то цикл немедленно завершает свое выполнение. Если же условие равно true, то выполняется тело цикла.
Шаг №3: Инкремент/декремент счетчика цикла. Переменная увеличивается или уменьшается на единицу. После этого цикл возвращается к шагу №2.
Рассмотрим пример цикла for и разберемся детально, как он работает:
#include <iostream> int main() { for (int count = 0; count < 10; ++count) std::cout << count << ” “; return 0; } |
Сначала мы объявляем переменную count и присваиваем ей значение 0. Далее проверяется условие count < 10, а так как count равен 0, то условие 0 < 10 имеет значение true. Следовательно, выполняется тело цикла, в котором мы выводим в консоль переменную count (т.е. значение 0).
Затем выполняется выражение ++count, т.е. инкремент переменной. Затем цикл снова возвращается к проверке условия. Условие 1 < 10 имеет значение true, поэтому тело цикла выполняется опять. Выводится 1, а переменная count увеличивается уже до значения 2. Условие 2 < 10 является истинным, поэтому выводится 2, а count увеличивается до 3 и так далее.
В конце концов, count увеличивается до 10, а условие 10 < 10 является ложным, и цикл завершается. Следовательно, результат выполнения программы:
0 1 2 3 4 5 6 7 8 9
Циклы for могут быть несколько сложны для новичков, однако опытные кодеры любят их, так как эти циклы очень компактны и удобны. Для наглядности, давайте преобразуем цикл for, приведенный выше, в эквивалентный цикл while:
#include <iostream> int main() { { // внешние скобки нужны для обеспечения области видимости цикла int count = 0; while (count < 10) { std::cout << count << ” “; ++count; } } return 0; } |
Обратите внимание, внешние фигурные скобки здесь необходимы, так как переменная count выходит из области видимости при завершении цикла.
Еще примеры циклов for
Давайте, используя цикл for, напишем функцию вычисления значений в степени n:
int pow(int base, int exponent) { int total = 1; for (int count=0; count < exponent; ++count) total *= base; return total; } |
Функция возвращает значение base^exponent (число в степени n). base – это число, которое нужно возвести в степень, а exponent – это степень, в которую нужно возвести base.
Если экспонент равен 0, то цикл for выполняется 0 раз, и функция возвращает 1.
Если экспонент равен 1, то цикл for выполняется 1 раз, и функция возвращает 1 * base.
Если экспонент равен 2, то цикл for выполняется 2 раза, и функция возвращает 1 * base * base.
Хотя в большинстве циклов используется инкремент счетчика, мы также можем использовать и декремент счетчика:
#include <iostream> int main() { for (int count = 8; count >= 0; –count) std::cout << count << ” “; return 0; } |
Результат:
8 7 6 5 4 3 2 1 0
Также с каждой новой итерацией мы можем увеличить или уменьшить значение счетчика больше, чем на единицу:
#include <iostream> int main() { for (int count = 9; count >= 0; count -= 2) std::cout << count << ” “; return 0; } |
Результат:
9 7 5 3 1
Ошибка неучтенной единицы
Одна из самых больших проблем с которой приходится сталкиваться начинающим программистам в циклах for (а также и в других типах циклов) – это ошибка на единицу (или «ошибка неучтенной единицы»). Она возникает, когда цикл повторяется на 1 раз больше или на 1 раз меньше нужного количества итераций. Это обычно происходит из-за того, что в условии используется некорректный оператор сравнения (например, > вместо >= или наоборот). Как правило, эти ошибки трудно отследить, так как компилятор не будет жаловаться на них, программа будет работать, но её результаты будут неправильными.
При написании циклов for помните, что цикл будет выполняться до тех пор, пока условие является истинным. Рекомендуется тестировать циклы, используя разные значения для проверки работоспособности цикла. Хорошей практикой является проверять циклы с помощью данных ввода (чисел, символов и прочего), которые заставляют цикл выполниться 0, 1 и 2 раза. Если цикл работает исправно, значит всё ОК.
Правило: Тестируйте свои циклы, используя входные данные, которые заставляют цикл выполниться 0, 1 и 2 раза.
Пропущенные выражения в цикле
Также в циклах можно пропускать одно или сразу все выражения, например:
#include <iostream> int main() { int count = 0; for (; count < 10; ) { std::cout << count << ” “; ++count; } return 0; } |
Результат:
0 1 2 3 4 5 6 7 8 9
Инициализацию счетчика мы прописали вне тела цикла, а инкремент счетчика – внутри тела цикла. В самом операторе for мы указали только условие. Иногда бывают случаи, когда не требуется объявлять счетчик цикла (потому что у нас он уже есть) или увеличивать его (так как мы увеличиваем его каким-то другим способом).
Хоть это и не часто можно наблюдать, но в операторе for можно вообще ничего не указывать. Стоит отметить, что подобное приведет к бесконечному циклу:
for (;;)
тело цикла;
Вышеприведенный пример эквивалентен:
while (true)
тело цикла;
Объявления переменных в цикле for
Хотя в циклах for обычно используется только один счетчик, иногда могут возникать ситуации, когда нужно работать сразу с несколькими переменными. Для этого используется оператор Запятая. Например:
#include <iostream> int main() { int aaa, bbb; for (aaa = 0, bbb = 9; aaa < 10; ++aaa, –bbb) std::cout << aaa << ” ” << bbb << std::endl; return 0; } |
Этот цикл присваивает значения двум ранее объявленным переменным: aaa = 0 и bbb = 9. Только с каждой итерацией переменная aaa увеличивается на единицу, а bbb – уменьшается на единицу.
Результат выполнения программы:
0 9
1 8
2 7
3 6
4 5
5 4
6 3
7 2
8 1
9 0
Примечание: Вышеприведенный цикл можно переписать следующим образом:
#include <iostream> int main() { for (int aaa = 0, bbb = 9; aaa < 10; ++aaa, –bbb) std::cout << aaa << ” ” << bbb << std::endl; return 0; } |
В этом случае запятая в объявлении переменных является частью синтаксиса, а не использованием оператора Запятая. Но эффект идентичен.
Использование циклов for в старых версиях С++
В старых версиях C++ переменные, объявленные в цикле for, не уничтожались при завершении этого цикла. Т.е. у вас могло получиться что-то вроде следующего:
for (int count=0; count < 10; ++count) std::cout << count << ” “; // В старых версиях С++ переменная count здесь не уничтожается std::cout << “n”; std::cout << “I counted to: ” << count << “n”; // поэтому мы можем использовать count даже здесь |
Позднее это было запрещено, но вы все еще можете увидеть подобное в старом коде.
Вложенные циклы for
Подобно другим типам циклов, одни циклы for могут быть вложены в другие циклы for. В следующем примере мы разместили один for внутри другого for:
#include <iostream> int main() { for (char c = ‘a’; c <= ‘e’; ++c) // внешний цикл по буквам { std::cout << c; // сначала выводим букву for (int i = 0; i < 3; ++i) // внутренний цикл по числам std::cout << i; std::cout << ‘n’; } return 0; } |
С одной итерацией внешнего цикла выполняется три итерации внутреннего цикла. Следовательно, результат выполнения программы:
a012
b012
c012
d012
e012
Заключение
Циклы for являются наиболее часто используемыми циклами в языке C++. Несмотря на то, что их синтаксис, как правило, немного запутывает начинающих программистов, вы очень скоро к нему привыкните и ощутите всю мощь и удобство этих циклов.
Тест
Задание №1
Напишите цикл for, который выводит каждое четное число в диапазоне от 0 до 20.
Ответ №1
#include <iostream> int main() { for (int count = 0; count <= 20; count += 2) std::cout << count << std::endl; return 0; } |
Задание №2
Напишите функцию sumTo(), которая принимает целочисленный параметр с именем value и возвращает сумму всех чисел от 1 до значения value.
Например, если значением value является 5, то sumTo(5) должен возвратить 15, исходя из 1 + 2 + 3 + 4 + 5.
Подсказка: Используйте переменную вне тела цикла для хранения суммы чисел, как в примере с функцией pow() в подзаголовке «Еще примеры циклов for».
Ответ №2
int sumTo(int value) { int total(0); for (int count=1; count <= value; ++count) total += count; return total; } |
Задание №3
Что не так со следующим циклом?
// Выводим все числа от 8 до 0 for (uned int count=8; count >= 0; –count) cout << count << ” “; |
Ответ №3
Этот цикл for выполняется до тех пор, пока count >= 0. Другими словами, он работает до тех пор, пока переменная count не станет отрицательным числом. Однако, поскольку count является типа uned, то эта переменная никогда не сможет быть отрицательной. Следовательно, этот цикл бесконечный! Как правило, рекомендуется избегать использования типов uned в цикле, если на это нет веских причин.
Оценить статью:
Загрузка…
Источник
Мы рассмотрели наиболее типичный вид оператора for. Тем не менее, имеется несколько вариаций, увеличивающих мощь и гибкость в некоторых ситуациях.
Одна из наиболее типичных вариаций достигается с использованием оператора «запятая», тем самым позволяя иметь две или более переменных цикла. (Следует помнить, что оператор «запятая» используется для объединения нескольких выражений. Например, данный цикл использует переменные х и у для управления циклом и обе эти переменные инициализируются в операторе for:
for (х = 0, у = 0; х + у < 10; ++х)
{
scanf(“%d”, &у);
…
}
Здесь оператор «запятая» разделяет два инициализационных оператора. При каждом увеличении х цикл повторяется и значение у вводится с клавиатуры. Как х, так и у должны иметь корректное значение для окончания цикла. Необходимо инициализировать переменную у нулем, поэтому ее значение определяется перед первым вычислением выражения условия. Если бы у не была определена, то имелся бы шанс, что в результате предыдущей работы программы она содержала 10, тем самым делая условие проверки ложным и запрещая выполнения тела цикла.
Другой пример использования нескольких переменных цикла можно найти в показанной ниже функции reverse(). Она предназначена для копирования содержимого первого строкового аргумента во второй строковый аргумент в обратном порядке. Например, если функция вызывается с параметром «hello» для s, то после окончания работы r получит «olleh»:
/* Копирование s в r в обратном порядке */
void reverse (char *s, char *r)
{
int i, j;
for (i=strlen(s)-1, j=0; i>=0; j++,i–) r[i] = s[j] ;
r[j] = ‘ ’; /* присоединение завершающего символа */
}
Не обязательно в качестве условия использовать простое сравнение переменной цикла с некоторым целевым значением. Фактически условием может выступать любой оператор отношения или логический оператор. Например, данная функция может быть использована для отметки пользователя на удаленной системе. Пользователю предоставляется три шанса ввести пароль. Цикл оканчивается в случае использования всех трех возможностей или введения правильного пароля:
void _on (void)
{
char str[20];
int x;
for(x=0; x<3 && strcmp (str, “password”); ++x) {
f(“enter password please:”);
gets(str);
}
if(x==3) hang_up();
}
Надо помнить, что strcmp() – это стандартная библиотечная функция, выполняющая сравнение двух строк и возвращающая 0 в случае совпадения.
Другая интересная вариация цикла for основана на том, что любая из трех частей цикла может содержать любое корректное выражение. Эти выражения могут и не выполнять действий, характерных для данной части. Рассмотрим следующий пример:
#include <stdio.h>
int readnuro(void), prompt(void);
int sqrnum(int num);
int main(void)
{
int t;
for(prompt(); t=readnum(); prompt()) sqrnum(t);
return 0;
}
int prompt(void)
{
f (“: “);
return 0;
}
int readnum(void)
{
int t;
scanf (“%d”, &t);
return t;
}
int sqrnum(int num)
{
f(“%dn”, num*num);
return 0;
}
Если посмотреть внимательно на цикл for в main(), то можно увидеть, что каждая часть цикла содержит вызовы функций, которые осуществляют подсказку и чтение вводимого с клавиатуры числа. Если введенное число равно нулю, цикл оканчивается, поскольку условие ложно, иначе число возводится в квадрат. Следовательно, в данном цикле части инициализации и увеличения используются не традиционно, но абсолютно корректно.
Еще один интересный момент цикла for – это необязательность наличия какой-либо части. Практически можно опустить любую часть. Например, следующий цикл работает до тех пор, пока не будет введено 123:
for (х=0; х != 123; ) scanf (“%d”, &х);
Обратим внимание, что часть увеличения отсутствует. Это означает, что на каждой итерации цикла х проверяется на совпадение с числом 123, но больше ничего не выполняется. Если ввести с клавиатуры 123, условие станет ложным и цикл прекратится.
Часто можно видеть часть инициализации вне оператора for. Это встречается, когда начальное состояние переменной цикла вычисляется неким сложным образом. Например:
gets (s); /* чтение строки в s */
if(*s) х = strlen(s); /* получение длины строки */
for( ;х<10; )
{
f (“%d”, х);
}
Здесь часть инициализации пуста и х инициализируется до входа в цикл.
Источник
| |||||||||||||||||||||||||||||||||||||||||||||||||
Источник