Серия «Введение в основы программирования.»

1

Заключение

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

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

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

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

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

Удачи!

5

Методы

Продолжаем улучшать читабельность и информативность программного кода.

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

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

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

  • Распределить написание кода между командой программистов, где каждый пишет свой модуль, блок программного кода. Затем эти модули соединяются в единую конструкцию.

  • Упрощается отладка и поиск ошибок в программе, потому как найти неверно работающий модуль легче, чем найти ошибку среди тысяч строк программного кода в методе Main.

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

Наименьшим выделенным блоком программного кода в языке C# является — метод. К примеру, точка входа в программу метод— Main, или методы вывода на экран — Write и WriteLine.

Методы делятся на две группы. Методы, возвращающие значение и методы невозвращение значение. Аналогами методов в других языках программирования, являются функции и процедуры

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

static void Metod()

{

Тело цикла. Здесь пишется блок исполняемого кода.

}

Где,

  • static — этот параметр примите как необходимость. Его обсуждение не входит в тему этой лекции

  • void — ключевое слово, указывающее, что метод не возвращает значение, которое может изменить ход выполнения программы

  • Metod — имя метода. По правилам пишется с большой буквы и имеет описательное содержание, которое описывает выполняемую функцию.

  • () — круглые скобки. Формат записи, указывающий на метод. Круглые скобки могут быть пустыми или содержать параметр.

  • {} — между фигурных скобок пишется исполняемый код.

Самая распространенная операция, которая не влияет на ход выполнения программы, а значит не возвращает никакого значения, является вывод информации на экран.  Очень часто, таким сообщением бывает сообщение — Ошибка.

Выделим сообщение об ошибке в отдельный блок — метод, и вызовем этот метод в методе Main. Все операции производятся в class Program

class Program

{

static void Main(string[] args)

{

MessageError();

}


static void MessageError()

{

Console.WriteLine("Ошибка");

}

}

На первый взгляд, здесь происходит нарушение основного принципа программирования — следование. Метод MessageError() находится ниже метода Main. На самом деле это не так. Найдя строку MessageError();,  компилятор находит в программе этот метод, выполняет его, и затем передает управление назад в метод Main. Поэтому нет разницы, где будет находится метод, ниже выше или в другом классе, или в другом файле, метод будет выполнен, в противном случае программа закончится ошибкой. При расположении метода за пределами базового класса Program, обязательно указывается путь к этому методу. Об этом поговорим чуть позже.

Как видно из вышеприведенного программного кода, использование методов очень похоже на применение переменных. По большому счету, операция Console.WriteLine("Ошибка"); как некое значение, была помещена в отдельный блок с именем, и теперь по имени можно вызвать эту операцию на выполнение.

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

Напишем метод, умножающий значение переменной «х» на два.

static void Sum(int x)

{

Console.WriteLine(x * 2);

}

Здесь, в строке static void Sum(int x), параметр метода, метод Sum ожидает значение с типом данных int, которым будет инициализирована переменная int x.

Для того, чтобы воспользоваться методом достаточно вызвать метод по имени в методе Main, и в круглые скобки поместить значение. Значение в круглых скобках называется — аргумент. Аргумент должен иметь идентичный, с параметром тип данных.

class Program

{

static void Sum(int x)

{

Console.WriteLine(x * 2);

}


static void Main(string[] args)

{

Sum(30); //ПЕРЕДАЧА аргумента

// ОТВЕТ. Невидимая операция

}

}

Число «30» в строке Sum(30); является аргументом метода Sum. Саму же операцию передачи значения аргумента в параметр метода, можно представит как операцию инициализации переменной, в которой правым операндом является аргумент, а левым параметр.

В познавательном процессе о методах, встречаются ситуацию, когда обучающийся, написав свой метод не может к нему обратится. Это связано с тем, что ученик привык к мысли «одна операция — одно действие». Здесь же в строке Sum(30); происходит две операции — передача аргумента и получение ответа от метода в виде результата вычисления. Дабы избавится от визуальной зависимости «одна операция — одно действие», представьте, что ниже строки Sum(30); находится невидимая операция, принимающая ОТВЕТ.

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

class Program

{

static void Sum(int x)

{

Console.WriteLine(x * 2);

}

static void Main(string[] args)

{

int a = 30;

Sum(a); //ПЕРЕДАЧА аргумента

//ОТВЕТ. Невидимая операция

}

}

Здесь в качестве аргумента выступает значение переменной «а», которое инициализирует переменную «х», параметр метода Sum. После выполнения программного кода в теле метода Sum, результат вычисления возвращается методу Main.

Усложним задачу и напишем программу с несколькими параметрами, представленными различными типами данных.

class Program

{

static void Data(int x, string text)

{

Console.WriteLine($"Имя: {text}, возраст: {x}");

}


static void Main(string[] args)

{

int age = 30;

string name= "Bill";

Data(age, name); //ПЕРЕДАЧА аргумента

//ОТВЕТ. Невидимая операция

}

}

Здесь, аргументами выступают переменные age и name которые инициализируют переменные int x, string text метода Data.

В случаях, когда у метода два и более параметра необходимо соблюдать два правила.

  • 1.  Количество аргументов должно быть идентичным количеству параметров.

  • 2.  Типы данных параметров должны соответствовать по своему расположению типам данных аргументов. Т.е. первый параметр и аргумент должны иметь идентичные типы данных.

    Помимо переменных, в качестве параметров могут выступать структуры.

    Нижеприведен код программы, где метод ShowMany выводит на экран все элементы массива, а ShowOne — единственный.

    class Program

    {

    static void ShowMany(int[] arr)

    {

    for(int i=0; i<arr.Length; i++)

    {

    Console.Write( arr[i] + " ");

    }

    }

    static void ShowOne(int[] arr, int i)

    {

    Console.Write(arr[i]);

    }

    static void Main(string[] args)

    {

    int[] little = { 3, 6, 8, 9 };

    int[] big = { 1, 2, 3, 6, 5, 4, 9, 8, 25 };

    ShowMany(big); //ПЕРЕДАЧА аргумента

    //ОТВЕТ. Невидимая операция

    Console.WriteLine();

    ShowOne(little, 1); //ПЕРЕДАЧА аргумента

    //ОТВЕТ. Невидимая операция

    }

    }

    Здесь, параметром ShowMany является массив, поэтому аргументом для этого метода будет массив. Метод ShowOne, позволяет обратится к отдельному элементу массива, но операция по выводу отдельного элемента массива происходит внутри метода, поэтому прежде, чем обратится к конкретному элементу, необходимо в метод ShowOne передать все элементы массива. Таким образом метод ShowOne имеет два параметра — массив и переменную инициализируемую индексом

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

    Такие методы легко отличить от методов с «void». Так как метод возвращает значение, а значение имеет тип данных, то ключевое слово «void» заменяется на один из принятых типов данных. Само значение возвращается с помощью оператор — return.

    static string Name()

    {

    return "Bill";

    }

    Где, string — тип данных метода Text. Типом данных определены характеристики обрабатываемых значений.

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

    class Program

    {

    static string Text()

    {

    return "Bill";

    }


    static void Main(string[] args)

    {

    string name=Text();

    Console.WriteLine($"Имя {name}");

    }

    }

    Оператор return выполняет две функции, возвращает значение и прекращает работу метода.

    class Program

    {

    static string Text()

    {

    string name = "Bill";

    return name;

    string message = "Error";

    }


    static void Main(string[] args)

    {

    string name=Text();

    Console.WriteLine($"Имя {name}");

    }

    }

    Так как оператор «return» завершает работу метода, то операция с этим методом должна находится на последней строчке метода.

    Используя параметры и аргументы методы могут обмениваться значениями.

    class Program

    {

    static string Text(string name)

    {

    return name;

    }

    static int Number(int years)

    {

    return years;

    }

    static void Main(string[] args)

    {

    string name = Text("Bill");

    int age = Number(36);

    Console.WriteLine($"Имя {name}, возраст {age}");

    }

    }

    Здесь, аргументами "Bill" и 36, были инициализированы переменные в методах Text и Number соответственно.

В заключении.

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

Для передачи значений между методами, к примеру, между Main  и Sum, используется конструкция аргумент — параметр, где аргумент передает значение, а параметр принимает. Аргументом может быть как литеральное, так и переменное значение, параметром выступает переменная с типом данных идентичным аргументу.

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью

Имена переменных и комментарии. Синтаксис C#

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

Напишем программу

static void Main(string[] args)

{

Console.WriteLine("Введите значение");

int a = int.Parse(Console.ReadLine());

Console.WriteLine(a*5/9+32);

}

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

А теперь представьте себе, вы открываете код и видите применение такого стиля оформления у программы в 1000 строк. Даже если эту программу написали Вы, для понимания происходящего в этом коде придется потратить много времени.

Избежать этого позволило бы наличие комментариев

static void Main(string[] args)

{

/* Эта программа переводит значение температуры

* по Фаренгейту в значение температуры по Цельсию */

Console.WriteLine("Введите значение"); //Температура по Фаренгейту

int a = int.Parse(Console.ReadLine());

Console.WriteLine(a*5/9+32); //Температура по Цельсию

}

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

С помощью многострочного комментария некоторые программисты блокируют готовые блоки кода. Это делается в случаях, когда программист сомневается какой вариант программного кода оптимален для программы.

static void Main(string[] args)

{

/* Эта программа переводит значение температуры

* по Фаренгейту в значение температуры по Цельсию */

Console.WriteLine("Введите значение");

int a = int.Parse(Console.ReadLine());

Console.WriteLine(a * 5 / 9 + 32); //Первый вариант вычислений

/*

* int b = a * 5 / 9 + 32; //Второй вариант вычислений

Console.WriteLine(b);

*/

}

Написание комментариев подчинены определённым правилам.

Первое и главное правило комментария – комментарий должен предоставлять правдоподобную информация.

  • Комментарии могут предоставлять дополнительную информация или пояснять назначение кода.

  • Комментарии могут подсказать как улучшить код, если код, в силу каких-то причин, был написан не удачно.

  • Комментарии могут предупреждать об опасностях внесения изменений в код. Самый распространенный из таких комментариев – “НЕ ТРОГАТЬ!!!”. На эту тему, на просторах интернета, есть поучительная история про вентилятор, воздушный шар и комнату, набитую швабрами.

Еще одним элементом в написании информативного кода являются ИМЕНА.

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

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

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

Объектам, т.е. переменным, массивам, методам, классам и т.д. принято задавать удобочитаемые, описательные имена, которые объясняют, для чего создан объект.

Применение простых имен таких как a, b или z обычно используются внутри небольших блоков программы, где однозначно определено для чего нужна переменная

  • Если имя, для уникальности или смысловой нагрузки должно содержать два и более слова, эти слова пишутся слитно— thisFirstVariable. В языке C# к таким словам применяется стиль написания — Верблюжья нотация. Для этой нотации характерно следующее написание— Первое слово пишется со строчной буквы, последующие — с заглавной. Торчащие посреди заглавные буквы выглядят как горб у верблюда.

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

  • Длина имени не больше 15 символов. Имя объекта — thisFirstVariableofSquareClassRectangle, только усложнит чтение кода.

Для примера.

static void Main(string[] args)

{

int firstVariable = 10;

int secondVariable = 10;

int resultSum = firstVariable + secondVariable;

Console.WriteLine(resultSum);

}

Однако не всегда есть необходимость так полно информировать о принадлежности переменной, скорее это относится к глобальным переменным, о которых мы расскажем чуть позже. Имена переменным внутри небольших кусочков кода, таких как операции ветвления, повторения, лучше присваивать имена вида— a, b, c, y, x.

В заключении.

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

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

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

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью
4

Двумерные массивы и вложенные циклы. Синтаксис C#

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

static void Main(string[] args)

{

string[,] arr = { { "A", "B" }, { "C", "D" } };

Console.WriteLine(arr[1,0]);

}

Здесь, инициализирован двумерный массив из двух строк, в каждой из которых два значения. Значения A и B принадлежать первой строке с индексом 0, значения С и D, находятся на второй строке, с индексом 1. С помощью arr[1,0] был получен доступ к значению «С» расположенному на второй строке в первом столбце.

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

Первым параметром указывается количество строк, вторым— столбцов. Количество строк и столбцов называется размерностью массива.

static void Main(string[] args)

{

int[,] arr = new int [ 2, 3 ];

arr[0, 0] = 1;

arr[0, 1] = 2;

arr[0, 2] = 3;

arr[1, 0] = 4;

arr[1, 1] = 5;

arr[1, 2] = 6;

Console.WriteLine(arr[1,0]);

}

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

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

Так же, как и в одномерном массиве, для перебора в цикле нужно знать размерность массива, но в отличии от одномерного, в двумерном, размерности две. Одна — количество строк, вторая количество — столбцов. Свойство Length для этих целей не подходит, так как предназначено для подсчета количества всех элементов массива вне зависимости от того, как они хранятся.

static void Main(string[] args)

{

int[,] arr = new int[2, 3];

arr[0, 0] = 1;

arr[0, 1] = 2;

arr[0, 2] = 3;

arr[1, 0] = 4;

arr[1, 1] = 5;

arr[1, 2] = 6;

Console.WriteLine(arr.Length);

}

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

static void Main(string[] args)

{

int[,] arr = new int[2, 3];

arr[0, 0] = 1;

arr[0, 1] = 2;

arr[0, 2] = 3;

arr[1, 0] = 4;

arr[1, 1] = 5;

arr[1, 2] = 6;

// Перебор строк:

for (int i = 0; i < arr.GetLength(0); i++)

{

// Перебор столбцов в строке:

for (int j = 0; j < arr.GetLength(1); j++)

{


Console.Write(arr[i, j] + " ");

}

// Переход к новой строке:

Console.WriteLine();

}

}

Общепринято для внешнего цикла использовать переменную «i», для внутреннего «j»

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

static void Main(string[] args)

{

int[,] arr = new int[2, 3];

Random rnd = new Random();

int value = rnd.Next(0, 10);


for (int i = 0; i < arr.GetLength(0); i++)

{

// Перебор столбцов в строке:

for (int j = 0; j < arr.GetLength(1); j++)

{

arr[i,j] = rnd.Next(0, 10);

Console.Write(arr[i, j] + " ");

}

// Переход к новой строке:

Console.WriteLine();

}

}

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

К примеру, таблица умножения

static void Main(string[] args)

{

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

{

for (int j = 1; j < 10; j++)

{

Console.Write($"{i * j} \t");

}

Console.WriteLine();

}

}

Здесь, « \t » управляющий символ, литерал, аналог клавиши Tab, используемый для выравнивания текста.

В заключении.

Двумерный массив — массив таблица. Доступ к единичному значению в таком массиве осуществляется по двум индексам — индекс строки и индекс столбца.

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

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью
4

Операции над массивом. Синтаксис C#

Операции над массивом включают в себя

  • Присвоение значения элементу массива

  • Изменение элемента массива

  • Поиск элемента массива

  • Сортировка элементов массива. Данная операция относится к учебному курсу «Алгоритмы и структуры данных» и в данной лекции рассмотрена не будет.

Присвоение значения элементу массива.

Присвоить значения элементам массива можно при инициализации массива

int[] arr = {10, 5, 6, 3, 4};

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

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

static void Main(string[] args)

{

Random rnd = new Random();

int value = rnd.Next(0, 10);

Console.WriteLine("Сгенерированное число " + value);

}

Здесь — rnd, объект класса Random. Классы не входят в рамки этого курса и не будут рассмотрены.

Строка int value = rnd.Next(0, 10); — операция инициализации целочисленной переменной целочисленным значением, которое является результатом вычисления операции rnd.Next(0, 10), где метод— Next(0, 10) определяет диапазон числового ряда.

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

static void Main(string[] args)

{

Random rnd = new Random();

int[] arr = new int[5];

for (int i = 0; i < arr.Length; i++)

{

arr[i] = rnd.Next(0, 10);

Console.WriteLine($"Индекс элемента {i}, значение {arr[i]}");

}

}

Переменная « i » последовательно принимает значения числового ряда в диапазоне от нуля до четырех. Изменяясь каждую итерацию, переменная « i », изменяет каждую итерации индекс в выражении arr[i], при первой итерации выражение arr[i] будет заменено на arr[0], а при последнем на arr[4]. Таким образом, в строке arr[i] = rnd.Next(0, 10); происходит три операции

  • Генерация случайного значения в диапазоне от 0 до 10

  • Получение доступа к элементу массива по индексу

  • Присвоение сгенерированного значения элементу массива

В случае, когда значений не много, элементы массива можно случайными значениями с клавиатуры. Напишем программу для хранения названий трех самых высоких гор

static void Main(string[] args)

{

Console.WriteLine("Введите названия трех самых высоких гор");

string[] arr = new string[3];

for (int i = 0; i < arr.Length; i++)

{

Console.WriteLine("Введите название горы ");

arr[i] = Console.ReadLine();

}

Console.Clear();

Console.WriteLine("Названия трех самых высоких гор");

for (int i = 0; i < arr.Length; i++)

{

Console.WriteLine(arr[i]);

}

}

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

Изменение значений в элементах массива

Изменения значений в элементах ничем не отличаются от операции присвоения, и по аналогии с операцией присвоения нового значения переменной, происходит замещение одного значения другим.

static void Main(string[] args)

{

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

Random rnd = new Random();

for (int i = 0; i < arr.Length; i++)

{

arr[i] = rnd.Next(10, 20);

Console.WriteLine($"Индекс элемента {i}, значение {arr[i]}");

}

}

Самая распространенная операция над элементами массива — поиск значения.

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

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

static void Main(string[] args)

{

int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8 };

for (int i = 0; i < arr.Length; i++)

{

if (arr[i] % 2 == 0)

{

Console.WriteLine(arr[i]);

}

}

}

Здесь переменная « i » будет принимать значения от нуля до значения ограниченное логическим выражением «arr.Length», т.е. конечное значение массива. Меняясь, переменная « i », будет изменять индекс элемента arr[i]  и проверять его в отношении «arr[i] % 2 == 0» , тем самым вызывая для проверки, каждую итерацию, значение из нового элемента.

Часто требуется подсчитать вхождения в массив определенного значения.

static void Main(string[] args)

{

int count = 0;

Console.WriteLine("Введите искомое число");

int number = int.Parse(Console.ReadLine());

int[] arr = { 1, 2, 4, 4, 5, -1, 7, 8, 9, 7 };

for (int i = 0; i < arr.Length; i++)

{

if (arr[i] == number)

{

count++;

}

}

Console.WriteLine($"Количество вхождений числа {number} = {count}");

}

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

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

static void Main(string[] args)

{

int[] arr = { 1, 2, 4, 4, 5, -1, 7, 8, 9, 7 };

for (int i = 0; i < arr.Length; i++)

{

if (arr[i] > 0)

{

Console.WriteLine( arr[i]);

}

else

{

break;

}

}

}

В заключении.

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

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью
1

Структуры данных. Массив. Синтаксис C#

До этой лекции, для решения задач, использовалось единственное значение, хранимое в переменной. Но для большинства задач, требующих автоматизации, характерна обработка большого количества значений. Количество необходимых для получения результата вычисления может достигать несколько тысяч значений. Возникает вопрос. Как хранить и обрабатывать большое количество значений? Применение метода «одна переменная — одно значение» в данном случае неприемлемо. Представьте программный код с одной тысячей переменных. Удобочитаемость, имена переменных, сам набор символов для инициализации или объявления переменной, создадут огромные трудности для программиста. Здесь, даже не стоит говорить об эффективности программного кода с точки зрения аппаратной части вычислительной системы.

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

Но лекция не об структурах данных. Структуры данных — большой объем информации, для изучения которого существует специализированный учебный курс “Структуры и алгоритмы обработки данных”.

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

Массив в C# имеет некоторые ограничения

1.  Массив хранит значения с одним типом данных.

2.  Размер массива определяется сразу и не меняется.

В случае необходимости хранить значения с разными типами данных или когда размер массива нельзя предсказать заранее, применяются другие структуры данных, о которых вы можете узнать из курса “Структуры и алгоритмы обработки данных”.

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

Нижеприведенный массив состоит из двух элементов, каждый из которых хранит единственное значение типа данных int.

int[] arr = new int[2];

Отдельно нужно пояснить про оператор « new », который используется для указания на создание объекта некоторого класса. Классы не будут рассмотрены, поэтому примите оператор « new » как обязательный параметр при объявлении массива.

Заполним массив значениями. Для этого обратимся к элементам по соответствующим индексам и присвоим им значения, как обычным переменным. Нумерация индексов начинается с нуля.

static void Main(string[] args)

{

int[] arr = new int[2];

arr[0] = 5;

arr[1] = 3;

}

Вот так будет выглядеть массив в памяти компьютера. Здесь, значение ссылки приведено для наглядности и не соответствует действительности

Структуры данных. Массив. Синтаксис C# Введение, Основы, Программирование, Учебные курсы, Длиннопост

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

string[] text = { "Hello", ", ", "world ", "!"};
int[] arr = { 10, 5, 6, 3, 4 };

Доступ к единичному элементу массива осуществляется по имени массива с указанием индекса

static void Main(string[] args)

{

int[] arr = { 10, 5, 6, 3, 4 };

Console.WriteLine("Первое значение массива: " + arr[0]);

Console.WriteLine("Второе значение массива: " + arr[1]);

Console.WriteLine("Третье значение массива: " + arr[2]);

Console.WriteLine("Четвертое значение массива: " + arr[3]);

Console.WriteLine("Пятое значение массива: " + arr[4]);

}

Так как нумерация индексов элементов массива начинается с нуля, то для доступа к первому значению массива, нужно обратится к элементу с индексом « ноль ».

Но самым важным отличием массива от строкового значения является возможность изменения хранимых в элементах массива значений.

static void Main(string[] args)

{

string []text = { "А","Р","Т","К" };


text[2] = "M";

Console.WriteLine(text[2]);

}

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

Для работы с массивами создана специальная конструкция повторения с оператором foreach, но использовать мы ее не будем, а получим доступ к элементам массива с помощью конструкцией с оператором for

static void Main(string[] args)

{

int[] arr = new int[5] { 10, 5, 6, 3, 4 };

for(int i=0; i < arr.Length; i++ )

{

Console.Write(arr[i] + " ");

}

}

Или while

static void Main(string[] args)

{

string[] arr = new string[5] { "10", "5", "6", "3", "4" };

int i = 0;

while (i < arr.Length)

{

Console.Write(arr[i] + " ");

i++;

}

}

Где,

  • Выражение int i=0— начальное значение счетчика

  • Выражение i < arr.Length — логическое выражение со свойством Length, которое определяет размер массива. В случае результата true в операции отношения, выполняется итерация цикла, результат — false, заканчивает цикл.

  • Унарная операция i++ — операция по изменению счетчика.

В заключении.

Хранение большого количества значений в переменных не эффективно, как с точки информативности и удобочитаемости программного кода, так и с точки эффективности использования аппаратной части вычислительной системы. Для хранения некоторого количества значений используются более сложные структуры данных. Одной из таких структур является — массив. Массив переназначен для хранения однотипных значений, в области памяти компьютера под названием — куча. Доступ к элементу, хранимому значение,  осуществляется по его индексу. Первый индекс элемента равен нулю. Для доступа к массиву в стеке записывается ссылка в виде имени массива, указывающая, где находится массив.

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

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью 1
2

Операции над строковым значением с помощью цикла. Синтаксис C#

Самой распространенной операцией над строковым значением является поиск. Поиск может осуществляется как одного элемента, так и цепочки из элементов. К примеру, зная, что инструкция в программном коде заканчивается на знак «;», можно подсчитать количество инструкций даже если некоторые из них написаны в одну строку. Поиск, цепочек из элементов, позволяют определить стратегию продажи товара. Для этого, в отзывах ищут цепочки из символов «хорошо» или «плохо».

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

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

Изменение номера индекса — повторяющаяся задача, поэтому применим для этой операции операцию повторения.

Для написания цикла, нам необходимо знать начальное, конечное значение цикла, а также изменение начального значения.

  1. Так как нумерация индексов начинается с нуля, то и начальное значение будет начинаться с нуля.

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

static void Main(string[] args)

{

string text = "Hello!";

int sizeText =  text.Length;

Console.WriteLine($"Размер значения: {sizeText} символов");

}

  1. Изменение значения будем осуществлять по нижеприведенному алгоритму:

  • Представим индекс элемента в виде переменной

  • В цикле будем изменять значение переменной. Изменяя значение переменной, каждую итерацию, в конструкции — имя переменной [индекс элемента], вместо индекса элемента будет подставляться новое значение.

    Напишем программу вывода элементов через пробел переменной text.

    static void Main(string[] args)

    {

    string text = "Hello!";

    for(int i=0; i < text.Length; i++)

    {

    Console.Write(text[i] + " ");

    }

    }

    Здесь,

    1. Внесено изменение в конструкцию — имя переменной [индекс элемента] и представляет собой следующий вид  — text[i].

    2. Изменяясь каждую итерацию, переменная «i» будет принимать значение от нуля до пяти. При первой итерации, конструкция text [i], получит от переменной « i » значение в виде числа « 0 » и метод вывода примет следующий вид Console.Write(text[0] + " "); а при последней — Console.Write(text[5] + ","). 


    Выведем на экран символы значение из предыдущей программы в обратном порядке


    static void Main(string[] args)

    {

    string text = "Hello!";

    for (int i = text.Length; i > 0; i--)

    {

    Console.Write(text[i] + " ");

    }

    }

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

Операции над строковым значением с помощью цикла. Синтаксис C# Введение, Основы, Учебные курсы, Длиннопост

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

Исправить ошибку достаточно легко. Достаточно уменьшить значение свойства Length на единицу. Еще одной ошибкой в данном коде является конечное значение счетчика определенное операцией «i > 0». Здесь «i» не достигнет числа « 0 » и элемент с таким индексом не будет задействован в цикле.

Исправим обе ошибки

static void Main(string[] args)

{

string text = "Hello!";

for (int i = text.Length - 1; i >= 0; i--)

{

Console.Write(text[i] + " ");

}

}

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

Практический пример для подсчета предложений

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

static void Main(string[] args)

{

string text = "Эрнест Хемингуэй! Старик и море. Жанр. Роман?";

int count = 0;

int i = 0;

while (i < text.Length)

{

if ((text[i] == '.') || (text[i] == '!') || (text[i] == '?'))

{

count++;

}

i++;

}

Console.WriteLine("Количество предложений: " + count);

}

Здесь переменная «i» не только считает количество итераций, но и изменяет каждую итерацию индекс массива символов. Таким образом в цикле просматриваются все символы от первого до последнего. В случае совпадения символа значения с символом сравнения, информация об этом записывается в переменную count.

В заключении.

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

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью 1
2

О string и char. Синтаксис C#

Из этой лекции вы узнаете о ссылочном типе данных — string и примитивном — char.

Переменные с ссылочным типом данных string — это переменные, предназначенные для хранения значений в виде строк. Строкой считается любое значение, с форматом представления в виде любых символов заключенных между двойными кавычками, даже если это один символ.

Объявление и инициализация переменной с типом данных string ничем ни отличается от тех же операций с другими типами данных.

Так выглядит инициализация переменной с строковым значением

static void Main(string[] args)

{

string text = "Bill";

}

В отличии от числовых значений, строковое значение, не является набором цифр, и поэтому не может хранится как числовое значение.

Для хранения строгого значения используется следующая схема. Строковое значение разбивается на отдельные символы, в том числе, знаки препинания, пробелы и т.д., и каждый символ преобразуется в число. После преобразования получается массив из чисел, которые записываются в специальную область памяти — куча. Соответствие символа и его десятичного, числового представления указаны в таблице символов ASCII(1 байт) или UNICODE(2 байта).

Для доступа к строковому значению, в стеке, создается объект-ссылка с именем, в котором указано, где, в куче, находятся символы.

Ссылка приведена для визуального оформления

О string и char. Синтаксис C# Введение, Основы, Программирование, Учебные курсы, Длиннопост

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

Строковое значение «Bill», в памяти компьютера будет представлено следующим набором числовых значений — 66 105 108 108.

О string и char. Синтаксис C# Введение, Основы, Программирование, Учебные курсы, Длиннопост

Для доступа к отдельному элементу указывается имя значения и соответствующий индекс, в формате записи — имя переменной [индекс элемента]

static void Main(string[] args)

{

string text = "Bill";

Console.WriteLine($"Имя строка - {text[0]},{text[1]},{text[2]},{text[3]}");

}

Здесь, для вывода строки применена интерполяции.

Элемент строкового значения хранится в виде значения с символьным типом данных — char. Таким образом, значение с типом данных string — это массив элементов с типом данных char.

static void Main(string[] args)

{

string text = "Bill";

Console.WriteLine("Тип данных: " + text[0].GetTypeCode());

}

Здесь, метод GetTypeCode(), указывает на тип данных значения, хранимого в элементе с индексом 0.

Символьный тип —char, является очень интересным типом данных. Значения этого типа данных хранится как числовое значение, но на экран выводится — его графическое представление. Другими словами, для компьютера значение типа данных —char, является числом, но пользователь на экране видит символ.  Это некий мостик, между строковыми и числовыми значениями.

Значения с типом данных char относятся к примитивным типам данных и хранятся в стеке. Формат записи —  единственный символ, обрамленный одинарными кавычками. Размер выделяемой памяти составляет один или два байта.

Инициализация переменной

static void Main(string[] args)

{

char symbolA = 'A';

}

О string и char. Синтаксис C# Введение, Основы, Программирование, Учебные курсы, Длиннопост

Соответствие символа и его числового значения

static void Main(string[] args)

{

char symbolA = 'A';

Console.WriteLine("Переменная символа 'A' = " + symbolA);

int number = symbolA;

Console.WriteLine("Числовое значение переменной symbolA = " + number);

}

При изменении числового значение меняется символ.

static void Main(string[] args)

{

char symbolA = 'A';

Console.WriteLine("Переменная символа 'A' = " + symbolA);

int number = symbolA + 1;

char value = (char)number;

Console.WriteLine("Символ 'A' + 1 = " + value);

}

Здесь, переменная number инициализирована числом, соответствующим символу 'A' — 65, добавим к этому значению единицу. Результатом такой операции станет число 66, которое соответствует символу 'B'. Для преобразования числового значения в значение с типом данных char используется явное привидение типов

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

static void Main(string[] args)

{

string text = "Bill";

Console.WriteLine($"Размер значения - {text.Length}");

}

Зная, что строковое значение — массив значений символьного типа, а также размер массива, можно производить некоторые действия над строковым значением. В C# такие действия ограничены, но, к примеру в языке С++, можно заменять один символ другим. Возможности обработка строки, на различных языках программирования существенно отличается, иначе зачем столько языков программирования.

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

Примем, что строковое значение состоит из одного предложение, заканчивающееся на один из вышеперечисленных знаков.

Последний символ предложения хранится в последнем элементе значения. Для получения доступа к этому элементу нам необходимо знать его индекс. В этом нам поможет свойство Length, в виде конструкции «Length-1». Дело в том, что нумерация в Length начинается не с нуля, как у индексов элементов, а с единицы. Дабы привести в соответствие числовые ряды, Length уменьшается на единицу.

Полученный индекс последнего элемента запишем в отдельную переменную «int idx = text.Length-1;». Таким образом в операции отношения сравнивается последний элемент строкового значения с символами окончания предложения.

static void Main(string[] args)

{

string text = "Hello, world!";

int idx = text.Length - 1;

if (text[idx] == '.')

{

Console.WriteLine("Предложение повествовательное");

}

if (text[idx] == '!')

{

Console.WriteLine("Предложение побудительное");

}

if (text[idx] == '?')

{

Console.WriteLine("Предложение вопросительное");

}

}

В заключении.

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

Значения с типом данных char, представляет собой значение в графическом виде, отображающее символ, но хранимое как число. Символы и соответствующие им числовые значения приведены в таблице ASCII. Формат записи — единственный символ, заключенный в одинарные кавычки.

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью 3
Отличная работа, все прочитано!