Герберт Шилдт - C# 4.0 полное руководство - 2011

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

В C# определено несколько различных видов переменных. Так, в предыдущих примерах программ использовались переменные, называемые локальными , поскольку они объявляются внутри метода.

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

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

тип имя_переменной = значение;

где зна чение — это конкретное значение, задаваемое при создании переменной. Оно должно соответствовать указанному типу переменной.

Ниже приведены некоторые примеры инициализации переменных.

int count = 10; // задать начальное значение 10 переменной count.

char ch = 'X'; // инициализировать переменную ch буквенным значением X.

float f = 1.2F // переменная f инициализируется числовым значением 1,2.

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

int a, b=8, с=19, d; // инициализировать переменные b и с

В данном примере инициализируются только переменные b и с.

Динамическая инициализация

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

// Продемонстрировать динамическую инициализацию.

using System;

class Dynlnit {

static void Main() {

// Длина сторон прямоугольного треугольника. double si = 4.0; double s2 = 5.0;

// Инициализировать переменную hypot динамически, double hypot = Math.Sqrt( (si * si) + (s2 * s2) );

Console.Write("Гипотенуза треугольника со сторонами " + si + " и " + s2 + " равна ");

Console.WriteLine("{0:#.###}.", hypot);

}

}

Результат выполнения этой программы выглядит следующим образом.

Гипотенуза треугольника со сторонами 4 и 5 равна 6.403

В данном примере объявляются три локальные переменные: si, s2 и hypot. Две из них (si и s2) инициализируются константами, А третья (hypot) динамически инициализируется вычисляемой длиной гипотенузы. Для такой инициализации используется выражение, указываемое в вызываемом методе Math . Sqrt (). Как пояснялось выше, для динамической инициализации пригодно любое выражение, действительное на момент объявления переменной. А поскольку вызов метода Math. Sqrt () (или любого другого библиотечного метода) является действительным на данный момент, то его можно использовать для инициализации переменной hypot. Следует особо подчеркнуть, что в выражении для инициализации можно использовать любой элемент, действительный на момент самой инициализации переменной, в том числе вызовы методов, другие переменные или литералы.

Неявно типизированные переменные

Как пояснялось выше, все переменные в C# должны быть объявлены. Как правило, при объявлении переменной сначала указывается тип, например int или bool, а затем имя переменной. Но начиная с версии C# 3.0, компилятору предоставляется возможность самому определить тип локальной переменной, исходя из значения, которым она инициализируется. Такая переменная называется неявно типизированной.

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

var е = 2.7183;

В данном примере переменная е инициализируется литералом с плавающей точкой, который по умолчанию имеет тип double, и поэтому она относится к типу double. Если бы переменная е была объявлена следующим образом:

var е = 2.7183F;

то она была бы отнесена к типу float.

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

// Продемонстрировать применение неявно типизированных переменных, using System;

class ImplicitlyTypedVar { static void Main() {

// Эти переменные типизированы неявно. Они отнесены // к типу double, поскольку инициализирующие их // выражения сами относятся к типу double, var si = 4.0; var s2 = 5.0;

// Итак, переменная hypot типизирована неявно и // относится к типу double, поскольку результат,

// возвращаемый методом Sqrt(), имеет тип double, var hypot = Math.Sqrt( (si * si) + (s2 * s2) );

Console.Write("Гипотенуза треугольника со сторонами " + si + " by " + s2 + " равна ");

Console.WriteLine("{0:#.###}.", hypot);

// Следующий оператор не может быть скомпилирован,

// поскольку переменная si имеет тип double и // ей нельзя присвоить десятичное значение.

// si = 12.2М; // Ошибка!

}

}

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

// si = 12.2М; // Ошибка!

Эта операция присваивания недействительна, поскольку переменная s 1 относится к типу double. Следовательно, ей нельзя присвоить десятичное значение. Единственное отличие неявно типизированной переменной от обычной, явно типизированной переменной, — в способе определения ее типа. Как только этот тип будет определен, он закрепляется за переменной до конца ее существования. Это, в частности, означает, что тип переменной s 1 не может быть изменен по ходу выполнения программы.