Int i 0 что это значит

Рассмотрим пример вычисления суммы чисел от 1 до 10.

///////////////////////////////////////////////////////////////////////////// // Прикладное программирование // Пример 9. Пример работы оператора for - вычисление суммы чисел // // Кафедра Прикладной и компьютерной оптики, http://aco.ifmo.ru // Университет ИТМО ///////////////////////////////////////////////////////////////////////////// // подключение библиотеки ввода-вывода #include // подключение стандартного пространства имен для использования библиотек using namespace std; ///////////////////////////////////////////////////////////////////////////// // функция main начинает исполнение программы void main() < // описание переменных int sum = 0; // оператор пошагового цикла for(int i=1; i cout"sum=" /////////////////////////////////////////////////////////////////////////////

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

1.8.2 Пошаговый цикл for

Общая форма оператора for, и соответствующая ему блок-схема показаны в таблице.

for(инициализация; условие; приращение) < блок операторов; >

В заголовке цикла указывается выражение инициализации, которое задает начальное значение счетчику цикла, условие, должен ли цикл продолжать свое выполнение, а выражение приращения модифицирует счетчик цикла.

Если условие продолжения цикла с самого начала ложно, то операторы тела for не исполняются и управление сразу передается оператору, следующему за for.

В большинстве случаев оператор for можно представить эквивалентным оператором while:

while ( условие ) блок операторов ; приращение ; >

Если выражение инициализации в заголовке оператора for объявляет счетчик цикла (т.е. перед именем переменной указан ее тип), то переменная может использоваться только в теле оператора for – вне оператора for эта переменная будет неизвестна. Такое ограничение на использование имени переменной называют областью действия переменной. Область действия переменной определяет, где в программе она может использоваться.

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

Еще несколько примеров заголовков цикла:

изменение управляющей переменной от 1 до 100 с шагом 1:
for ( int i = 1; i
изменение управляющей переменной от 100 до 1 с шагом -1 (с уменьшением на 1):
for ( int i = 100; i > 0; i—)
изменение управляющей переменной от 7 до 77 с шагом 7:
for ( int i = 7; i
изменение управляющей переменной от 20 до 2 с шагом -2:
for ( int i = 20; i >= 2; i -= 2)
изменение управляющей переменной в следующей последовательности: 2, 5, 8, 11, 14:
for ( int j = 2; j
изменение управляющей переменной в следующей последовательности: 99, 88, 77, 66, 55, 44, 33, 22, 11, 0:
for ( int j = 99; j >= 0; j -= 11)

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

for ( int x = 0, y=0; x < 10; x++, y++)

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

На самом деле, все три выражения в операторе for являются необязательными. Если опущено выражение для условия продолжения цикла, C++ предполагает, что условие всегда истинно и, таким образом, получается бесконечный цикл. Можно опустить выражение инициализации, если управляющая переменная инициализируется в программе ранее. Можно опустить и выражение приращения, если приращение переменной выполняется в теле цикла или оно вообще не требуется.

int i=0; for( ; ; ) < // . if(i>=100) break; i++; >

1.8.3 Операторы break и continue

Когда оператор break исполняется в операторе while, for, do. while или switch, происходит немедленный выход из цикла (или switch) и исполнение программы продолжается со следующего оператора. Типичным применением оператора break является досрочное прерывание цикла или пропуск оставшейся части оператора switch.

Исполнение оператора continue в операторе while, for или do. while вызывает пропуск оставшейся части тела оператора и переход к следующей итерации цикла. В операторах while и do. while сразу после исполнения оператора continue оценивается условие продолжения цикла. В операторе for сначала исполняется выражение приращения, и затем оценивается условие продолжения.

1.8.4 Пример вычисление факториала (пример 10)

///////////////////////////////////////////////////////////////////////////// // Прикладное программирование // Пример 10. Вычисление факториала. Примеры работы циклов for, do. while // // Кафедра Прикладной и компьютерной оптики, http://aco.ifmo.ru // Университет ИТМО ///////////////////////////////////////////////////////////////////////////// // подключение библиотеки ввода-вывода #include // подключение стандартного пространства имен для использования библиотек using namespace std; ///////////////////////////////////////////////////////////////////////////// // функция main начинает исполнение программы void main() < int menu_number;// номер пункта меню // цикл, позволяющий производить вычисления пока не будет выбран пункт "Exit" do < // число, для которого вычисляется факториал int number; // цикл будет работать до тех пор, пока не будет введено положительное число do < cout"Enter integer positive numbers: "; cin>>number; >while(number // факториал, первоначальное значение равно 1, т.к. 0!=1 int factorial=1; // пошаговый цикл, перебирает все числа от number до 1, с шагом -1 for(int i=number; i>0; --i) < factorial*=i; >// вывод результата cout<// вывод меню cout<<<// ввод номера пункта меню cin>>menu_number; >while(menu_number!=0); > /////////////////////////////////////////////////////////////////////////////

Что такое i в цикле for

Не могу до конца понять, что такое i в цикле for. Понятно, что обычная переменная, можно другими символами имя ей задать. Понимаю, что она нужна для счёта, но путаюсь. Например: Мне нужно вывести список list:

using System; using System.Collections.Generic; namespace ConsoleApp1 < class Program < static void Main(string[] args) < var list = new List(); for (var i = 0; i < 15; i ++) < var input = Console.ReadLine(); var tp = int.TryParse(input, out int result); if (tp == false) < Console.WriteLine("It`s not int"); >list.Add(result); > for (var i = 0; i < list.Count; i++) < Console.WriteLine(list[i]); >Console.ReadLine(); > > >

Не понимаю, почему выводятся элементы списка. Мне кажется, написано: пока количество выведенных на экран элементов списка меньше, чем количество всех элементов, выводить на экран количество остальных элементов поочерёдно. А вот зачем в Console.WriteLine написано, чтобы выводился i этого списка, я не понимаю. Ну, как бы, это тяжело объяснить. Что такое i этот? Объясните, пожалуйста.

Отслеживать
задан 21 окт 2020 в 20:03
159 11 11 бронзовых знаков

я не понял вопроса. Вы не знаете, как работает for? Или вы не знаете что такое индексатор для списка?

21 окт 2020 в 20:06
Что такое индексатор, скорее
21 окт 2020 в 20:06
21 окт 2020 в 20:09

3 ответа 3

Сортировка: Сброс на вариант по умолчанию

Если я вас правильно понял, вам непонятна строка Console.WriteLine(list[i]); Мы выводим не элемент i, а итый элемент списка list. Чтобы это понять, представьте на месте i любое число, например, Console.WriteLine(list[1]); Эта запись будет означать: «вывести первый элемент списка»

Отслеживать
ответ дан 21 окт 2020 в 20:10
Listopad02 Listopad02
1,198 1 1 золотой знак 6 6 серебряных знаков 21 21 бронзовый знак

@Lirika, честно сказать, С# немного не мой профиль, но если я правильно понял ваш код, то в вашем последнем цикле for (for (var i = 0; i < list.Count; i++)), list.Count и есть количество всех ваших элементов списка, так что просто выводите его через writeLine. Может, вы хотели вывести все элементы в одной строке, а не их количество?

21 окт 2020 в 20:21

Во первых, i у вас используется в двух местах, но видимо как оно используется в первом цикле вам понятно. Если нет, вкратце — в первом цикле for просто 15 раз запрашивает ввод данных из консоли. В этом цикле переменная i не более чем итератор, который отсчитывает какое по счету число вы вводите.

Кстати, что любопытно, проверка у вас на int работает, но если не int, то лишь информирует, и все равно пытается добавлять в список введенное значение. Наверное так и было задумано.

Во вторых, во втором цикле Вы верно понимает, что это перебор элементов списка list. И тогда i при каждой итерации цикла указывает на i-й элемент из списка list. Получается, что вы просто по порядку перебираете с первого по последний элементы в списке и выводите их на экран. list[i] — это значение, которое хранится в списке на позиции i. В данном случае i уже можно считать индексом значения (применимо к списку list). Само значение i на экран у вас в коде нигде не выводится при этом. Только значение из списка list.

Как уже вам в комментариях подсказали, можете вместо i просто написать цифру. К примеру list[0] — первый элемент списка, list[10] — одинадцатый и так далее. Чтобы иметь возможность вводить и выводить произвольное количество значений, вставили такой вот цикл, вместо вывода конкретных индексов, их перебирают в цикле. И i во втором цикле никак не относится к i в первом цикле.

Указатели

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

Определение указателя

Для определения указателя надо указать тип объекта, на который указывает указатель, и символ звездочки *:

тип_данных* название_указателя;

Сначала идет тип данных, на который указывает указатель, и символ звездочки *. Затем имя указателя.

Например, определим указатель на объект типа int:

int* p;

Такой указатель может хранить только адрес переменной типа int , но пока данный указатель не ссылается ни на какой объект и хранит случайное значение. Мы его даже можем попробовать вывести на консоль:

#include int main()

Например, в моем случае консоль вывела «0x8» — некоторый адрес в шестнадцатеричном формате (обычно для представления адресов в памяти применяется шестнадцатеричная форма). Но также можно инициализировать указатель некоторым значением:

int* p<>;

Поскольку конкрентное значение не указано, указатель в качестве значения получает число 0. Это значение представляет специальный адрес, который не указывает не на что. Также можно явным образом инициализировать нулем, например, используя специальную константу nullptr :

int* p;

Хотя никто не запрещает не инициализировать указатели. Однако в общем случае рекомендуется все таки инициализировать, либо каким-то конкретным значением, либо нулем, как выше. Так, к примеру, нулевое значение в будущем позволит определить, что указатель не указывает ни на какой объект.

Cтоит отметить что положение звездочки не влияет на определение указателя: ее можно помещать ближе к типу данных, либо к имени переменной — оба определения будут равноценны:

int* p1<>; int *p2<>;

Также стоит отметить, что размер значения указателя (хранимый адрес) не зависит от типа указателя. Он зависит от конкретной платформы. На 32-разрядных платформах размер адресов равен 4 байтам, а на 64-разрядных — 8 байтам. Например:

#include int main() < int *pint<>; double *pdouble<>; std::cout

В данном случае определены два указателя на разные типы — int и double. Переменные этих типов имеют разные размеры — 4 и 8 байт соответственно. Но размеры значений указателей будут одинаковы. В моем случае на 64-разрядной платформе размер обоих указателей равен 8 байтам.

Получение адреса и оператор &

С помощью операция & можно получить адрес некоторого объекта, например, адрес переменной. Затем этот адрес можно присвоить указателю::

int number ; int *pnumber ; // указатель pnumber хранит адрес переменной number

Выражение &number возвращает адрес переменной number . Поэтому переменная pnumber будет хранить адрес переменной number . Что важно, переменная number имеет тип int, и указатель, который указывает на ее адрес, тоже имеет тип int. То есть должно быть соответствие по типу. Однако также можно использовать ключевое слово auto :

int number ; auto *pnumber ; // указатель pnumber хранит адрес переменной number

Если мы попробуем вывести адрес переменной на консоль, то увидим, что он представляет шестнадцатиричное значение:

#include int main() < int number ; int *pnumber ; // указатель pnumber хранит адрес переменной number std::cout

Консольный вывод программы в моем случае:

number addr: 0x1543bffc74

В каждом отдельном случае адрес может отличаться и при разных запусках программы может меняться. К примеру, в моем случае машинный адрес переменной number — 0x1543bffc74 . То есть в памяти компьютера есть адрес 0x1543bffc74, по которому располагается переменная number. Так как переменная x представляет тип int , то на большинстве архитектур она будет занимать следующие 4 байта (на конкретных архитектурах размер памяти для типа int может отличаться). Таким образом, переменная типа int последовательно займет ячейки памяти с адресами 0x1543bffc74, 0x1543bffc75, 0x1543bffc76, 0x1543bffc77.

Указатели в C++

И указатель pnumber будет ссылаться на адрес, по которому располагается переменная number, то есть на адрес 0x1543bffc74.

Итак, указатель pnumber хранит адрес переменной number, а где хранится сам указатель pnumber? Чтобы узнать это, мы также можем применить к переменной pnumber операцию &:

#include int main() < int number ; int *pnumber ; // указатель pnumber хранит адрес переменной number std::cout

Консольный вывод программы в моем случае:

number addr: 0xe1f99ff7cc pnumber addr: 0xe1f99ff7c0

Здесь мы видим, что переменная number располагается по адресу 0xe1f99ff7cc , а указатель, который хранит этот адрес, — по адресу 0xe1f99ff7c0 . Из вывода видно, что обе переменные хранятся совсем рядом в памяти

Получение значения по адресу

Но так как указатель хранит адрес, то мы можем по этому адресу получить хранящееся там значение, то есть значение переменной number. Для этого применяется операция * или операция разыменования («indirection operator» / «dereference operator»). Результатом этой операции всегда является объект, на который указывает указатель. Применим данную операцию и получим значение переменной number:

#include int main() < int number ; int *pnumber ; std::cout Address = 0x44305ffd4c Value = 25

Значение, которое получено в результате операции разыменования, можно присвоить другой переменной:

int n1 ; int *pn1 ; // указатель pn1 хранит адрес переменной n1 int n2 < *pn1>; // n2 получает значение, которое хранится по адресу в pn1 std::cout int x = 10; int *px = &x; *px = 45; std::cout

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

В языке C++ помимо стандартного оператора присваивания = существует еще несколько операторов присваивания: += , -= , *= , /= , %= , &= , |= , ^= , >= . Запись x+=a эквивалентна записи x=x+a , то есть значение x увеличивается на a . Аналогично работают и остальные операторы: x=a присвоить x значение a
x+=a увеличить значение x на a
x-=a уменьшить значение x на a
x*=a умножить x на a
x/=a поделить x на a (не забудьте про то, что бывает деление целочисленное и с плавающей точкой!)
x%=a заменить x на остаток от деления x на a

Все эти операции возвращают ссылку на переменную, стоящую слева от оператора присваивания. При этом если в арифметической инструкции есть несколько операторов присваивания, то они выполняются справа налево. Операторы присваивания имеют более низкий приоритет, чем операторы + , - , * , / , % , то есть выполняются после этих операторов (если нет скобок).

Во второй строке стоит два оператора присваивания. Сначала выполнится оператор m*=2 , поскольку он стоит правее. Этот оператор присвоит m значение 6 и вернет это значение. Следующим выполнится оператор n+=6 , где 6 — это значение, которое вернул предыдущий оператор присваивания. Таким образом, переменной n будет присвоено значение 8 и на экран будут напечатаны числа 8 и 6.

Операторы инкремента и декремента

Унарный оператор инкремента ++ увеличивает значение переменной на 1. Существует две формы оператора инкремента: префиксная форма ++n и постфиксная форма n++ . Постфиксный оператор инкремента возвращает старое значение переменной, а префиксный оператор — новое, то есть увеличенное на 1. Пример:

Переменные a , b , d в этом примере будут иметь значение, равное 1, а переменная c будет равна 0.

Унарный оператор декремента -- уменьшает значение переменной на 1 и также существует в префиксной и постфиксной формах.

Операторы инкремента и декремента имеют более высокий приоритет, нежели операторы арифметических операций и присваиваний, то есть выполняются раньше их (в выражении --d%=c сначала будет выполнен декремент переменной d , а затем оператор взятия остатка и присваивания %= ).

Цикл for

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

Синтаксис оператора for такой:

for (инициализация ; условие ; итератор )
инструкция

где инициализация , условие , итератор — арифметические выражения, инструкция — одна инструкция языка C++.

Работает цикл for следующим образом. Сначала вычисляется выражение " инициализация ". Затем вычисляется значение " условия ". Если оно истинно, то выполняется " инструкция " тела цикла, а затем вычисляется " итератор ". Если же " условие " ложно, то цикл не выполняется и управление передается на следующую инструкцию после цикла. Если цикл был выполнен, то после вычисления " итератора " снова проверяется " условие ", и если оно истинно, то снова выполняется " инструкция ", а затем вычисляется " итератор " и так далее, пока условие не станет ложно.

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

Рассмотрим следующий пример, в котором на экран выводится 3 числа: 0, 1 и 2:

Выполняется инициализация i=0 .
Проверяется условие i
Выполняется тело цикла: значение переменной i выводится на экран.
Вычисляется итератор ++i . Теперь i равно 1.
Проверяется условие i
Выполняется тело цикла: значение переменной i выводится на экран.
Вычисляется итератор ++i . Теперь i равно 2.
Проверяется условие i
Выполняется тело цикла: значение переменной i выводится на экран.
Вычисляется итератор ++i . Теперь i равно 3.
Проверяется условие i

Инструкции управления циклом

Внутри циклов while и for могут встречаться инструкции управления циклом. Инструкция break; прерывает выполнение цикла, управление при этом немедленно передается на следующую после цикла инструкцию. Инструкция continue; продолжает выполнение цикла со следующей итерации: все входящие в блок цикла инструкции не выполняются, в цикле for выполняется итератор, после чего проверяется условие (во всех видах циклов) и в зависимости от его значения выполняется или не выполняется тело цикла. Как правило, инструкции break; и continue; используются вместе с инструкцией if . Пример: for(i=0;i <100;++i)
if(i%3==0)
continue;
cout // Выполнить еще какие-нибудь действия
>
В этом примере переменная i в цикле принимает значения от 0 до 99. Внутри цикла проверяется условие и если i делится на 3, то оставшаяся часть цикла пропускается, и на экран будут напечатаны только те значения i , которые не делятся на 3.

Извлечение квадратного корня

Для извлечения квадратного корня (из величин типа double , целочисленные величины необходимо преобразовать к типу double ) используется стандартная функция sqrt , определененная в файле cmath . Для ее использования необходимо в начале файла с программой добавить строку #include . Пример использования функции: d=sqrt(e); .

Упражнения (для 9 класса)

Не используя компьютер, определите значения переменных после выполнения данных фрагментов программ: int a=5,b=4,c=17,d=3;
a-=b=c%=d;

Упражнения (для 10 класса)

Не используя компьютер, определите значения переменных после выполнения данных фрагментов программ: int a=5,b=4,c=17,d=3;
a-=b=c%=d;

Решите эту задачу для d=4.
Аналитически (без использования компьютера) решите задачу для d=8.
Решите эту задачу для всех оставшихся цифр.
Подумайте над обобщением этой задачи на случай нескольких последних цифр.

Int i 0 что это значит