Главная страница Случайная лекция
Мы поможем в написании ваших работ!
Порталы:
БиологияВойнаГеографияИнформатикаИскусствоИсторияКультураЛингвистикаМатематикаМедицинаОхрана трудаПолитикаПравоПсихологияРелигияТехникаФизикаФилософияЭкономика
Мы поможем в написании ваших работ!
Переменные
Элементарной единицей данных в компьютерной программе является переменная. Каждая переменная должна иметь имя, отличающее ее от других переменных, и тип. Эти характеристики переменных задаются при их объявлении.
2.1.1. Объявление переменных
Объявление переменных осуществляется оператором объявления (подробно он будет описан в главе 3), имеющим вид:
<тип_переменной> <имя_переменной>;
Например:
int n;
double x;
При попытке использовать переменную, которая не была объявлена, компилятор обнаружит ошибку и выдаст соответствующее сообщение.
Кроме того, переменная характеризуется своим значением – связанным с ней элементом данных. В отличие от имени и типа, значение переменной может изменяться по ходу выполнения программы. Для того чтобы начать использовать переменную, ей необходимо присвоить начальное значение. Это называется инициализацией переменной. Инициализация переменных, как правило, выполняется в момент объявления, хотя и может быть отложена. В первом случае оператор объявления дополняется присваиванием начального значения и имеет вид:
<тип_переменной> <имя_переменной> = <начальное_значение>;
Например:
int n = 0;
double x = 0.1;
Во втором случае инициализация выполняется после объявления переменной, но до ее первого использования, в одном из операторов выполнением операции присваивания. При попытке использовать переменную без ее инициализации будет возникать ошибка.
Несколько переменных одного типа могут быть объявлены в одном операторе, с инициализацией или без нее. Например:
int i = 0,j,n = 10;
Хорошим стилем считается инициализация переменных во время их объявления. Причину этого можно пояснить следующим простым примером:
intx, s; // Объявление без инициализации
x = 7;
if(x > 5) s = 4;
Console.WriteLine("s= {0}",s);// Ошибка //компиляции:использование неинициализированной //переменной
Переменная s, как это легко видеть при просмотре кода, получает значение в условном операторе if. Тем не менее, при компиляции возникнет ошибка, утверждающая, что в процедуре WriteLine делается попытка использовать неинициализированную переменную s. Связано это с тем, что для оператора if на этапе компиляции не вычисляется условие, зависящее от переменной x. Поэтому компилятор предполагает худшее – условие ложно, инициализация s в этом операторе не происходит.
Иногда возникает необходимость запретить изменять значение переменной, назначенное ей при инициализации. Такая переменная называется константой. Она должна быть объявлена с использованием служебного слова constиинициализирована при объявлении, например:
const intn = 10;
2.1.2. Именование переменных
Выбор имен переменных – далеко не тривиальная задача. Во-первых, имя переменной должно, по-возможности, отражать ее назначение и быть удобным в использовании (в частности, не очень длинным). Во-вторых, оно должно подчиняться определенным в языке правилам построения имен. В третьих, имя, если оно является составным, должно быть удобочитаемым.
В языке C# определены следующие правила именования переменных:
· первым символом в имени обязательно должна быть либо буква, либо символ подчеркивания (_), либо символ @;
· последующими символами в имени могут быть буквы, символы подчеркивания или числа;
· в качестве имен не могут быть использованы ключевые слова языка.
Язык С# является чувствительным регистру (регистрозависимым). Это означает, что если в объявлении переменной ее имя записано с использованием малых букв (символов нижнего регистра), то запись того же имени в другом месте программы с использованием хотя бы одной большой буквы (буквы верхнего регистра) будет рассматриваться компилятором как попытка обращения к другой, необъявленной переменной и вызовет ошибку компиляции.
Следующие имена удовлетворяют правилам формирования имен в C#:
myVar
VAR1
Сумма
_test
@addr41
А вот эти имена являются недопустимыми:
99BottlesOfBeer – начинается с цифры
namespace – является ключевым словом
It's-All-Over – содержит символы апострофа и дефиса
С учетом регистровой зависимости C# все перечисленные ниже имена переменных будут являться совершенно разными именами:
myVariable
MyVariable
MYVARIABLE
При конструировании составных имен переменных используются такие системы именования:
typeCase – венгерская нотация;
PascalCase – стиль языка Pascal;
camelCase – "верблюжий" стиль.
Венгерская нотация подразумевает использование в именах всех переменных стандартных прописных префиксов, указывающих на тип этих переменных, например intVal. Для простых типов еще можно было бы подобрать одно- или двухбуквенные префиксы. Но из-за возможности создавать свои собственные типы и наличия многих сотен таких более сложных типов, такой подход быстро теряет практичность.
К тому же в любом месте исходного текста можно выяснить тип переменной наведя на ее имя курсор мыши: после этого появляется всплывающее окно с информацией о типе этой переменной. Поэтому в настоящее время программисты обычно используют системы именования PascalCase или camelCase. В соответствии с рекомендациям Microsoft системой camelCase лучше пользоваться для именования переменных простых типов, а системой PascalCase — для переменных сложных типов. Для разделения частей составного имени не рекомендуется использовать символ подчеркивания, например, my_Arr.
2.1.3. Пространства имен
Пространства имен (namespace) являются в .NET способом обеспечения уникальности имен в коде приложения. Большую часть этих имен составляют имена различных пользовательских типов.
Пространство имен определяется с помощью ключевого слова namespace с указанием имени пространства. Область действия пространства имен ограничивается фигурными скобками. Пространства имен образуют иерархию, так что внутри одного пространства имен можно определить любое число вложенных пространств. На самом верхнем уровне этой иерархии,по умолчанию,определено глобальное пространство имен. Доступ к элементам из этого пространства можно получать просто путем указания их имени. Имена элементов из других пространств должны обязательно квалифицироваться.
Квалифицированное имя — это такое имя, в котором содержится вся иерархическая информация, т.е. цепочка имен вложенных пространств на пути от глобального пространства к данному. Имена отдельных пространств в цепочке разделяются точками, например:
namespace LevelOne
{
// код в пространстве имен LevelOne
// определение имени "NameOne"
}
// код в глобальном пространстве имен
В этом коде определяется одно пространство имен — LevelOne — и одно имя в этом пространстве имен — NameOne (сам код не приводится для придания описанию общего характера, но зато приводится комментарий на том месте, где должно находиться определение). В коде, добавляемом внутри пространства имен LevelOne, на это имя можно ссылаться с использованием NameOne, т.е. квалифицировать его не обязательно.
В коде, добавляемом внутри глобального пространства имен, однако, на него обязательно нужно ссылаться с помощью квалифицированного имени LevelOne.NameOne.
Внутри любого пространства имен с использованием ключевого слова namespace можно определять и другие пространства имен, называемые в таком случае вложенными пространствами имен. Ссылаться на вложенные пространства имен нужно с применением информации об их иерархии и отделения каждого уровня иерархии символом точки. Лучше всего будет показать это на примере. Возьмем следующий код:
namespace LevelOne
{
// код в пространстве имен LevelOne
namespace LevelTwo
{
// код в пространстве имен LevelOne.LevelTwo
// определение имени "NameTwo"
}
}
// код в глобальном пространстве имен
Здесь на имя NameTwo нужно ссылаться в глобальном пространстве имен как LevelOne.LevelTwo.NameTwo, в пространстве имен LevelOne — LevelTwo.NameTwo, a в пространстве имен LevelOne. LevelTwo — NameTwo.
Главным тут является то, что пространства имен идентифицируют определяемые в них имена уникальным образом. Например, имя NameThree можно определить и в пространстве имен LevelOne и в пространстве имен LevelTwo:
namespace LevelOne
{
// определение имени "NameThree"
namespace LevelTwo
{
// определение имени "NameThree"
}
}
Это приведет к получению двух отдельных имен LevelOne.NameThree и LevelOne. LevelTwo.NameThree, которые можно будет использовать совершенно независимо друг от друга.
После создания пространств имен для упрощения доступа к содержащимся в них именам можно применять оператор using. С помощью этого оператора, по сути, заявляется следующее: "Далее будут нужны имена из этого пространства имен, поэтому не обязательно постоянно уточнять их". Например, следующий код указывает, что у кода в пространстве имен LevelOne должна быть возможность получать доступ к именам из пространства имен LevelOne. LevelTwo без уточнения:
namespace LevelOne
{
using LevelTwo;
namespace LevelTwo
{
// определение имени "NameTwo"
}
}
Благодаря этому, в коде пространства имен LevelOne ссылаться на LevelTwo.NameTwo можно будет с использованием просто NameTwo.
В некоторых случаях, однако, как и в приведенном выше примере с NameThree, такой подход может привести к появлению проблем из-за конфликтов между идентичными именами в разных пространствах имен (т.е. при использовании такого имени код не будет компилироваться — и компилятор будет выдавать сообщение, информирующее об отсутствии однозначности). В подобных случаях в операторе using можно указывать псевдоним (alias) пространства имен:
namespace LevelOne
{
using LT = LevelTwo;
// определение имени "NameThree"
namespace LevelTwo
{
// определение имени "NameThree"
}
}
Благодаря этому, в коде пространства имен LevelOne теперь на LevelOne.NameThree можно будет ссылаться как NameThree, а на LevelOne. LevelTwo.NameThree — LT.NameThree.
Действие операторов using распространяется как на те пространства имен, в которых они содержатся, так и на любые вложенные пространства имен, которые также могут содержаться в этих пространствах имен. Приведенный выше код не позволяет применять в глобальном пространстве имен LT.NameThree. Однако если бы оператор using в нем был объявлен следующим образом:
using LT = LevelOne.LevelTwo;
namespace LevelOne
{
// определение имени "NameThree"
namespace LevelTwo
{
// определение имени "NameThree"
}
}
тогда в коде глобального пространства имен и пространства имен LevelOne можно было бы использовать LT.NameThree.
Обратите внимание на еще один важный момент: сам по себе оператор using не предоставляет доступа к именам в другом пространстве имен. Если только код в пространстве имен не будет каким-то образом связан с проектом, например, его определением в файле исходного кода проекта или в другом связанном с проектом коде, доступа к содержащимся в нем именам не будет. Кроме того, в случае связывания содержащего пространство имен кода с проектом, доступ к его именам будет открыт вне зависимости от того, используется оператор using или нет. Оператор using просто упрощает получение доступа к этим именам и может сократить количество вводимого кода, делая его более удобным для чтения.
Теперь вернемся к приведенному в начале этой главы коду приложения ConsoleApplicationl с тремя следующими касающимися пространств имен строками:
using System;
using System.Collections.Generic;
using System.Text;
namespace ConsoleApplicationl
{
}
Здесь три строки, начинающиеся с ключевого слова using, применяются для объявления того, что в последующем коде С# будут использоваться пространства имен System, System.Collections.Generic, System.Text и что к ним нужно обращаться из всех пространств имен в данном файле без квалификации. Пространство имен System является корневым для приложений .NET Framework и содержит все базовые функциональные возможности, которые могут быть необходимы для создания консольных приложений. Два других пространства имен очень часто используются в консольных приложениях и потому указаны здесь просто так, на всякий случай.
И, напоследок, в четвертой строке, начинающейся с ключевого слова using, объявляется пространство имен под названием ConsoleApplicationl, предназначенное для кода самого приложения.
| <== предыдущая страница | | | следующая страница ==> |
| Базовый синтаксис С#. Структура программы | | | Система типов языка C#. Встроенные типы |
Дата добавления: 2014-10-10; просмотров: 491; Нарушение авторских прав
Мы поможем в написании ваших работ!