Основы алгоритмизации и программирования

СОДЕРЖАНИЕ
1. ПЕРЕМЕННЫЕ И ВЫРАЖЕНИЯ .................................................................8
1.1. Базовый синтаксис С# .....................................................................................8
1.2. Переменные ...................................................................................................9
1.2.1. Простые типы переменных ......................................................................10
1.2.2. Именование переменных .........................................................................11
1.2.3. Соглашения, используемые при именовании .............................................11
1.2.4. Литеральные значения ............................................................................11
1.2.5. Литеральные строки................................................................................12
1.2.6. Объявление переменных и присваивание им значений ...............................12
1.3. Выражения ....................................................................................................12
1.3.1. Математические операторы .....................................................................13
1.3.2. Операторы присваивания ........................................................................14
1.3.3. Старшинство операторов .........................................................................14
1.4. Пространства имен .........................................................................................14
1.5. Вопросы для повторения ............................................................................16
2. УПРАВЛЕНИЕ ПОРЯДКОМ ВЫПОЛНЕНИЯ ПРОГРАММЫ ................17
2.1. Булева логика .................................................................................................17
2.2. Операторы работы с битами ............................................................................18
2.2.1. Логические операторы присваивания .......................................................19
2.2.2. Старшинство операторов с дополнениями ................................................20
2.2.3. Оператор goto. ........................................................................................20
2.3. Ветвление ......................................................................................................21
2.3.1. Тринарный оператор ...............................................................................21
2.3.2. Оператор if. ............................................................................................21
2.3.3. Проверка большего количества условий с помощью оператора if ................22
2.3.4. Оператор switch ......................................................................................23
2.4. Организация циклов .......................................................................................23
2.4.1. Цикл do. .................................................................................................24
2.4.2. Цикл while..............................................................................................24
2.4.3. Цикл for .................................................................................................24
2.4.4. Прекращение выполнения цикла ..............................................................25
2.4.5. Бесконечные циклы ................................................................................25
2.5. Вопросы для повторения ............................................................................25
3. ДОПОЛНИТЕЛЬНЫЕ СВЕДЕНИЯ О ПЕРЕМЕННЫХ ............................26
3.1. Преобразованиепеременных из одного типа в другой ........................................26
3.1.1. Неявные преобразования .........................................................................26
3.1.2. Явные преобразования ............................................................................27
3.1.3. Выполнение явных преобразований с помощью команд преобразования .....28
3.2. Сложные типы переменных ............................................................................28
3.2.1. Перечислимый тип .................................................................................28 3.2.2. Определение перечислимых типов ...........................................................28
3.2.3. Структуры .............................................................................................29
3.2.4. Массивы ................................................................................................29 3.2.5. Циклы foreach. ........................................................................................31
3.2.6. Многомерные массивы ...........................................................................31 3.2.7. Массивы массивов ..................................................................................31
3.2.8. Действия над строками ............................................................................32
3.3. Вопросы для повторения ............................................................................33
4. ФУНКЦИИ ........................................................................................................34
4.1. Описание и использование функций ................................................................34
4.2. Возвращаемые значения..................................................................................35
4.3. Параметры .....................................................................................................35
4.3.1. Соответствие параметров ........................................................................36
4.3.2. Массивы параметров ...............................................................................36 4.3.3. Передача параметров по ссылке и по значению .........................................36
4.3.4. Выходные параметры .............................................................................37
4.4. Область действия переменных .........................................................................38 4.5. Функция Main() ..............................................................................................39
4.6. Функции структур ..........................................................................................40 4.7. Перегрузка функций .......................................................................................40
4.8. Вопросы для повторения ............................................................................41
5. ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ...............42
5.1. Объектно-ориентированное программирование ................................................42
5.2. Объект ...........................................................................................................42
5.2.1. Свойства и поля ......................................................................................43
5.2.2. Методы..................................................................................................43
5.2.3. Конструкторы ........................................................................................44
5.2.4. Деструкторы ..........................................................................................44
5.2.5. Статические члены класса и члены класса экземпляра ................................44
5.3. Ссылочные и значимые типы данных ...............................................................45
5.3.1. Структуры .............................................................................................45
5.3.2. ООП в приложениях Windows .................................................................45
5.4. Вопросы для повторения ............................................................................46
6. ОПРЕДЕЛЕНИЕ КЛАССОВ ...........................................................................47
6.1. Определение классов в С# ...............................................................................47
6.2. Конструкторы и деструкторы ..........................................................................49
6.3. Типы структур................................................................................................50
6.4. Неглубокое и глубокое копирование ................................................................51
6.5. Вопросы для повторения ............................................................................52
7. ЧЛЕНЫ КЛАССОВ И ИХ СВОЙСТВА ........................................................52
7.1. Члены классов ................................................................................................52
7.1.1. Определение членов................................................................................52
7.1.2. Определение полей .................................................................................52
7.1.3. Определение методов ..............................................................................52
7.1.4. Определение свойств ..............................................................................53
7.2. Свойства членов .............................................................................................55
7.2.1. Дополнительные действия с членами класса .............................................55
7.3. Вопросы для повторения ............................................................................56
8. РАБОТА С ФАЙЛАМИ ...................................................................................57
8.1. Потоки ..........................................................................................................57
8.1.1. Классы для ввода и вывода ......................................................................57
8.1.2. Классы File и Directory.............................................................................57
8.1.3. Класс FileInfo..........................................................................................58
8.1.4. Класс DirectoryInfo ..................................................................................58
8.1.5. Имена пути и относительные пути ...........................................................58
8.1.6. Объект FileStream ...................................................................................58
8.1.7. Позиция внутри файла ............................................................................59
8.1.8. Чтение данных .......................................................................................59
8.1.9. Запись данных ........................................................................................60
8.2. Объект StreamWriter........................................................................................61 8.3. Форматирование данных .................................................................................62
8.4. Объект StreamReader. ......................................................................................62
8.4.1. Чтение данных .......................................................................................63
8.4.2. Файлы с ограничителем ..........................................................................63
8.5. Вопросы для повторения ............................................................................64
ЗАДАНИЯ ДЛЯ САМОСТОЯТЕЛЬНОЙ РАБОТЫ ........................................65 СПИСОК ЛИТЕРАТУРЫ ...................................................................................66
1. ПЕРЕМЕННЫЕ И ВЫРАЖЕНИЯ
Компьютерная программа это последовательность операций над данными. Это утверждение оказывается справедливым даже для наиболее сложных случаев, таких, например, как развернутые, многофункциональные Windowsприложения типа Microsoft Office Suite. И хотя пользователи зачастую не задумываются над структурой приложений, внутренняя сущность последних заключается именно в этом.
Когда используется приложение, например, калькулятор, вводятся данные, представленные в форме чисел, и выполняются над этими числами различные операции почти так же, как с помощью карандаша и бумаги.
Если фундаментальное свойство компьютерных программ заключается в выполнении операций над данными, то это предполагает наличие, во-первых, некоторого способа хранения данных и, во-вторых, определенных методов для выполнения манипуляций над ними. Для обеспечения этих двух функций используются соответственно переменные и выражения.
Рассмотрим базовый синтаксис, используемый при программировании на С#.
1.1.Базовый синтаксис С#
Внешне код на С# очень напоминает код на C++ или на Java. Компиляторы С# не обращает внимание на лишнее пустое пространство, которое может состоять из пробелов, возвратов каретки или символов табуляции (эти символы известны под общим названием символов пустого пространства). Отсюда можно сделать вывод, что мы обладаем большой свободой в выборе способа форматирования нашей программы, хотя следование определенным правилам помогает создавать более удобные для чтения программы.
Код на С# представляет собой последовательность операторов, каждый из которых оканчивается точкой с запятой. Поскольку пустое пространство игнорируется, то можно располагать по несколько операторов в одной строке; однако для того чтобы сделать программу более наглядной, принято размещать символ возврата каретки после каждой точки с запятой, в результате чего на строке располагается только один оператор. Хотя абсолютно приемлемо (и совершенно нормально) использовать операторы, которые занимают несколько строк кода.
С# – язык, обладающий блочной структурой; другими словами, каждый оператор является частью некоторого блока кода. Эти блоки, для обозначения начала и конца которых используются фигурные скобки, соответственно, { и }, могут содержать произвольное количество операторов или не содержать их вовсе. Фигурные скобки не сопровождаются точками с запятой.
Простой блок программы на С# может иметь следующий вид:
{
;


;
}
Здесь выражения не являются действительными составляющими кода на С#: этот текст используется для обозначения места, куда впоследствии будут помещены операторы С#. В данном примере вторая и третья строки кода являются частями одного и того же оператора, поэтому после второй строки точка с запятой отсутствует.
В этом простом примере кода использованы отступы, чтобы сделать запись на С# более наглядной. Такой подход является обычной практикой; в действительности VS автоматически делает такие отступы по умолчанию. Каждый блок кода имеет свою величину отступов, определяющую, насколько далеко вправо он сдвинут. Блоки могут быть вложены друг в друга (т. е. блоки могут содержать в себе другие блоки), и в таком случае величина отступа у вложенных блоков должна быть больше:
{
;
{
;
;
}
; }
Кроме того, больший отступ обычно используется для тех строк кода, которые являются продолжением предшествующей строки, как в случае строки 3 в первом из приведенных примеров.
Такой стиль не является обязательным. Однако, если его не использовать, то текст программы будет трудночитаемым.
Еще одна вещь, которая может часто встречаться в коде на С#, это комментарии. Комментарии не являются частью кода на С#, однако они сосуществуют с ним. Предназначение комментариев в точности соответствует их названию: они позволяют включать в программу описательный текст на обычном английском (французском, немецком, монгольском и т. д.) языке, который игнорируется компилятором. Когда приступают к созданию достаточно длинных сегментов кода, то бывает полезно включить в программу напоминание о том, что именно разработчики собираются сделать. В С# предусмотрены два способа включения комментариев. Можно использовать либо специальные маркеры, обозначающие начало и завершение комментария, либо маркер, который означает, что "все, что находится за ним до конца строки, является комментарием".
Для того чтобы обозначить комментарии по первому способу, используются сочетания символов /* в начале комментария и */ в конце комментария. Они могут располагаться как на одной строке, так и на разных строках; в последнем случае все строки, находящиеся между ними, также являются частью комментария. Единственное, что не может входить в состав комментария,– это сочетание символов */, поскольку оно будет интерпретировано как конец комментария. Допустимы следующие комментарии:
/* Это комментарий */
/* Так же, как . . .
и это! */
А вот приведенный ниже пример ошибочен:
/* Сочетание символов “*/” часто используется для завершения комментария */
В этом случае последняя часть комментария (символы, расположенные после */) будет интерпретирована как код С#, что приведет к возникновению ошибки.
Другой подход к оформлению комментария состоит в использовании в качестве его начала символов //. В следующем за ними комментарии можно написать все, что угодно, но не более одной строки. Данный пример является правильным:
// Это еще один вид комментария.
А вот попытка воспользоваться следующим комментарием приведет к неудаче, поскольку вторая строка будет интерпретироваться как код на С#
// Это тоже комментарий,
а вот это уже нет.
Такой вид комментариев оказывается полезным для документирования отдельных операторов, поскольку весь комментарий целиком умещается на одной строке:
; // Объяснение данного оператора
В С# существует еще и третий тип комментариев, который позволяет создавать документацию для программы. Этот комментарий также расположен на одной строке, но в отличие от последнего случая начинается с трех символов /, а не с двух:
/// Это особый вид комментария
В обычных условиях эти комментарии игнорируются компилятором, как и все остальные, однако можно настроить VS таким образом, что текст этих комментариев при компиляции проекта будет извлекаться и использоваться для создания специальным образом отформатированного текстового файла. На его основе в дальнейшем можно создавать документацию по проекту.
Чрезвычайно важным моментом, который необходимо учитывать при работе с С#, является чувствительность этого языка к регистру. В отличие от некоторых других языков программирования, на С# текст необходимо вводить, в точности соблюдая регистр, поскольку простая замена заглавной буквы на строчную приведет к прекращению компиляции проекта.
Базовая структура консольного приложения на С#
Простейший код консольного приложения (Console Application) имеет следующий вид:
using System;
namespace ConsoleApplication {
l
///

/// Summary description for Class
///

class Classl
{
static void Main (string[] args) {
//
// ТОDО: Add code to start application here //
static void Main(string[] args)
Console.WriteLine(“The first application"); } } }
Рис. 1.1 – Простейшая программа вида Console Application
Нетрудно заметить, что в этом приложении присутствуют все синтаксические элементы, обсуждавшиеся выше, а именно, точки с запятыми, фигурные скобки, комментарии и отступы.
Наиболее важной частью кода является следующее: static void Main(string[] args)
{
// TODO: Add code to start application here
// static void Main(string[] args)
Console.WriteLine(“The first app in Beginning C# Programming!");
}
Это тот заключенный в фигурные скобки блок кода, который и выполняется при запуске. Единственной строкой, выполняющей какие-либо действия, является строка, которую добавили к автоматически сгенерированному коду и которая – одна из всех – не является комментарием. Этот код выводит некоторый текст в консольном окне, а понимание того, каким образом выполнение приложения доходит до точки вызова Console.WriteLine(), а также механизм его работы сейчас не важен.
1.2.Переменные
Переменные тесно связаны с хранением данных. По существу, переменные в памяти компьютера можно представить в виде коробочек, лежащих на полке. Такие коробочки могут использоваться для того, чтобы что-нибудь в них класть, а затем вынимать обратно, или же можно просто заглянуть в них и узнать, есть там что-то или нет. Все это относится и к переменным, в которые мы можем помещать данные, а затем брать их оттуда или просматривать по мере необходимости.
Хотя все данные в компьютере фактически представляют собой одно и то же (последовательность, состоящую из нулей и единиц), переменные могут отличаться друг от друга, образуя так называемые типы. Возвращаясь к аналогии с коробочками, можно представить коробочки различных размеров и форм, причем разные объекты могут помещаться только в специально предназначенные для них коробочки. Обоснование системы типов заключается в том, что для манипуляций над данными различных типов могут требоваться различные методы, и, приписав переменным конкретные типы, можно избежать серьезной путаницы. Ведь вряд ли получится что-то осмысленное, если рассматривать последовательность нулей и единиц, представляющую собой оцифрованное изображение, в качестве звукового файла.
Для того чтобы использовать переменную, необходимо ее объявить. Это означает, что ей должны быть присвоены имя и тип. Как только переменная объявлена, она может использоваться как хранилище для данных того типа, который указан в ее объявлении.
Синтаксис объявления переменных в С# состоит из указания типа переменной и ее имени:
;
Если попытаться использовать переменную, которая не была объявлена, то программа не будет откомпилирована и будет сгенерирована соответствующая ошибка. Однако в этом случае компилятор сможет точно указать, в чем именно заключается проблема, и поэтому такой тип ошибок не очень опасен. Попытка использовать переменную, которой не присвоено никакого значения, тоже приведет к ошибке; в этом случае компилятор также сможет точно установить причину ее возникновения.
Существует бесконечное множество типов, которые можно использовать, так как имеется возможность описывать
свои собственные типы, предназначенные для хранения любых даже самых сложных данных.
Однако существуют определенные типы данных, которые раньше или позже потребуются всем, например, переменные, в которых могут храниться числа. По этой причине существует некоторое количество простых, предварительно описанных типов данных.
1.2.1.Простые типы переменных
Простые типы – это такие типы значений, как численные или логические (true (истина) или false (ложь)), которые являются составными частями любых приложений, а также других, более сложных типов. Большинство из имеющихся типов являются численными, что на первый взгляд выглядит несколько странно: разве для хранения чисел не достаточно одного типа?
Причина такого изобилия численных типов кроется в способе хранения чисел в памяти компьютера как последовательности нулей и единиц. В случае целых значений мы используем несколько бит (отдельных цифр, которые могут принимать значение нуля или единицы) и просто представляем число в двоичном формате. Переменная, в которой может храниться N бит, позволяет представлять любые числа в диапазоне от 0 до ( N 12 - ). Числа, превышающие последнее значение, оказываются слишком большими и не могут быть размещены в переменной данного типа.
В качестве примера рассмотрим переменную, в которой может храниться 2 бита. Соответствие между целыми числами и их двоичным представлением в этом случае будет следующим:
0 = 00 1 = 01 2 = 10 3 = 11
Если необходимо хранить большие числа, то для этого потребуется большее количество бит (3 бита, например, позволят хранить числа, лежащие в диапазоне от 0 до 7).
Отсюда неизбежно следует вывод о том, что хранение произвольного числа требует бесконечного количества бит, что, безусловно, неприемлемо для персонального компьютера. Но даже если бы необходимое количество бит и имелось, использовать такой объем памяти для числа, изменяющегося, скажем, от 0 до 10, было бы крайне неэффективно (из-за неиспользуемой памяти). В данном случае вполне достаточно 4 бит, которые позволяют разместить в одной и той же области памяти все числа указанного диапазона.
Именно для этого существует несколько целых типов, которые могут быть использованы для хранения чисел из различных диапазонов и которые занимают различный объем памяти (вплоть до 64 битов). Эти типы целых чисел сведены в таблицу, приводимую ниже.
Каждый тип использует один из стандартных типов, определенных в .NET Framework. Применение стандартных типов – это как раз то, что делает возможным совместное использование различных языков программирования. Имена, которые используются для этих типов в С#, обозначают определенные типы, описанные в .NET Framework. В таблице 1.1 приводятся имена типов и указывается, какому типу в библиотеке .NET Framework они соответствуют.
Буква "u", встречающаяся перед некоторыми из имен, является сокращением от слова "unsigned" ("беззнаковый"). Это говорит о том, что в переменных соответствующего типа не могут храниться отрицательные значения. Этот факт отражен в столбце "Допустимые значения".

Внимание, отключите Adblock

Вы посетили наш сайт со включенным блокировщиком рекламы!
Ссылка для скачивания станет доступной сразу после отключения Adblock!

Скачать полную версию