Цикл for visual studio 2010

Доброго времени суток, хабражители!
Для желающих начать программировать на языке C# выкладываю четвертую лекцию на тему: «Условия и циклы». Лекция получилась очень большая (на целый час), поэтому, кто готов смотреть так долго я желаю терпения и большого желания не останавливаться на достигнутом.

Ссылки на предыдущие лекции

Лекция 1. Введение
Лекция 2. Hello, World! и знакомство с Visual C# Express 2010
Лекция 3. Переменные и выражения

А сейчас — ответы на предыдущее домашнее задание:
1. Недопустимыми именами для переменных являются:

100metres

(так как имя переменной не может начинаться с цифры) и

csharp.com

(так как имя переменной содержит посторонний символ “.”)
2. Строка “

thisisveryverylongstringindeedisntit

” НЕ является слишком большой, чтобы уместиться в тип string, поскольку память, выделяемая под переменные этого типа динамична и меняется в зависимости от размера.
3. Учитывая приоритет операций выражение:

resultVar += var1 * var2 + var3 % var4 / var5;

будет выполняться со следующей последовательностью:
1) *
2) %
3) /
4) +
5) +=

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

Новое домашнее задание:

1. При наличии двух целых чисел, хранящихся в переменных var1 и var2, какую булевскую проверку нужно выполнить для выяснения того, является ли то или другое (но не оба вместе) больше 10?
2. Напишите приложение, которое получает два числа от пользователя и отображает их на экране, но отклоняет варианты, когда оба числа больше 10, и предлагает в таком случае ввести два других числа.
3. Что неверно в следующем коде (постарайтесь решить это задание, не используя Visual Studio)?

1.       int i = 10;
2.       for (i = 1; i <= 10; i++)
3.       {
4.         if ((i % 2) = 0)
5.           continue;
6.         Console.WriteLine(i);
7.       }

* This source code was highlighted with Source Code Highlighter.

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

Примеры кода, которые были использованы в лекции.

1. Применение булевских операций

1.     static void Main(string[] args)
2.     {
3.       int myInt;
4.       Console.WriteLine(“Enter an integer:”); // Введите целое число
5.       Int32.TryParse(Console.ReadLine(), out myInt);
6.       Console.WriteLine(“Integer less than 10? {0}”, myInt < 10);
7.       Console.WriteLine(“Integer between 0 and 5? {0}”, (myInt >= 0) && (myInt <= 5));
8.       Console.ReadKey();
9.     }

* This source code was highlighted with Source Code Highlighter.

2. Применение операторов goto, if else, ?: (тернарный оператор)

1.     static void Main(string[] args)
2.     {
3.       string result = String.Empty;
4.       double var1 = 0, var2 = 0;
5.  
6.       begin1:
7.       Console.WriteLine(“Enter first number:”);
8.       if (!Double.TryParse(Console.ReadLine(),out var1)) // здесь я упростил код просто поставив “!” перед выражением bool
9.       {
10.         Console.WriteLine(“You should enter a double value.”);
11.         goto begin1;
12.       }
13.  
14.       begin2:
15.       Console.WriteLine(“Enter second number:”);
16.       if (!Double.TryParse(Console.ReadLine(), out var2))
17.       {
18.         Console.WriteLine(“You should enter a double value.”);
19.         goto begin2;
20.       }
21.  
22.       if (var1 < var2)
23.         result = “less than”;
24.       else
25.       {
26.         result = var1 == var2 ? “equal to” : “greater than”;
27.       }
28.  
29.       Console.WriteLine(“The first number is {0} the second number.”, result);
30.       Console.ReadKey();
31.     }

* This source code was highlighted with Source Code Highlighter.

3. Применение оператора switch

1.     static void Main(string[] args)
2.     {
3.       const int fail = 10;
4.       int value = 0;
5.  
6.       switch (value)
7.       {
8.         case 1:
9.           Console.WriteLine(“This is one”);
10.           break;
11.         case 2:
12.           Console.WriteLine(“This is two”);
13.           break;
14.         case fail:
15.           Console.WriteLine(“This is fail”);
16.           break;
17.         default:
18.           Console.WriteLine(“This is default”);
19.           break;
20.       }
21.     }

* This source code was highlighted with Source Code Highlighter.

4. Применение циклов

1.     static void Main(string[] args)
2.     {
3.       double balance = 0, interestRate = 0, targetBalance = 0;
4.       Console.WriteLine(“What is your current balance?”);
5.       Double.TryParse(Console.ReadLine(), out balance);
6.       Console.WriteLine(“What is your current interest rate (in %)?”);
7.       Double.TryParse(Console.ReadLine(), out interestRate);
8.       interestRate = 1 + interestRate/100.0;
9.       Console.WriteLine(“What balance would you like to have?”);
10.       Double.TryParse(Console.ReadLine(), out targetBalance);
11.  
12.       int totalYears = 0;
13.  
14.       while (balance < targetBalance)
15.       {
16.         balance *= interestRate;
17.         totalYears++;
18.       }
19.  
20.       Console.WriteLine(“In {0} year{1} you will have a balance of {2}.”, totalYears,
21.         totalYears == 1 ? “” : “s”, balance);
22.       Console.ReadKey();

* This source code was highlighted with Source Code Highlighter.

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

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

for (int i=0; i<size; i++) {
[…]
}

Хотя почему не могу, очень даже могу:

find . ( -name *.h -o -name *.cpp ) -exec grep -H “for (” {} ; | wc -l
43641

Наш текущий проект содержит 43 тысячи циклов. Проект пилю не я один, но команда маленькая и проект у меня не первый (и, надеюсь, не последний), так что в качестве грубой оценки пойдёт. А насколько такая запись цикла for хороша? Ведь на самом деле, важно даже не то количество раз, когда я цикл написал, а то количество раз, когда я цикл прочитал (см. отладка и code review). А тут речь очевидно идёт уже о миллионах.

На КПДВ узел под названием «совершенная петля» (perfection loop).

Так каков он, совершенный цикл?

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

for (int iter=0; iter<nb_iter; iter++) { // some iterative computation
for (int c=0; c<mesh.cells.nb(); c++) // loop through all tetrahedra
for (int lv0=0; lv0<4; lv0++) // for every pair of
for (int lv1 = lv0+1; lv1<4; lv1++) // vertices in the tet
for (int d=0; d<3; d++) { // do stuff for each of 3 dimensions
nlRowScaling(weight);
nlBegin(NL_ROW);
nlCoefficient(mesh.cells.vertex(c, lv0)*3 + d, 1);
nlCoefficient(mesh.cells.vertex(c, lv1)*3 + d, -1);
nlEnd(NL_ROW);
}
[…]
}

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

Мы обязаны иметь дело с кучей вложенных циклов; вышеприведённые пять вложенных далеко не предел. Мы уже довольно давно (лет пятнадцать как) пришли к выводу, что стандартный for (int i=0; i<size; i++) — это очень громоздкая конструкция: те самые пять вложенных заголовков for превращаются в совершенно нечитаемую кашу, и даже подсветка синтаксиса не спасает.

Когда мы читаем стандартный for(;;), мы должны на каждой строчке обратить внимание на три вещи: на инициализацию, на условие выхода и собственно на инкремент. Но ведь это совершеннейший оверкилл для тех случаев, когда нам нужно пройтись от 0 до size-1, а это подавляющее большинство всех циклов. Скажите, как часто вам приходится писать обратный цикл или итерацию с другими границами? Как мне кажется, один раз из десяти — это ещё щедрая оценка.

До появления c++11 мы в итоге пришли к страшной вещи, а именно ввели в самый верхний заголовок вот такой дефайн:

#define FOR(I,UPPERBND) for(int I = 0; I<int(UPPERBND); ++I)

И тогда вышеприведённый кусок кода превращается из тыквы в кабачок:

FOR(iter, nb_iter) {
FOR(c, mesh.cells.nb())
FOR(lv0, 4)
for (int lv1 = lv0+1; lv1<4; lv1++)
FOR(d, 3) {
nlRowScaling(weight);
nlBegin(NL_ROW);
nlCoefficient(mesh.cells.vertex(c, lv0)*3 + d, 1);
nlCoefficient(mesh.cells.vertex(c, lv1)*3 + d, -1);
nlEnd(NL_ROW);
}
[…]
}

Польза такой трансформации в том, что когда я встречаю for (;;), я знаю, что мне нужно насторожиться и внимательно смотреть на все три места (инициализацию, условие, инкремент). В то время как если я вижу FOR(,) то это совершенно стандартный пробег от 0 до n-1 без каких-либо тонкостей. Я совершенно не предлагаю пользоваться вышеприведённым дефайном, но точно знаю, что для нашей команды он сберёг много ресурсов мозга, поскольку мы кода гораздо больше читаем (см. отладка), нежели пишем (как, наверное, и все программисты).

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

А как дела обстоят у соседей? Вы знаете, местами довольно недурно. Например, в лагере питонистов стандартный цикл выглядит следующим образом:

for i in range(n):
print(i)

Что любопытно, до третьего питона range() создавал в памяти массив индексов, и проходился по нему. И со времён c++11 мы вполне можем делать точно так же!

#include <iostream>
int main() {
int range[] = {0,1,2,3,4,5};
for (int i : range) {
std::cerr << i;
}
}

Разумеется, явно создавать в памяти массив индексов это несерьёзно, и с третьей версии в питоне это тоже поняли. Но и в C++ мы можем сделать не хуже!

Давайте посмотрим на следующую функцию range(int n):

#include <iostream>

constexpr auto range(int n) {
struct iterator {
int i;
void operator++() { ++i; }
bool operator!=(const iterator& rhs) const { return i != rhs.i; }
const int &operator*() const { return i; }
};
struct wrapper {
int n;
auto begin() { return iterator{0}; }
auto end() { return iterator{n}; }
};
return wrapper{n};
}

int main() {
for (int i: range(13)) {
std::cerr << i;
}
return 0;
}

Пожалуйста, не начинайте int vs size_t, разговор не об этом. Если скомпилировать этот код при помощи gcc 10.2 с флагами компиляции -std=c++17 -Wall -Wextra -pedantic -O1, то мы получим следующий ассемблерный код (проверьте тут):

[…]
.L2:
mov esi, ebx
mov edi, OFFSET FLAT:_ZSt4cerr
call std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
add ebx, 1
cmp ebx, 13
jne .L2
[…]

То есть, компилятор начисто убрал все эти обёртки и оставил голый инкремент, ровно как если бы мы написали обычный for (int i=0; i<13; i++).

Лично мне кажется, что for (int i: range(n)) справляется с подчёркиванием обычности цикла чуть хуже, нежели FOR(,), но тоже вполне достойно, и за это не нужно платить дополнительными тактами процессора.

Range for в c++11 нанёс большую пользу. Давайте скажем, что у меня есть массив трёхмерных точек, и мне нужно распечатать икс координаты каждой точки, это можно сделать следующим образом:

#include <vector>
#include <iostream>

struct vec3 { double x,y,z; };

int main() {
std::vector<vec3> points = {{6,5,8},{1,2,3},{7,3,7}};
for (vec3 &p: points) {
std::cerr << p.x;
}
return 0;
}

for (vec3 &p: points) это прекрасная конструкция, никаких костылей, сразу из стандарта языка. Но что если у меня каждая точка из массива имеет цвет, вес или вкус? Это можно представить ещё одним массивом того же размера, что и массив точек. И тогда для доступа к атрибуту мне всё же понадобится индекс, который мы можем сгенерировать, например, вот таким образом:

std::vector<vec3> points = {{6,5,8},{1,2,3},{7,3,7}};
std::vector<double> weights = {4,6,9};
int i = 0;
for (vec3 &p: points) {
std::cerr << p.x << weights[i++];
}

Для этого кода компилятор генерирует следующий ассемблер:

В принципе, имеет право на жизнь, но гулять так гулять, давайте снимем с программиста заботу о создании параллельного индекса, ровно как сделали в питоне, благо стандарт c++17 имеет structural binding!

Итак, можно сделать следующим образом:

#include <vector>
#include <iostream>
#include “range.h”

struct vec3 {
double x,y,z;
};

int main() {
std::vector<vec3> points = {{6,5,8},{1,2,3},{7,3,7}};
std::vector<double> weights = {4,6,9};

for (auto [i, p]: enumerate(points)) {
std::cerr << p.x << weights[i];
}

return 0;
}

Функция enumerate() определена в следующем заголовочном файле:

При компиляции с флагами -std=c++17 -Wall -Wextra -pedantic -O2 мы получим следующий ассемблерный код (проверьте тут):

И снова компилятор начисто убрал обёртку (правда, для этого пришлось поднять уровень оптимизации с -O1 на -O2).
Кстати, в c++20 появился std::ranges, что ещё больше упрощает написание такой функции, но я пока не готов переходить на этот стандарт.

На ваш взгляд, каким должен быть совершенный цикл в 2020м году? Научите меня!

Если вы ещё не задавались этим вопросом, то скопируйте к себе в пет-проект заголовочный файл range.h и попробуйте его поиспользовать хотя бы несколько дней.