Название: Основы алгоритмизации и программирования 2
Вид работы: реферат
Рубрика: Информатика
Размер файла: 784.79 Kb
Скачать файл: referat.me-133384.pdf
Краткое описание работы: ОСНОВЫ АЛГОРИТМИЗАЦИИ И ПРОГРАММИРОВАНИЯ КОНСПЕКТ ЛЕКЦИЙ Тамбов 2009 Утверждена на заседании кафедры прикладной информатики Тамбовского филиала ФГОУ ВПО МГУКИ «__» августа 2009 г., протокол № __
Основы алгоритмизации и программирования 2
ОСНОВЫ АЛГОРИТМИЗАЦИИ И ПРОГРАММИРОВАНИЯ
КОНСПЕКТ ЛЕКЦИЙ
Тамбов 2009
ББК
УДК
Х
Утверждена на заседании кафедры прикладной информатики Тамбовского филиала ФГОУ ВПО МГУКИ «__» августа 2009 г., протокол № __
Составители: канд. техн. наук, доцент В.Н. Точка,
Основы алгоритмизации и программирования:конспект лекций для студентов, обучающихся по специальности 080801 «Прикладная информатика (в менеджменте) (дневной формы обучения)»:/ сост. В.Н. Точка. - Тамбов, 2009.- 100 с.
© Тамбовский филиал ФГОУ ВПО МГУКИ, 2009
СОДЕРЖАНИЕ
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. Компиляторы С# не обращает внимание на лишнее пустое пространство, которое может состоять из пробелов, возвратов каретки или символов табуляции (эти символы известны под общим названием символов пустого пространства). Отсюда можно сделать вывод, что мы обладаем большой свободой в выборе способа форматирования нашей программы, хотя следование определенным правилам помогает создавать более удобные для чтения программы.
Код на С# представляет собой последовательность операторов, каждый из которых оканчивается точкой с запятой. Поскольку пустое пространство игнорируется, то можно располагать по несколько операторов в одной строке; однако для того чтобы сделать программу более наглядной, принято размещать символ возврата каретки после каждой точки с запятой, в результате чего на строке располагается только один оператор. Хотя абсолютно приемлемо (и совершенно нормально) использовать операторы, которые занимают несколько строк кода.
С# – язык, обладающий блочной структурой; другими словами, каждый оператор является частью некоторого блока кода. Эти блоки, для обозначения начала и конца которых используются фигурные скобки, соответственно, { и }, могут содержать произвольное количество операторов или не содержать их вовсе. Фигурные скобки не сопровождаются точками с запятой.
Простой блок программы на С# может иметь следующий вид:
{
<строка кода 1, оператор 1>; |
<строка кода 2, оператор 2> |
<строка кода 3, оператор 2> |
;
}
Здесь выражения <строка кода х, оператор у> не являются действительными составляющими кода на С#: этот текст используется для обозначения места, куда впоследствии будут помещены операторы С#. В данном примере вторая и третья строки кода являются частями одного и того же оператора, поэтому после второй строки точка с запятой отсутствует.
В этом простом примере кода использованы отступы, чтобы сделать запись на С# более наглядной. Такой подход является обычной практикой; в действительности VS автоматически делает такие отступы по умолчанию. Каждый блок кода имеет свою величину отступов, определяющую, насколько далеко вправо он сдвинут. Блоки могут быть вложены друг в друга (т. е. блоки могут содержать в себе другие блоки), и в таком случае величина отступа у вложенных блоков должна быть больше:
{
<строка кода 1>;
{
<строка кода 2>;
<строка кода 3>;
}
<строка кода 4>; }
Кроме того, больший отступ обычно используется для тех строк кода, которые являются продолжением предшествующей строки, как в случае строки 3 в первом из приведенных примеров.
Такой стиль не является обязательным. Однако, если его не использовать, то текст программы будет трудночитаемым.
Еще одна вещь, которая может часто встречаться в коде на С#, это комментарии. Комментарии не являются частью кода на С#, однако они сосуществуют с ним. Предназначение комментариев в точности соответствует их названию: они позволяют включать в программу описательный текст на обычном английском (французском, немецком, монгольском и т. д.) языке, который игнорируется компилятором. Когда приступают к созданию достаточно длинных сегментов кода, то бывает полезно включить в программу напоминание о том, что именно разработчики собираются сделать. В С# предусмотрены два способа включения комментариев. Можно использовать либо специальные маркеры, обозначающие начало и завершение комментария, либо маркер, который означает, что "все, что находится за ним до конца строки, является комментарием".
Для того чтобы обозначить комментарии по первому способу, используются сочетания символов /* в начале комментария и */ в конце комментария. Они могут располагаться как на одной строке, так и на разных строках; в последнем случае все строки, находящиеся между ними, также являются частью комментария. Единственное, что не может входить в состав комментария,– это сочетание символов */, поскольку оно будет интерпретировано как конец комментария. Допустимы следующие комментарии:
/* Это комментарий */ |
||
/* Так же, как . . . |
||
и это! */ |
А вот приведенный ниже пример ошибочен:
/* Сочетание символов “*/” часто используется для завершения комментария */
В этом случае последняя часть комментария (символы, расположенные после */) будет интерпретирована как код С#, что приведет к возникновению ошибки.
Другой подход к оформлению комментария состоит в использовании в качестве его начала символов //. В следующем за ними комментарии можно написать все, что угодно, но не более одной строки. Данный пример является правильным:
// Это еще один вид комментария.
А вот попытка воспользоваться следующим комментарием приведет к неудаче, поскольку вторая строка будет интерпретироваться как код на С#
// Это тоже комментарий, |
|
а вот это уже нет. |
Такой вид комментариев оказывается полезным для документирования отдельных операторов, поскольку весь комментарий целиком умещается на одной строке:
<Некоторый оператор>; // Объяснение данного оператора
В С# существует еще и третий тип комментариев, который позволяет создавать документацию для программы. Этот комментарий также расположен на одной строке, но в отличие от последнего случая начинается с трех символов /, а не с двух:
/// Это особый вид комментария
В обычных условиях эти комментарии игнорируются компилятором, как и все остальные, однако можно настроить VS таким образом, что текст этих комментариев при компиляции проекта будет извлекаться и использоваться для создания специальным образом отформатированного текстового файла. На его основе в дальнейшем можно создавать документацию по проекту.
Чрезвычайно важным моментом, который необходимо учитывать при работе с С#, является чувствительность этого языка к регистру. В отличие от некоторых других языков программирования, на С# текст необходимо вводить, в точности соблюдая регистр, поскольку простая замена заглавной буквы на строчную приведет к прекращению компиляции проекта.
Базовая структура консольного приложения на С#
Простейший код консольного приложения (Console Application) имеет следующий вид:
using System; |
||||||||||
namespace ConsoleApplication { |
l |
|||||||||
/// <summary> |
||||||||||
/// Summary description for Class |
||||||||||
/// </summary> |
||||||||||
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" ("беззнаковый"). Это говорит о том, что в переменных соответствующего типа не могут храниться отрицательные значения. Этот факт отражен в столбце "Допустимые значения".
Таблица 1.1 – Типы данных C# и соответствующие им типы .NET Framework
Тип |
Тип .NET Framework |
Допустимые значения |
sbyte |
System. Byte |
Целое в диапазоне от -128 до 127 |
byte |
System. Byte |
Целое в диапазоне от 0 до 255 |
short |
System.Intl6 |
Целое в диапазоне от -32 768 до 32 767 |
ushort |
System.UIntl6 |
Целое в диапазоне от 0 до 65 535 |
int |
System.Int32 |
Целое в диапазоне от -231 до 231 -1 |
uint |
System.UInt32 |
Целое в диапазоне от 0 до 232 -1 |
long |
System.Int64 |
Целое в диапазоне от -263 до 263 -1 |
ulong |
System.UInt64 |
Целое в диапазоне от 0 до 264 -1 |
Кроме целых чисел часто требуется хранить дробные значения (или значения с плавающей запятой), которые представляют нецелые числа. Существует три типа переменных с плавающей запятой, которые можно использовать: float, double и decimal. Первые два из них хранят числа с плавающей запятой в виде ± m 2× e , причем диапазон допустимых значений m и е для каждого типа свой. Тип decimal использует альтернативную форму представления чисел ± m 10× e . Эти три типа приводятся ниже вместе с допустимыми значениями m и е и диапазонами действительных чисел
(таб. 1.2).
Таблица 1.2 – Дробные типы данных C# и соответствующие им типы .NET Framework
|
|
|
|
|
|
|
|
float |
System.Single |
0 |
224 |
-149 |
104 |
1.5 10× - 45 |
3.4 10× 38 |
double |
System.Double |
0 |
253 |
-1075 |
970 |
5 10× -324 |
1.7 10× 307 |
decimal |
System.Decimal |
0 |
296 |
-26 |
0 |
1 10× -28 |
7.9 10× 28 |
Кроме численных типов, существует еще три простых типа (таб. 1.3).
Таблица 1.3 – Символьные и логические типы данных C# и соответствующие им типы данных .NET Framework
Тип |
Тип .NET Framework |
Диапазон допустимых значений |
char |
System.Char |
Отдельный символ в кодировке Unicode, хранящийся в виде целого числа в диапазоне от 0 до 65 535 |
bool |
System.Boolean |
Логическое значение (Boolean), которое может принимать значения true (истина) илиfalse(ложь) |
string |
System.String |
Последовательность символов |
Следует обратить внимание, что верхней границы количества символов, составляющих строки типа string, не существует, поскольку они могут занимать изменяющиеся объемы памяти.
Логический тип bool – один из наиболее часто используемых в С# типов переменной; аналогичные типы часто встречаются в кодах на других языках программирования. Использование переменной, которая может принимать только два значения – либо true, либо false,– создает очень важную возможность ветвления логики приложения. Одним из применений такого типа данных - сравнение значений переменных и проверка допустимости введенной информации.
1.2.2.Именование переменных
Нельзя использовать в качестве имени переменной произвольную последовательность символов. Однако в распоряжении разработчика имеется весьма гибкая система именования.
Основные правила при именовании переменных следующие:
- первый символ в имени переменной должен быть либо буквой, либо символом подчеркивания _, либо @; - последующими символами могут быть буквы, символ подчеркивания или цифры.
Кроме того, существуют определенные ключевые слова, которые обладают особым смыслом с точки зрения компилятора С#, например, using или namespace.
Если по ошибке используется одно из них, компилятор сгенерирует соответствующую ошибку при компиляции. Следующие имена переменных являются правильными: myBigVar
VAR1
_test
А вот эти – нет: 99BottlesOfBeer namespace
It's-All-Over
С# чувствителен к регистру: необходимо постоянно помнить о правильном использовании регистров в соответствии с тем, как они использовались при объявлении переменных. Обращение к переменной внутри программы, в котором хотя бы один символ будет набран в неверном регистре, приведет к выдаче сообщения об ошибке в процессе компиляции.
Другим следствием этой ситуации является возможность иметь множество имен переменных, которые будут отличаться друг от друга только использованием регистра; например, приведенные ниже имена различны:
myVariable MyVariable MYVARIABLE
1.2.3.Соглашения, используемые при именовании
Имена переменных – это нечто такое, что приходится использовать очень часто. Поэтому стоит посвятить немного времени тому, какие типы имен следует применять. Однако прежде чем перейти к обсуждению этого вопроса, следует отметить, что данная тема полна противоречий. На протяжении многих лет одни системы именования сменялись другими, а некоторые разработчики готовы насмерть стоять за признание только собственных систем.
До недавнего времени наиболее популярной была система, известная под именем венгерской системы записи. Она предполагает использование перед именами всех переменных префикса, набираемого в нижнем регистре и обозначающего тип переменной. Например, если переменная имеет тип int, то перед ней следует поместить символ i, например, iAge. При использовании такой системы оказывается очень просто определять тип переменных даже при беглом взгляде на программу.
Однако в более современных языках, вроде С#, реализовать венгерскую систему оказывается совсем не просто. Эта система вполне может использоваться для простых типов, описанных выше (таб. 1.1-1.3), поскольку для обозначения каждого типа вполне достаточно префиксов, состоящих из одной или двух букв. Но поскольку имеется возможность создавать свои собственные типы и, кроме того, в базовой .NET Framework таких сложных типов присутствует несколько сотен, то система быстро перестает работать. Когда над проектом трудятся несколько человек, существенно возрастает вероятность того, что с использованием различных префиксов будет возникать путаница, которая может иметь самые разрушительные последствия.
В итоге разработчики пришли к выводу, что намного лучше именовать переменные просто в соответствии с их предназначением. Если при этом возникают какие-либо сомнения, то узнать тип переменной очень просто. В VS для этого надо просто поместить курсор мыши около имени переменной, и очень быстро появится окно, в котором будет указан ее тип.
В настоящее время в пространствах имен .NET Framework используются два соглашения об именовании, известные как PascalCase и camelCase. Отличить одну систему от другой можно по использованию регистра. Обе системы применяются к именам, составленным из нескольких слов; при этом каждое слово в составном имени набирается в нижнем регистре, за исключением первой буквы слова, которая должна набираться в верхнем регистре. В системе camelCase существует еще одно дополнительное правило, которое гласит, что первое слово должно начинаться с буквы в нижнем регистре.
Следующие имена переменных соответствуют правилам camelCase:
age |
||
firstName |
||
timeOfDeath |
А вот так имена должны записываться в соответствии с правилами PascalCase:
Age |
||
LastName |
||
WinterОfDisconten |
t
Следует отметить, что система PascalCase соответствует рекомендациям компании Microsoft.
Необходимо отметить, что многие предыдущие системы именования широко использовали символ подчеркивания, обычно в качестве
Тип(ы) |
Значение |
Суффикс |
Пример/Допустимые значения |
bool |
Логическое |
Отсутствует |
trueилиfalse |
int, uint, long, ulong |
Целое |
Отсутствует |
100 |
uint, ulong |
Целое |
u или U |
100U |
long, ulong |
Целое |
1 илиL |
100L |
ulong |
Целое |
ul, uL, Ul, UL, lu, lU, Lu или LU |
100UL |
float |
Вещественное |
f или F |
1,5F |
double |
Вещественное |
Отсутствует, d или D |
1,5 |
decimal |
Вещественное |
m или М |
1,5M |
char |
Символьное |
Отсутствует |
'а' или escapeпоследовательность |
string |
Строковое |
Отсутствует |
“a. . .а", может включать escape-последовательности |
Таблица 1.4 – Типы переменных и соответствующие им литеральные значения разделителя слов в имени переменной: например, my_first_variable. Однако, такой подход в настоящее время не рекомендуется.
1.2.4.Литеральны е значения
В предыдущем примере были использованы два литеральных значения: целое число и строка. Переменные других типов также обладают определенными литеральными значениями, которые сведены в приведенную ниже таблицу. Многие из них предполагают использование суффиксов, т. е. добавление в конец литерального значения некоторой последовательности символов, которая позволяет определить необходимый тип. Некоторые литеральные значения могут иметь несколько типов, которые определяются в время работы компилятора по контексту.
1.2.5.Литеральные строки
Приведем таблицу всех возможных escape-последовательностей для справочных целей.
В таблице 1.5 последний столбец содержит шестнадцатеричные значения кодов символов в кодировке Unicode.
Кроме приведенных выше символов, с помощью escape-последовательности можно задать любой символ в кодировке Unicode. Такая последовательность должна состоять из стандартного символа , за которым следует символ u и четырехзначное шестнадцатеричное значение (например, те четыре цифры, которые расположены после символа х в последнем столбце вышеприведенной таблицы).
Отсюда следует, что, например, следующие две строки эквивалентны
“Karli’s string.” |
|
“Karliu0027s string.” |
Очевидно, что возможность использовать escape-последовательности в кодировке Unicode дает дополнительную гибкость.
Также можно применять "дословные" строки (verbatim). Это означает, что в строку включаются все символы, находящиеся между двумя двойными кавычками, в том числе символы конца строки и символы, для которых в противном случае потребовалось бы использование escape-последовательностей. Единственным исключением из этого правила является escape-последовательность для символа двойной кавычки, которая должна использоваться во избежание преждевременного завершения обработки строки. Чтобы получить дословную строку, необходимо поместить в ее начало символ @:
@”Verbatim string literal.”
Эта строка может быть задана и обычным способом, а вот для следующего примера такой способ оказывается единственно возможным: @"A short list item 1 item 2"
Escapeпоследовательность |
Выводимый символ |
Код символа в кодировке Unicode |
’ |
Одиночная кавычка |
0x0027 |
” |
Двойная кавычка |
0x0022 |
\ |
Обратный слэш |
0х005С |