Штирлиц — Сеть печатных салонов в Перми

Весь комплекс печатных услуг в Перми. Общирная сеть печатных салонов в Перми. Цифровая печать, цветное и черно-белое копирование документов, сканирование документов, ризография в Перми

Циклы в c: Операторы цикла в языке Си : for, while, do…while

Содержание

Цикл while в C++ | Уроки С++

  Обновл. 17 Июл 2021  | 

На этом уроке мы детально рассмотрим цикл while, его конструкцию, особенности и использование.

Цикл while

Цикл while является самым простым из четырех циклов, которые есть в языке C++. Он очень похож на ветвление if/else:

while (условие)
    тело цикла;

Цикл while объявляется с использованием ключевого слова while. В начале цикла обрабатывается условие. Если его значением является true (любое ненулевое значение), то тогда выполняется тело цикла.

Однако, в отличие от оператора if, после завершения выполнения тела цикла, управление возвращается обратно к while и процесс проверки условия повторяется. Если условие опять является true, то тогда тело цикла выполняется еще раз.

Например, следующая программа выводит все числа от 0 до 9:

#include <iostream> int main() { int count = 0; while (count < 10) { std::cout << count << » «; ++count; } std::cout << «done!»; return 0; }

#include <iostream>

int main()

{

    int count = 0;

    while (count < 10)

        {

        std::cout << count << » «;

        ++count;

        }

    std::cout << «done!»;

    return 0;

}

Результат выполнения программы:

0 1 2 3 4 5 6 7 8 9 done!

Рассмотрим детально эту программу. Во-первых, инициализируется переменная: int count = 0;. Условие 0 < 10 имеет значение true, поэтому выполняется тело цикла. В первом стейтменте мы выводим 0, а во втором — выполняем

инкремент переменной count. Затем управление возвращается к началу цикла while для повторной проверки условия. Условие 1 < 10 имеет значение true, поэтому тело цикла выполняется еще раз. Тело цикла будет повторно выполняться до тех пор, пока переменная count не будет равна 10, только в том случае, когда результат условия 10 < 10 будет false, цикл завершится.

Тело цикла while может и вообще не выполняться, например:

#include <iostream> int main() { int count = 15; while (count < 10) { std::cout << count << » «; ++count; } std::cout << «done!»; return 0; }

#include <iostream>

int main()

{

    int count = 15;

    while (count < 10)

        {

        std::cout << count << » «;

        ++count;

        }

    std::cout << «done!»;

    return 0;

}

Условие 15 < 10 сразу принимает значение false, и тело цикла пропускается. Единственное, что выведет эта программа:

done!

Бесконечные циклы

С другой стороны, если условие цикла всегда принимает значение true, то и сам цикл будет выполняться бесконечно. Это называется бесконечным циклом. Например:

#include <iostream> int main() { int count = 0; while (count < 10) // это условие никогда не будет false std::cout << count << » «; // поэтому эта строка будет выполняться постоянно return 0; // а эта строка никогда не выполнится }

#include <iostream>

int main()

{

    int count = 0;

    while (count < 10) // это условие никогда не будет false

        std::cout << count << » «; // поэтому эта строка будет выполняться постоянно

    return 0; // а эта строка никогда не выполнится

}

Поскольку переменная count не увеличивается на единицу в этой программе, то условие count < 10 всегда будет true. Следовательно, цикл никогда не будет завершен, и программа будет постоянно выводить 0 0 0 0 0....

Мы можем преднамеренно объявить бесконечный цикл следующим образом:

while (1) // или while (true) { // Этот цикл будет выполняться бесконечно }

while (1) // или while (true)

{

  // Этот цикл будет выполняться бесконечно

}

Единственный способ выйти из бесконечного цикла — использовать операторы return, break, goto, выбросить исключение или воспользоваться функцией exit().

Программы, которые работают до тех пор, пока пользователь не решит остановить их, иногда преднамеренно используют бесконечные циклы вместе с операторами return, break или функцией exit() для завершения цикла. Распространена такая практика в серверных веб-приложениях, которые работают непрерывно и постоянно обслуживают веб-запросы.

Счетчик цикла while

Часто нам нужно будет, чтобы цикл выполнялся определенное количество раз. Для этого обычно используется переменная в виде счетчика цикла. Счетчик цикла — это целочисленная переменная, которая объявляется с единственной целью: считать, сколько раз выполнился цикл. В вышеприведенных примерах переменная count является счетчиком цикла.

Счетчикам цикла часто дают простые имена, такие как

i, j или k. Однако в этих именах есть одна серьезная проблема. Если вы захотите узнать, где в вашей программе используется счетчик цикла и воспользуетесь функцией поиска символов i, j или k, то в результате получите половину своей программы, так как i, j или k используются во многих именах. Следовательно, лучше использовать iii, jjj или kkk в качестве имен для счетчиков. Они более уникальны, их значительно проще найти, и они выделяются в коде. А еще лучше использовать «реальные» имена для переменных, например, count или любое другое имя, которое предоставляет контекст использования этой переменной.

Также для счетчиков цикла лучше использовать тип signed int. Использование unsigned int может привести к неожиданным результатам. Например:

#include <iostream> int main() { unsigned int count = 10; // Считаем от 10 к 0 while (count >= 0) { if (count == 0) std::cout << «blastoff!»; else std::cout << count << » «; —count; } return 0; }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

#include <iostream>

int main()

{

    unsigned int count = 10;

    // Считаем от 10 к 0

    while (count >= 0)

    {

        if (count == 0)

            std::cout << «blastoff!»;

        else

            std::cout << count << » «;

        —count;

    }

    return 0;

}

Взгляните на эту программу еще раз и постарайтесь найти ошибку.

Оказывается, эта программа представляет собой бесконечный цикл. Она начинается с вывода 10 9 8 7 6 5 4 3 2 1 blastoff!, как и предполагалось, но затем «сходит с рельсов» и начинает отсчет с 4294967295. Почему? Потому что условие цикла count >= 0 никогда не будет ложным! Когда count = 0, то и условие 0 >= 0 имеет значение true, выводится blastoff, а затем выполняется декремент переменной count, происходит переполнение и значением переменной становится 4294967295. И так как условие 4294967295 >= 0 является истинным, то программа продолжает свое выполнение. А поскольку счетчик цикла является типа unsigned, то он никогда не сможет быть отрицательным, а так как он никогда не сможет быть отрицательным, то цикл никогда не завершится.

Правило: Всегда используйте тип

signed int для счетчиков цикла.

Итерации

Каждое выполнение цикла называется итерацией (или «повтором»).

Поскольку тело цикла обычно является блоком, и поскольку этот блок выполняется по новой с каждым повтором, то любые переменные, объявленные внутри тела цикла, создаются, а затем и уничтожаются по новой. В следующем примере переменная z создается и уничтожается 6 раз:

#include <iostream> int main() { int count = 1; int result = 0; // переменная result определена здесь, поскольку она нам понадобится позже (вне тела цикла) while (count <= 6) // итераций будет 6 { int z; // z создается здесь по новой с каждой итерацией std::cout << «Enter integer #» << count << ‘:’; std::cin >> z; result += z; // Увеличиваем значение счетчика цикла на единицу ++count; } // z уничтожается здесь по новой с каждой итерацией std::cout << «The sum of all numbers entered is: » << result; return 0; }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

#include <iostream>

int main()

{

    int count = 1;

    int result = 0; // переменная result определена здесь, поскольку она нам понадобится позже (вне тела цикла)

    while (count <= 6) // итераций будет 6

    {

        int z; // z создается здесь по новой с каждой итерацией

        std::cout << «Enter integer #» << count << ‘:’;

        std::cin >> z;

        result += z;

        // Увеличиваем значение счетчика цикла на единицу

        ++count;

    } // z уничтожается здесь по новой с каждой итерацией

    std::cout << «The sum of all numbers entered is: » << result;

    return 0;

}

Для фундаментальных типов переменных это нормально. Для не фундаментальных типов переменных (таких как структуры или классы) это может сказаться на производительности. Следовательно, не фундаментальные типы переменных лучше определять перед циклом.

Обратите внимание, переменная count объявлена вне тела цикла. Это важно и необходимо, поскольку нам нужно, чтобы значение переменной сохранялось на протяжении всех итераций (не уничтожалось по новой с каждым повтором цикла).

Иногда нам может понадобиться выполнить что-то при достижении определенного количества итераций, например, вставить символ новой строки. Это легко осуществить, используя оператор остатка от деления со счетчиком цикла:

#include <iostream> int main() { int count = 1; while (count <= 50) { // Выводим числа до 10 (перед каждым числом добавляем 0) if (count < 10) std::cout << «0» << count << » «; else std::cout << count << » «; // выводим остальные числа // Если счетчик цикла делится на 10 без остатка, то тогда вставляем символ новой строки if (count % 10 == 0) std::cout << «\n»; // Увеличиваем значение счетчика цикла на единицу ++count; } return 0; }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

#include <iostream>

int main()

{

    int count = 1;

    while (count <= 50)

    {

        // Выводим числа до 10 (перед каждым числом добавляем 0)

        if (count < 10)

            std::cout << «0» << count << » «;

        else

            std::cout << count << » «; // выводим остальные числа

        // Если счетчик цикла делится на 10 без остатка, то тогда вставляем символ новой строки

        if (count % 10 == 0)

            std::cout << «\n»;

        // Увеличиваем значение счетчика цикла на единицу

        ++count;

    }

    return 0;

}

Результат выполнения программы:

01 02 03 04 05 06 07 08 09 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50

Вложенные циклы while

Также одни циклы while могут быть вложены внутри других циклов while. В следующем примере внутренний и внешний циклы имеют свои собственные счетчики. Однако, обратите внимание, условие внутреннего цикла использует счетчик внешнего цикла!

#include <iostream> int main() { int outer = 1; while (outer <= 5) { int inner = 1; while (inner <= outer) std::cout << inner++ << » «; // Вставляем символ новой строки в конце каждого ряда std::cout << «\n»; ++outer; } return 0; }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

#include <iostream>

int main()

{

    int outer = 1;

    while (outer <= 5)

    {

        int inner = 1;

        while (inner <= outer)

            std::cout << inner++ << » «;

        // Вставляем символ новой строки в конце каждого ряда

        std::cout << «\n»;

        ++outer;

    }

    return 0;

}

Результат выполнения программы:

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

Тест


Задание №1

Почему в программе, приведенной выше, переменная inner объявлена внутри блока while, а не сразу после объявления переменной outer (вне блока while)?

Ответ №1

Переменная inner объявлена внутри блока while так, чтобы она была восстановлена (и повторно инициализирована значением 1) каждый раз, когда выполняется внешний цикл. Если бы переменная inner была объявлена вне внешнего цикла while, то её значение никогда не было бы сброшено до 1, или нам бы пришлось это сделать самостоятельно с помощью операции присваивания. Кроме того, поскольку переменная inner используется только внутри внешнего цикла while, то имеет смысл объявить её именно там. Помните, что переменные нужно объявлять максимально близко к их первому использованию!

Задание №2

Напишите программу, которая выводит буквы английского алфавита от a до z вместе с кодами из ASCII-таблицы.

Подсказка: Чтобы выводить символы как целые числа — используйте оператор static_cast.

Ответ №2

#include <iostream> int main() { char mychar = ‘a’; while (mychar <= ‘z’) { std::cout << mychar << » » << static_cast<int>(mychar) << «\n»; ++mychar; } return 0; }

#include <iostream>

int main()

{

    char mychar = ‘a’;

    while (mychar <= ‘z’)

    {

        std::cout << mychar  << » » << static_cast<int>(mychar) << «\n»;

        ++mychar;

    }

    return 0;

}

Задание №3

Измените программу из последнего подраздела «Вложенные циклы» так, чтобы она выводила следующее:

5 4 3 2 1
4 3 2 1
3 2 1
2 1
1

Ответ №3

#include <iostream> int main() { int outer = 5; while (outer >= 1) { int inner = outer; while (inner >= 1) std::cout << inner— << » «; // Вставляем символ новой строки в конце каждого ряда std::cout << «\n»; —outer; } return 0; }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

#include <iostream>

int main()

{

    int outer = 5;

    while (outer >= 1)

    {

        int inner = outer;

        while (inner >= 1)

            std::cout << inner— << » «;

        // Вставляем символ новой строки в конце каждого ряда

        std::cout << «\n»;

        —outer;

        }

    return 0;

}

Задание №4

Теперь сделайте так, чтобы цифры выводились следующим образом (используя программу из предыдущего задания):

        1
      2 1
    3 2 1
  4 3 2 1
5 4 3 2 1

Подсказка: Разберитесь сначала, как вывести числа следующим образом:

X X X X 1
X X X 2 1
X X 3 2 1
X 4 3 2 1
5 4 3 2 1

Ответ №4

#include <iostream> int main() { // Цикл с 1 до 5 int outer = 1; while (outer <= 5) { // Числа в рядах появляются в порядке убывания, поэтому цикл начинаем с 5 и до 1 int inner = 5; while (inner >= 1) { // Первое число в любом ряде совпадает с номером этого ряда, // поэтому числа должны выводиться только если <= номера ряда (в противном случае, выводится пробел) if (inner <= outer) std::cout << inner << » «; else std::cout << » «; // вставляем дополнительные пробелы —inner; } // Этот ряд вывели, переходим к следующему std::cout << «\n»; ++outer; } }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

#include <iostream>

int main()

{

// Цикл с 1 до 5

int outer = 1;

while (outer <= 5)

{

// Числа в рядах появляются в порядке убывания, поэтому цикл начинаем с 5 и до 1

int inner = 5;

while (inner >= 1)

{

// Первое число в любом ряде совпадает с номером этого ряда,

// поэтому числа должны выводиться только если <= номера ряда (в противном случае, выводится пробел)

if (inner <= outer)

std::cout << inner << » «;

else

std::cout << »  «; // вставляем дополнительные пробелы

—inner;

}

// Этот ряд вывели, переходим к следующему

std::cout << «\n»;

++outer;

}

}

Оценить статью:

Загрузка…

Поделиться в социальных сетях:

C: Циклы — Linux FAQ

Циклы широко используются в программировании для повторения одних и тех же действий. Циклическое повторение действий может прервано в определенный, описанный разработчиком момент, к примеру, после достижения переменной заданного значения или после чтения последнего байта из файла.

Цикл for

Цикл for используется для выполнения блока кода для каждого из рассматриваемых объектов, событий, элементов массива и так далее…

  1. #include <stdio.h>

  2.  

  3. int main()

  4. {

  5.     for (int count = 1; count <= 10; count++)

  6.     {

  7.         printf(«%in», count);

  8.     }

  9.  

  10.     return 0;

  11. }

В данном случае будут выведены значения переменной count от 1 до 10. При объявлении цикла разработчику предлагается осуществить инициализацию переменной (int count = 1), задать условие исполнения цикла (count <= 10) и задать инструкцию, которая будет исполняться после каждой итерации, причем в данном случае она предназначена для увеличения значения переменной (count++). Все эти выражения необязательны, причем при чтении чужого кода вы наверняка столкнетесь с довольно странными на первый взгляд вариантами использования циклов for. Главное помнить о назначении выражений в описании цикла, а также о том, что исполнение цикла может быть прервано в любой момент с помощью инструкции break или goto.

Загрузить файл исходного кода

Цикл while

Цикл while осуществляет проверку заданного разработчиком условия и в случае его выполнения осуществляет исполнение заданного блока кода. Однако, в некоторых случаях условие не будет выполняться никогда, следовательно, блок кода также не будет исполнен ни разу, при этом исполнение начнется с выражения, следующего за циклом.

  1. #include <stdio.h>

  2.  

  3. int main()

  4. {

  5.     int i = 0;

  6.    

  7.     while (i < 10)

  8.     {

  10.         i++;

  11.     }

  12.    

  13.     return 0;

  14. }

С помощью данного цикла будут выведены значения от 1 до 9 (обратите внимание, что в условии используется оператор <, а не <=, как в примере выше). Цикл while предполагает указание выражения условия, причем увеличение значения переменной или любое другое аналогичное действие должно выполняться в теле цикла (обратите внимание на выражение i++;).

Загрузить файл исходного кода

Цикл do-while

Цикл do-while очень похож на цикл do, но, в отличие от него, проверяет условие после исполнения блока кода, а не до него. Это означает, что код из тела цикла будет исполнен как минимум один раз, причем в случае выполнения условия он может исполняться неограниченное число раз.

  1. #include <stdio.h>

  2.  

  3. int main()

  4. {

  5.     int i = 1;

  6.    

  7.     do

  8.     {

  10.         i++;

  11.     } while (i < 10);

  12.    

  13.     return 0;

  14. }

С помощью данного цикла также будут выведены значения от 1 до 9. Увеличение значения переменной или любое другое аналогичное действие должно также выполняться в теле цикла (обратите внимание на выражение i++;).

Загрузить файл исходного кода

for, foreach, while и do while

В программировании различные типы циклов применяются для того, чтобы повторить некоторое действие нужное количество раз. Например отсортировать элементы массива или найти факториал числа. Цикл состоит из условия и тела цикла. Код, находящийся в теле, выполняется, когда условие равно true. Каждое повторение цикла называется итерацией.

Типы циклов

Цикл For

for (int i=0; i<10; i++) { тело }

i — это переменная-счётчик, которая сначала равна нулю. До тех пор, пока она меньше 10, выполняется тело цикла, затем счетчик увеличивается на единицу. For — цикл с предусловием. Это значит, что сначала проверяется условие, и если оно true, то тело выполняется. В скобках объявляется тип переменной счётчика и её начальное значение. Затем указывается условие конца цикла и способ, которым изменяется значение счётчика.

Цикл Foreach (или совместный цикл)

for (int element :array) { тело }

Тело этого цикла выполнится для каждого элемента коллекции. В переменной element будет доступен по очереди каждый элемент массива array.

Цикл While

while(i < 10) { тело }

Относится к тому же типу циклов, что и For, — цикл с предусловием. С его помощью можно создать безусловный цикл, например while(1) — бесконечный цикл. Чтобы его закончить, нужно использовать служебное слово break.

Цикл Do While

do { тело } while (i<10)

Do While относится к типу циклов с постусловием. Однако здесь код выполнится как минимум один раз, даже если условие false.

Вложенные циклы

int array[][] = {{1, 2, 3}, {3, 4, 5}}

for (i=0;i<3;i++) {
    for (j=0;j<3;j++) {
        printf(array[i][j])
    }
}

Циклы можно помещать внутрь друг друга. Это удобно для перебора многомерных коллекций. Код в примере выше выведет в консоль значение каждого элемента из двумерного массива array.

Операторы циклов

Break

while (true) // бесконечный цикл
    {
         std::cout << "Введите 0 чтобы выйти, или любое число чтобы продолжить: ";
         int val;
         std::cin >> val;
 
         // Выходим из цикла, если пользователь ввел 0
         if (val == 0)
             break;
    }

Оператор break используется для досрочного выхода из цикла. Когда программа встречает break, цикл немедленно завершается и начинает выполняться код, следующий за циклом.

Continue

Оператор Continue даёт циклу команду выйти из текущей итерации и перейти к следующей.

Этот код выведет в консоль все нечетные числа из диапазона от 0 до 10:

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue;
    }
    cout << i << "\n";
}

Циклы в языке программирования С (Си) для микроконтроллеров AVR

В данной статье будут рассмотрены циклы в языке программирования Си для микроконтроллеров AVR. Будут рассмотрены циклы типа «для» (for) и циклы типа «пока» (while), будет показано как осуществить принудительное прерывание цикла и организовать бесконечный цикл. Рассмотрены вопросы вложенных циклов и формирования длительных временных задержек.

Для того чтобы несколько раз повторить какую-либо последовательность действий, применяют алгоритмические конструкции, называемые циклами. Саму последовательность действий при этом называют телом цикла.

В языке С есть две разновидности циклов: циклы со счетчиком (типа «для» или for) и цикл с условием (типа «пока» или while). В других языках программирования, например Pascal, циклы с условием разделялись на циклы с предусловием (типа while) и циклы с пост условием (типа repeat until), но в современных языках программирования циклы с пост условием постепенно отмирают.

Циклы типа «для» (for)

Циклы типа «для» (for) применяются в ситуациях, в которых заранее известно количество повторений цикла. Поэтому в составе подобного цикла всегда есть так называемый «счетчик повторений» или «переменная цикла». Пример использования цикла for в языке представлен на следующем рисунке.

В данном примере тело цикла повторится столько раз, сколько значений «пробежит» переменная цикла i от своего начального значения, задаваемого операцией присваивания i = a, до конечного значения, задаваемого условием i < b. Изменение переменной i определяется условием присваивания вида i = i + c. Но чаще всего в циклах типа for в языке С переменная цикла изменяется за одно повторение цикла на +1 или -1, поэтому используется запись вида i++ (инкремент переменной цикла) или i— (декремент переменной цикла). В рассмотренном примере при i = b цикл завершается и выполняется оператор, следующий за закрывающей скобкой цикла.

Рассмотрим пример цикла for, приведенный на следующем рисунке.

В этом примере на первом шаге цикла переменная i будет равна 1, перед вторым шагом произойдет ее увеличение на 1 в результате инкремента (i++) и она станет равной 2. На третьем шаге значение переменной цикла i будет равно 3. И так до тех пор, пока на пятом шаге цикла она не станет равной 5. В результате следующей операции инкрементирования (i++) переменная цикла получит значение 6, но условие i <= 5 уже не будет истинным, поэтому цикл завершится. Таким образом, тело цикла будет выполнено 5 раз.

Язык С допускает инициализацию переменной цикла в его оглавлении как показано на следующем рисунке.

Но начинающим лучше производить инициализацию переменной цикла в начале функции вместе с остальными инициализируемыми переменными – более подробно читайте об этом в статье про переменные в языке С.

Усовершенствуем программу управления миганием светодиода, рассмотренную в статье про программирование портов микроконтроллеров AVR, с помощью цикла типа «для» (for). Заставим светодиод мигать 10 раз.

Пример подобной программы представлен на следующем рисунке.

Циклы типа «пока» (while)

Цикл типа while («пока») повторяется до тех пор, пока истинно условие цикла. Поэтому часто его называют циклом с условием. В простейшем виде запись данного цикла выглядит следующим образом:

while (условие)
{
// тело_цикла
}

Циклы с условием необходимы в тех случаях, когда заранее не известно число повторений цикла. Подобный цикл будет работать до тех пор, пока выполняется условие.

Чтобы цикл завершился, внутри него (в его теле) должно происходить изменение какой-либо переменной, которая входит в условие цикла.

Пример:

int y;

y = 50;

while (y > 0)
{
y = y — 1;
}

В этом примере тело цикла будет повторено (выполнится) 50 раз, до тех пор пока переменная y будет больше нуля. На каждом шаге цикла значение переменной y будет уменьшаться на 1. И когда оно станет равным 0, цикл завершится.

Оператор break

С помощью данного оператора можно в любой момент завершить цикл (прервать его выполнение). Обычно это делается при наступлении каких-нибудь особых условий.

В большинстве случаев он используется следующим образом:

if (условие1) break;

Данную последовательность операторов можно записать в любом месте цикла. Но опытные программисты стараются все таки избегать использования данного оператора – для улучшения читаемости и отладки программы желательно в условии цикла прописывать все ситуации, при которых будет нужен выход из цикла.

Бесконечные циклы

Бесконечный цикл в языке программирования С можно осуществить как с помощью цикла «для» (for), так и с помощью цикла «пока» (while). Синтаксис подобных циклов выглядит следующим образом.

for(;;)
{
// тело_цикла
}

или

while (1)
{
// тело_цикла
}

Чаще применяется способ с циклом типа while – он более нагляден. Выйти из подобных циклов можно единственным образом – применив рассмотренный в предыдущем разделе оператор break.

Бесконечные циклы находят широкое распространение в программах для микроконтроллеров, потому что данные программы должны, как правило, работать постоянно до тех пор, пока устройство не обесточат. Много примеров подобных программ вы можете найти на нашем сайте в рубрике «схемы и устройства на микроконтроллерах AVR».

Вложенные циклы

В большинстве известных в настоящее время языках программирования (и язык Си этому не исключение) допускается использование вложенных циклов – то есть когда один цикл выполняется в теле другого. Пример использования такой конструкции приведен на следующем рисунке:

Рассмотрим пример двух вложенных друг в друга циклов «для». Тело вложенного цикла в общей сложности будет повторено 200 раз.

В этом примере тело вложенного цикла будет выполнено 200 раз.

Формирование задержки

Аппаратные средства микроконтроллеров AVR не могут формировать длительные задержки – но это, собственно говоря, не очень и нужно потому что сколь угодно длительную задержку можно организовать с помощью циклов (лишь бы имелась возможность формирования хотя бы небольшой задержки). Пример организации задержки длительностью 10 минут с помощью цикла и функции _delay_ms() представлен на следующем рисунке:

Цикл с постусловием — это… Что такое Цикл с постусловием?

Цикл — разновидность управляющей конструкции в высокоуровневых языках программирования, предназначенная для организации многократного исполнения набора инструкций. Также циклом может называться любая многократно исполняемая последовательность инструкций, организованная любым способом (например, с помощью условного перехода).

Определения

Последовательность инструкций, предназначенная для многократного исполнения, называется телом цикла. Однократное выполнение тела цикла называется итерацией. Выражение определяющее, будет в очередной раз выполняться итерация, или цикл завершится, называется условием выхода или условием окончания цикла (либо условием продолжения в зависимости от того, как интерпретируется его истинность — как признак необходимости завершения или продолжения цикла). Переменная, хранящая текущий номер итерации, называется счётчиком итераций цикла или просто счётчиком цикла. Цикл не обязательно содержит счётчик, счётчик не обязан быть один — условие выхода из цикла может зависеть от нескольких изменяемых в цикле переменных, а может определяться внешними условиями (например, наступлением определённого времени), в последнем случае счётчик может вообще не понадобиться.

Исполнение любого цикла включает первоначальную инициализацию переменных цикла, проверку условия выхода, исполнение тела цикла и обновление переменной цикла на каждой итерации. Кроме того большинство языков программирования предоставляют средства для досрочного завершения цикла, то есть выхода из цикла независимо от истинности условия выхода.

Виды циклов

Безусловные циклы

Иногда в программах используются циклы, выход из которых не предусмотрен логикой программы. Такие циклы называются безусловными, или бесконечными. Специальных синтаксических средств для создания бесконечных циклов, ввиду их нетипичности, языки программирования не предусматривают, поэтому такие циклы создаются с помощью конструкций, предназначенных для создания обычных (или условных) циклов. Для обеспечения бесконечного повторения проверка условия в таком цикле либо отсутствует (если позволяет синтаксис, как, например, в цикле LOOP…END LOOP языка Ада), либо заменяется константным значением (while true do … в Паскале).

Цикл с предусловием

Цикл с предусловием — цикл, который выполняется пока истинно некоторое условие, указанное перед его началом. Это условие проверяется до выполнения тела цикла, поэтому тело может быть не выполнено ни разу (если условие с самого начала ложно). В большинстве процедурных языков программирования реализуется оператором while, отсюда его второе название — while-цикл.

Цикл с постусловием

Цикл с постусловием — цикл, в котором условие проверяется после выполнения тела цикла. Отсюда следует, что тело всегда выполняется хотя бы один раз. В языке Паскаль этот цикл реализует оператор repeat..until; в Си — do…while.

В трактовке условия цикла с постусловием в разных языках есть различия. В Паскале и языках, произошедших от него, условие такого цикла трактуется как условие выхода (цикл завершается, когда условие истинно, в русской терминологии такие циклы называют ещё «цикл до»), а в Си и его потомках — как условие продолжения (цикл завершается, когда условие ложно, такие циклы иногда называют «цикл пока»)…..

Цикл с выходом из середины

Цикл с выходом из середины — наиболее общая форма условного цикла. Синтаксически такой цикл оформляется с помощью трёх конструкций: начала цикла, конца цикла и команды выхода из цикла. Конструкция начала маркирует точку программы, в которой начинается тело цикла, конструкция конца — точку, где тело заканчивается. Внутри тела должна присутствовать команда выхода из цикла, при выполнении которой цикл заканчивается и управление передаётся на оператор, следующий за конструкцией конца цикла. Естественно, чтобы цикл выполнился более одного раза, команда выхода должна вызываться не безусловно, а только при выполнении условия выхода из цикла.

Принципиальным отличием такого вида цикла от рассмотренных выше является то, что часть тела цикла, расположенная после начала цикла и до команды выхода, выполняется всегда (даже если условие выхода из цикла истинно при первой итерации), а часть тела цикла, находящаяся после команды выхода, не выполняется при последней итерации.

Легко видеть, что с помощью цикла с выходом из середины можно легко смоделировать и цикл с предусловием (разместив команду выхода в начале тела цикла), и цикл с постусловием (разместив команду выхода в конце тела цикла).

Часть языков программирования содержат специальные конструкции для организации цикла с выходом из середины. Так, в языке Ада для этого используется конструкция LOOP…END LOOP и команда выхода EXIT или EXIT WHEN:

LOOP
  ... Часть тела цикла
  EXIT WHEN <условие выхода>;
  ... Часть тела цикла
  IF <условие выхода> THEN 
    EXIT; 
  END;
  ... Часть тела цикла
END LOOP:

Здесь внутри цикла может быть любое количество команд выхода обоих типов. Сами команды выхода принципиально не различаются, обычно EXIT WHEN применяют, когда проверяется только условие выхода, а просто EXIT — когда выход из цикла производится в одном из вариантов сложного условного оператора.

В тех языках, где подобных конструкций не предусмотрено, цикл с выходом из середины может быть смоделирован с помощью любого условного цикла и оператора досрочного выхода из цикла (такого, как break в Си), либо оператора безусловного перехода goto.

Цикл cо счётчиком

Цикл со счётчиком — цикл, в котором некоторая переменная изменяет своё значение от заданного начального значения до конечного значения с некоторым шагом, и для каждого значения этой переменной тело цикла выполняется один раз. В большинстве процедурных языков программирования реализуется оператором for, в котором указывается счётчик (так называемая «переменная цикла»), требуемое количество проходов (или граничное значение счётчика) и, возможно, шаг, с которым изменяется счётчик. Например, в языке Оберон-2 такой цикл имеет вид:

 FOR v := b TO e BY s DO
   ... тело цикла
 END

(здесь v — счётчик, b — начальное значение счётчика, e — граничное значение счётчика, s — шаг).

Неоднозначен вопрос о значении переменной по завершении цикла, в котором эта переменная использовалась как счётчик. Например, если в программе на языке Паскаль встретится конструкция вида:

i := 100;
for i := 0 to 9 do begin
  ... тело цикла
end;
k := i;

возникает вопрос: какое значение будет в итоге присвоено переменной k: 9, 10, 100, может быть, какое-то другое? А если цикл завершится досрочно? Ответы зависят от того, увеличивается ли значение счётчика после последней итерации и не изменяет ли транслятор это значение дополнительно. Ещё один вопрос: что будет, если внутри цикла счётчику будет явно присвоено новое значение? Различные языки программирования решают данные вопросы по-разному. В некоторых поведение счётчика чётко регламентировано. В других, например, в том же Паскале, стандарт языка не определяет ни конечного значения счётчика, ни последствий его явного изменения в цикле, но не рекомендует изменять счётчик явно и использовать его по завершении цикла без повторной инициализации. Программа на Паскале, игнорирующая эту рекомендацию, может давать разные результаты при выполнении на разных системах и использовании разных трансляторов.

Радикально решён вопрос в языке Ада: счётчик считается описанным в заголовке цикла, и вне его просто не существует. Даже если имя счётчика в программе уже используется, внутри цикла в качестве счётчика используется отдельная переменная. Счётчику запрещено явно присваивать какие бы то ни было значения, он может меняться только внутренним механизмом оператора цикла. В результате конструкция

i := 100;
for i in (0..9) loop
  ... тело цикла
end loop;
k := i;

внешне аналогичная вышеприведённому циклу на Паскале, трактуется однозначно: переменной k будет присвоено значение 100, поскольку переменная i, используемая вне данного цикла, не имеет никакого отношения к счётчику i, который создаётся и изменяется внутри цикла. Считается, что подобное обособление счётчика наиболее удобно и безопасно: не требуется отдельное описание для него и минимальна вероятность случайных ошибок, связанных со случайным разрушением внешних по отношению к циклу переменных. Если программисту требуется включить в готовый код цикл со счётчиком, то он может не проверять, существует ли переменная с именем, которое он выбрал в качестве счётчика, не добавлять описание нового счётчика в заголовок соответствующей процедуры, не пытаться использовать один из имеющихся, но в данный момент «свободных» счётчиков. Он просто пишет цикл с переменной-счётчиком, имя которой ему удобно, и может быть уверен, что никакой коллизии имён не произойдёт.

Цикл со счётчиком всегда можно записать как условный цикл, перед началом которого счётчику присваивается начальное значение, а условием выхода является достижение счётчиком конечного значения; к телу цикла при этом добавляется оператор изменения счётчика на заданный шаг. Однако специальные операторы цикла со счётчиком могут эффективнее транслироваться, так как формализованный вид такого цикла позволяет использовать специальные процессорные команды организации циклов.

В некоторых языках, например, Си и других, произошедших от него, цикл for, несмотря на синтаксическую форму цикла со счётчиком, в действительности является циклом с предусловием. То есть в Си конструкция цикла:

for (i = 0; i < 10; ++i)
{
  ... тело цикла 
}

фактически представляет собой другую форму записи конструкции:

i = 0;
while (i < 10)
{
  ... тело цикла 
  ++i;
}

То есть в конструкции for сначала пишется произвольное предложение инициализации цикла, затем — условие продолжения и, наконец, выполняемая после каждого тела цикла некоторая операция (это не обязательно должно быть изменение счётчика; это может быть правка указателя или какая-нибудь совершенно посторонняя операция). Для языков такого вида вышеописанная проблема решается очень просто: переменная-счётчик ведёт себя совершенно предсказуемо и по завершении цикла сохраняет своё последнее значение.

Вложенные циклы

Существует возможность организовать цикл внутри тела другого цикла. Такой цикл будет называться вложенным циклом. Вложенный цикл по отношению к циклу в тело которого он вложен будет именоваться внутренним циклом, и наоборот цикл в теле которого существует вложенный цикл будет именоваться внешним по отношению к вложенному. Внутри вложенного цикла в свою очередь может быть вложен еще один цикл, образуя следующий уровень вложенности и так далее. Количество уровней вложенности как правило не ограничивается.

Полное число исполнений тела внутреннего цикла не превышает произведения числа итераций внутреннего и всех внешних циклов. Например взяв три вложенных друг в друга цикла, каждый по 10 итераций, получим 10 исполнений тела для внешнего цикла, 100 для цикла второго уровня и 1000 в самом внутреннем цикле.

Одна из проблем, связанных с вложенными циклами — организация досрочного выхода из них. Во многих языках программирования есть оператор досрочного завершения цикла (break в Си, exit в Турбо Паскале, last в Perl и т. п.), но он, как правило, обеспечивает выход только из цикла того уровня, откуда вызван. Вызов его из вложенного цикла приведёт к завершению только этого внутреннего цикла, объемлющий же цикл продолжит выполняться. Проблема может показаться надуманной, но она действительно иногда возникает при программировании сложной обработки данных, когда алгоритм требует немедленного прерывания в определённых условиях, наличие которых можно проверить только в глубоко вложенном цикле.

Решений проблемы выхода из вложенных циклов несколько.

  • Простейший — использовать оператор безусловного перехода goto для выхода в точку программы, непосредственно следующую за вложенным циклом. Этот вариант критикуется сторонниками структурного программирования, как и все конструкции, требующие использования goto. Некоторые языки программирования, например Modula-2, просто не имеют оператора безусловного перехода, и в них подобная конструкция невозможна.
  • Альтернатива — использовать штатные средства завершения циклов, в случае необходимости устанавливая специальные флаги, требующие немедленного завершения обработки. Недостаток — усложнение кода, снижение производительности без каких-либо преимуществ, кроме теоретической «правильности» из-за отказа от goto.
  • Размещение вложенного цикла в процедуре. Идея состоит в том, чтобы всё действие, которое может потребоваться прервать досрочно, оформить в виде отдельной процедуры, и для досрочного завершения использовать оператор выхода из процедуры (если такой есть в языке программирования). В Си, например, можно построить функцию с вложенным циклом, а выход из неё организовать с помощью оператора return. Недостаток — выделение фрагмента кода в процедуру не всегда логически обосновано, и не все языки имеют штатные средства досрочного завершения процедур.
  • Воспользоваться механизмом генерации и обработки исключений (исключительных ситуаций), который имеется сейчас в большинстве ЯВУ. В этом случае в нештатной ситуации код во вложенном цикле возбуждает исключение, а блок обработки исключений, в который помещён весь вложенный цикл, перехватывает и обрабатывает его. Недостаток — реализация механизма обработки исключений в большинстве случаев такова, что скорость работы программы уменьшается. Правда, в современных условиях это не особенно важно: практически потеря производительности столь мала, что имеет значение лишь для очень немногих приложений.
  • Наконец, существуют специальные языковые средства для выхода из вложенных циклов. Так, в языке Ада программист может пометить цикл (верхний уровень вложенного цикла) меткой, и в команде досрочного завершения цикла указать эту метку. Выход произойдёт не из текущего цикла, а из всех вложенных циклов до помеченного, включительно.

Совместный цикл

Ещё одним вариантом цикла является цикл, задающий выполнение некоторой операции для объектов из заданного множества, без явного указания порядка перечисления этих объектов. Такие циклы называются совместными (а также циклами по коллекции, циклами просмотра) и представляют собой формальную запись инструкции вида: «Выполнить операцию X для всех элементов, входящих в множество M». Совместный цикл, теоретически, никак не определяет, в каком порядке операция будет применяться к элементам множества, хотя конкретные языки программирования, разумеется, могут задавать конкретный порядок перебора элементов. Произвольность даёт возможность оптимизации исполнения цикла за счёт организации доступа не в заданном программистом, а в наиболее выгодном порядке. При наличии возможности параллельного выполнения нескольких операций возможно даже распараллеливание выполнения совместного цикла, когда одна и та же операция одновременно выполняется на разных вычислительных модулях для разных объектов, при том что логически программа остаётся последовательной.

Совместные циклы имеются в некоторых языках программирования (C#, JavaScript, Python, LISP, коллекции объектов. В определении такого цикла требуется указать только коллекцию объектов и переменную, которой в теле цикла будет присвоено значение обрабатываемого в данный момент объекта (или ссылка на него). Синтаксис в различных языках программирования синтаксис оператора различен:

C#:

foreach (type item in set) 
{
    //использование item
}


foreach (@set) 
{
    #использование $_
}

С++. Задачи с решениями. Числа и циклы. Задачи 1-10

1. Составьте программу, выводящую на экран квадраты чисел от 10 до 20 включительно.

int main()

{

for (int i=10; i<=20; i++)

cout<<i*i<<» «;

cout<<endl;

return 0;

}

2. Даны натуральные числа от 35 до 87. Вывести на консоль те из них, которые при делении на 7 дают остаток 1, 2 или 5.

int main()

{

for (int i=35; i<=87; i++)

{

if (i % 7 == 1 || i % 7 == 2 || i % 7 == 5)

cout<<i<<» «;

}

cout<<endl;

 

return 0;

}

3. Найдите сумму  , где число вводится пользователем с клавиатуры.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

int main()

{

int n;

 

cout<<«input n: «; cin>>n;

if (n<1)

cout<<«error»<<endl;

else

{

int sum=0;

for (int i=1; i<=n; i++)

sum+=i;

cout<<«sum = «<<sum<<endl;

}

 

return 0;

}

4. Найдите произведение цифр трехзначного числа.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

int main()

{

  int n;

  cout<<«input n: «;

  cin>>n;

  if (n<100 || n>999)

    cout<<«error n»<<endl;

  else

  {

    int a,b,c;

    a=n%10;       // первая цифра справа

    b=(n/10)%10;  // вторая цифра справа

    c=n/100;      // убрать две цифры справа

 

    int res;

    res=a*b*c;

    cout<<«answer: «<<res<<endl;

  }

  return 0;

}

5. Найдите количество четных цифр данного натурального числа.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

int main()

{

    int n;

 

    cout<<«input n: «;     cin>>n;

    if (n<=0)

      cout<<«error n»<<endl;    

   else    

   {    

        int count=0;    

        while (n>0)

     {

     if ((n%10)%2==0)

        count++;

     n/=10;

     }

     cout<<«answer: «<<count<<endl;

    }

 

    return 0;

}

6. Найдите наибольшую цифру данного натурального числа.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

int main()

{

    int n;

 

    cout<<«input n: «;     cin>>n;

    if (n<=0)

      cout<<«error n»<<endl;    

   else    

   {    

        int max=0;    

        while (n>0)

     {

     if ((n%10)>max)

        max=n%10;

     n/=10;

     }

     cout<<«answer: «<<max<<endl;

    }

 

    return 0;

}

7. Найдите все четырехзначные числа, сумма цифр каждого из которых равна 15.

int main()

{

for (int i=1000; i<10000; i++)

  if (i%10+(i/10)%10+(i/100)%10+i/1000==15)

    cout<<i<<endl;

return 0;

}

 

Метки задачи, циклы. Смотреть запись.

2.5.2 VBA. Организация циклов | Пакеты прикладных программ

Операторы цикла используются для повторения выполнения действия или группы действий заданное количество раз. Количество повторений (итераций цикла) может быть предопределено или вычислено.

VBA поддерживает циклические конструкции двух видов:

  1. Циклы с фиксированным числом повторений (циклы со счетчиком).
  2. Циклы с неопределенными числом повторений (циклы с условием).

Для всех видов циклов используется понятие тело цикла, определяющее блок операторов, заключенных между начальным и конечным операторами цикла. Каждое повторение выполнения операторов тела цикла называется итерация.

Фиксированные циклы

VBA предоставляет две управляющие структуры для организации фиксированного цикла: For … Next (цикл со счетчиком) и For Each … Next (цикл с перечислением).

Оператор For … Next это типовой цикл со счетчиком, выполняющий заданное число итераций. Синтаксис оператора For … Next:

For <счетчик> = <начЗначение> То <конЗначение> [Step <приращение>] 
	<блок операторов> 
Next [<счетчик>]

Пример использования оператора For … Next.

Листинг 9. Оператор For … Next

' ЗАДАЧА: Составить программу, которая получает два числа от пользователя. 
' Складывает все числа в диапазоне, заданном этими двумя числами, а затем 
' отображает результирующую сумму. 

Sub sample7() 
	Dim i As Integer ‘счетчик цикла 
	Dim sStart ‘начальное значение счетчика 
	Dim sEnd ‘конечное значение счетчика 
	Dim sSum As Long ‘результирующая сумма 

	sStart = InputBox("Введите первое число:") 
	sEnd = InputBox("Введите второе число:") 
	sSum = 0 
	
	For i = CInt(sStart) To CInt(sEnd) 
		sSum = sSum + i 
	Next i 
	
	MsgBox "Сумма чисел от " & sStart & " до " & sEnd & " равна: " & sSum 
End Sub

Оператор цикла For Each … Next относится к категории операторов объектного типа, т.е. применяется в первую очередь к коллекциям объектов, а также к массивам. Тело цикла выполняется фиксированное число раз, соответствующее числу элементов массива или коллекции. Формат оператора For Each … Next:

For Each <элемент> In <группа> <блок операторов> Next [<элемент>]

Циклы с условием (неопределенные циклы)

Циклы с условием используются в тех случаях, когда повторяющиеся действия нужно выполнять только при определенных условиях. Количество итераций не определено и в общем случае может быть равно нулю (в частности, для циклов с предусловием). VBA предлагает разработчикам несколько управляющих структур для организации циклов с условием:

  • Четыре вида циклов Do..Loop, которые различаются типом проверяемого условия и временем выполнения этой проверки.
  • Непрерываемый цикл While … Wend.

Цикл Do While … Loop — типичный цикл с предусловием. Условие проверяется до того, как выполняется тело цикла. Цикл продолжает свою работу, пока это <условие> выполняется (т.е. имеет значение True). Так как проверка выполняется в начале, то тело цикла может ни разу не выполниться. Формат цикла Do While … Loop:

	Do While <условие> 
		<блок операторов> 
	Loop

Листинг 10. Цикл Do While … Loop

' ЗАДАЧА: Составить программу, которая предусматривает ввод пользователем 
' произвольной последовательности чисел. Ввод должен быть прекращен 
' только после того, как сумма введенных нечетных чисел превысит 100. 

Sub sample8() 
	Dim OddSum As Integer ‘сумма нечетных чисел 
	Dim OddStr As String ‘строка с нечетными числами 
	
	Dim Num ‘для приема вводимых чисел 
	OddStr = "" ‘инициализация выходной строки 
	OddSum = 0 ‘инициализация суммы OddSum 
	
	Do While OddSum < 100 ‘начало цикла 
		Num = InputBox("Введите число: ") 

		If (Num Mod 2) <> 0 Then ‘проверка на четность 
			OddSum = OddSum + Num ‘накопление суммы нечетных чисел 
			OddStr = OddStr & Num & " " 
		End If 
	Loop 

	'вывод строки с нечетными числами 
	MsgBox prompt:="Нечетные числа: " & OddStr 

End Sub

Оператор Do … Loop While предназначен для организации цикла с постусловием. Условие проверяется после того, как тело цикла, будет выполнено хотя бы один раз. Цикл продолжает свою работу, пока <условие> остается истинным. Формат цикла Do … Loop While:

Do <блок операторов> Loop While<условие>

Листинг 11. Цикл с постусловием

' ЗАДАЧА: Составить программу игры "Угадай число". Программа должна случайным 
' образом генерировать число в диапазоне от 1 до 1000, пользователь должен 
' угадать это число. Программа на каждое вводимое число выводит подсказку 
' "больше" или "меньше". 

Sub sample8() 
Randomize Timer ' инициализация генератора случайных чисел 

	Dim msg As String ' строка сообщения 
	Dim SecretNumber As Long, UserNumber As Variant 
Begin:	SecretNumber = Round(Rnd * 1000) ' число, сгенерированное компьютером 
	UserNumber = Empty ' число, вводимое пользователем 

	Do ' игровой процесс 
		Select Case True 
			Case IsEmpty(UserNumber): msg = "Введите число" 
			Case UserNumber > SecretNumber: msg = "Слишком много!" 
			Case UserNumber < SecretNumber: msg = "Слишком мало!" 
		End Select 

		UserNumber = InputBox(prompt:=msg, Title:="Угадай число") 
	Loop While UserNumber <> SecretNumber 

	' проверка 
	If MsgBox("Играть еще? ", vbYesNo + vbQuestion, "Вы угадали!") = vbYes Then 
		GoTo Begin 
	End If 
End Sub

Циклы Do Until … Loop и Do … Loop Until являются инверсиями ранее рассмотренных циклов с условием. В общем случае они работают аналогично, за исключением того, что тело цикла выполняется при ложном условии (т.е. <условие>=False). Формат цикла Do Until … Loop:

Do Until <условие> <блок операторов> Loop

Формат цикла Do … Loop Until:

Do 
	<блок операторов> 
Loop Until<условие>

Практическое задание: Перепишите программы из листингов 10 и 11 с использованием инвертированных операторов цикла.

Цикл While … Wend также относится к циклам с условием. Данный оператор полностью соответствует структуре Do While … Loop. Формат цикла While … Wend:

While <условие> 
	<блок операторов> 
Wend

Отличительной особенностью этого оператора является невозможность принудительного завершения (прерывания) тела цикла (оператор Exit Do не работает в цикле While … Wend).

Прерывание цикла

Для досрочного завершения итерации и выхода из цикла применяется оператор Exit. Этот оператор применим в любой циклической структуре, кроме While … Wend. Общий синтаксис использования Exit для прерывания цикла таков:

<начало_цикла> 
	[<блок операторов1>] 
	Exit (For | Do) 
	[<блок операторов2>] 
	[Exit (For | Do)] 
	... 
<конец_цикла>

При выполнении оператора Exit цикл прерывается, и управление передается оператору, следующему за оператором <конец_цикла>. В теле цикла может присутствовать несколько операторов Exit.

Листинг 12. Принудительный выход из цикла

Sub sample9() 
	For i = 1 To 10000000 
		If i = 10 Then Exit For ' выход из цикла, когда счетчик достигнет 10 
	Next 
End Sub

Анатольев А.Г., 01.10.2012

Постоянный адрес этой страницы:

include — Циклы включения в файлы заголовков C

include — Циклы включения в файлы заголовков C — qaru

Присоединяйтесь к Stack Overflow , чтобы учиться, делиться знаниями и строить свою карьеру.

Спросил

Просмотрено 3к раз

Как предотвратить цикл включения в C? т.е.У вас не должно быть a.h #include «b.h», которое # включает «c.h», # которое включает «a.h». Я ищу способ предотвратить это, используя какую-то директиву C.

Первоначально я думал, что это предотвратило бы это:

Содержание а.ч .: 

  #ifndef __A_H
#define __A_H

#include "b.h"

#endif // __A_H

Содержание б.х .: 

  #ifndef __B_H
#define __B_H

#include "c.h"

#endif // __B_H

Содержание гр.ч: 

  #ifndef __C_H
#define __C_H

#include "a.h"

#endif // __C_H

Но вроде не работает.

Создан 07 ноя.

МСумулонг

2,1122 золотых знака1212 серебряных знаков2121 бронзовый знак

2

Он работает нормально: файлы повторно включаются , но разделы, защищенные # ifdndef / # define / # endif , не повторяются , и это прерывает цикл.

Используйте свой компилятор для создания предварительно обработанного вывода и посмотрите сами. В GNU CC вам нужно использовать параметр «-E» в файле .c [pp], например: 

  gcc -E $ (CFLAGS) -o foo.i foo.cpp
Оставить комментарий

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

© 2019 Штирлиц Сеть печатных салонов в Перми

Цифровая печать, цветное и черно-белое копирование документов, сканирование документов, ризография в Перми.

Карта сайта