Эндрю Троелсен - ЯЗЫК ПРОГРАММИРОВАНИЯ С# 2005 И ПЛАТФОРМА .NET 2.0. 3-е издание
Замечание. В главе 4 будет говориться о вложенных типах. Вы узнаете, что вложенные типы тоже могут быть объявлены, как приватные.
Значения, назначаемые переменным по умолчанию
Членам-переменным классов автоматически присваиваются подходящие значения, предусмотренные по умолчанию. Эти значения для каждого типа данных, свои, но правила их выбора достаточно просты:
• для типа bool устанавливается значение false;
• числовым данным присваивается значение 0 (или 0.0, если это данные с плавающим разделителем);
• для типа string устанавливается значение null;
• для типа char устанавливается значение ' ';
• для ссылочных типов устанавливается значение null.
С учетом этих правил проанализируйте следующий программный код.
// Поля типа класса получают значения по умолчанию.
class Test {
public int myInt; // Устанавливается равным 0.
public string myString; // Устанавливается равным null.
public bool myBool; // Устанавливается равным false.
public object myObj; // Устанавливается равным null.
}
Значения, назначаемые по умолчанию, и локальные переменные
Совсем по-другому обстоит дело тогда, когда объявляются локальные переменные, видимые в пределах данного члена. При определении локальной переменной вы должны назначить ей начальное значение, прежде чем начать ее использование, поскольку такая перемен наяне не получает начального значения по умолчанию. Например, следующий программный код приведет к ошибке компиляции,
// Ошибка компиляции! Переменная 'localInt' должна получить
// начальное значение до ее использования.
static void Main(string[] args) {
int localInt;
Console.WriteLine(localInt);
}
Исправить проблему очень просто. Следует присвоить переменной начальное значение.
// Так лучше: теперь все довольны.
static void Main(string[] args) {
int localInt = 0;
Console.WriteLine(localInt);
}
Замечание. Правило обязательного присваивания начальных значений локальным переменным имеет одно исключение: если переменная используется в качестве выходного параметра (это понятие будет рассмотрено немного позже), то устанавливать начальное значение такой переменной не требуется.
Синтаксис инициализации членов-переменных
Типы класса обычно имеют множество членов-переменных (также называемых полями). Если в классе можно определять множество конструкторов, то может возникнуть не слишком радующая программиста необходимость многократной записи одного и того же программного кода инициализации для каждой новой реализации конструктора. Это вполне реально, например, в том случае, когда вы не хотите принимать значение члена, предусмотренное по умолчанию. Так, чтобы член-переменная (myInt) целочисленного типа всегда инициализировался значением 9, вы можете записать следующее.
// Все это хорошо, но такая избыточность…
class Test {
public int myInt;
public string myString;
public Test() {myInt = 9;}
public Test(string s) {
myInt = 9;
myString = s;
}
}
Альтернативой может быть определение вспомогательной функции, вызываемой всеми конструкторами. При этом уменьшается общее число повторений для операции присваивания, но теперь возникает следующая избыточность,
// Все равно остается избыточность…
class Test {
public int myInt;
public string myString;
public Test() {InitData();}
public Test(string s) {
myString = s;
InitData();
}
private void InitData() {myInt = 9;}
}
Оба эта подхода вполне легитимны, но в C# позволяется назначать членам типа начальные значения в рамках деклараций (вы, наверное, знаете, что другие объектно-ориентированные языки [например, C++], не позволяют такую инициализацию членов). В следующем фрагменте программного кода обратите внимание на то, что инициализация может выполняться и для внутренних объектных ссылок, а не только для числовых типов данных.
// Если нужно отказаться от значений, предусмотренных по умолчанию,
// эта техника позволяет избежать повторной записи программного
// хода инициализации в каждом конструкторе.
class Test {
public int myInt = 9;
public string myStr = "Мое начальное значение. ";
public SportsCar viper = new SportsCar(Color.Red);
...
}
Замечание. Инициализация членов выполняется до выполнения программной логики конструктора. Если присвоить значение полю в самом конструкторе, это сведет на нет инициализацию члена.
Определение констант
Итак, вы знаете, как объявить переменные класса. Теперь давайте выясним, как определить данные, изменить которые не предполагается. Для определения переменных с фиксированным, неизменяемым значением в C# предлагается ключевое слово const. После определения значения константы любая попытка изменить это значение приводит к ошибке компиляции. В отличие От C++, в C# ключевое слово const нельзя указывать для параметров и возвращаемых значений – оно предназначено для создания локальных данных и данных уровня экземпляра.
Важно понимать, что значение, присвоенное константе, во время компиляции уже должно быть известно, поэтому константу нельзя инициализировать объектной ссылкой (значение последней вычисляется в среде выполнения). Чтобы проиллюстрировать использование ключевого слова const, рассмотрим следующий тип класса.
class ConstData {
// Значение, присваиваемое константе, должно быть известно во время компиляции.
public const string BestNbaTeam = "Timberwolves";
public const double SimplePI = 3.14;
public const bool Truth = true;
public const bool Falsity = !Truth;
}
Обратите внимание на то, что значения всех констант известны во время компиляции. И действительно, если просмотреть эти константы с помощью ildasm.exe, то вы обнаружите, что их значения будут "жестко" вписаны в компоновочный блок, как показано на рис. 3.8. (Ничего более постоянного получить невозможно!)
Рис. 3.8. Ключевое слово const вписывает "свое" значение прямо в метаданные компоновочного блока
Ссылки на константы
Если нужно сослаться на константу, определенную внешним типом, вы должны добавить префикс имени типа (например, ConstData.Truth), поскольку поля-константы являются неявно статическими. Однако при ссылке на константу, определенную в рамках текущего типа (или в рамках текущего члена), указывать префикс имени типа не требуется. Чтобы пояснить это, рассмотрим следующий класс.
class Program {
public const string BestNhlTeam = "Wild";
static void Main(string[] args) {
// Печать значений констант, определенных другими типами.
Console.WriteLine("Константа Nba: {0}", ConstData.BestNbaTeam);
Console.WriteLine("Константа SimplePI: {0}", ConstData.SimplePI);
Console.WriteLine("Константа Truth: {0}", ConstData.Truth);
Console.WriteLine("Константа Falsity: {0}", ConstData.Falsity);
// Печать значений констант члена.
Console.WriteLine("Константа Nhl: {0}", BestNhlTeam);
// Печать значений констант локального уровня.
const int LocalFixedValue = 4;
Console.WriteLine("Константа Local: {0}", LocalFixedValue);
Console.ReadLine();
}
}
Обратите внимание на то, что для доступа к константам класса ConstData необходимо указать имя типа. Однако класс Program имеет прямой доступ к константе BestNhlTeam, поскольку она была определена в пределах собственной области видимости класса. Константа LocalFixedValue, определенная в Main(), конечно же, должна быть доступной только из метода Main().
Исходный код. Проект Constants размещен в подкаталоге, соответствующем главе 3.
Определение полей только для чтения
Как упоминалось выше, значение, присваиваемое константе, должно быть известно во время компиляции. Но что делать, если нужно создать неизменяемое поле, начальное значение которого будет известно только в среде выполнения? Предположим, что вы создали класс Tire (покрышка), в котором обрабатывается значение ID (идентификатор) производителя. Кроме того, предположим, что вы хотите сконфигурировать этот тип класса так, чтобы в нем поддерживалась пара известных экземпляров Tire, чьи значения не должны изменяться. Если использовать ключевое слово const, вы получите ошибку компиляции, поскольку адрес объекта в памяти становится известным только в среде выполнения.
