Книга: C# 4.0: полное руководство

Более подробное рассмотрение переменных

Более подробное рассмотрение переменных

Переменные объявляются с помощью оператора следующей формы:

тип имя_переменной;

где тип — это тип данных, хранящихся в переменной; а имя_переменной — это ее имя. Объявить можно переменную любого действительного типа, в том числе и описанных выше типов значений. Важно подчеркнуть, что возможности переменной определяются ее типом. Например, переменную типа bool нельзя использовать для хранения числовых значений с плавающей точкой. Кроме того, тип переменной нельзя изменять в течение срока ее существования. В частности, переменную типа int нельзя преобразовать в переменную типа char.

Все переменные в 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 s1 = 4.0;
    double s2 = 5.0;
    // Инициализировать переменную hypot динамически,
    double hypot = Math.Sqrt( (s1 * s1) + (s2 * s2) );
    Console.Write("Гипотенуза треугольника со сторонами "
             + s1 + " и " + s2 + " равна ");
    Console.WriteLine("{0:#.###}.", hypot);
  }
}

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

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

В данном примере объявляются три локальные переменные: s1, s2 и hypot. Две из них (s1 и 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 s1 = 4.0;
    var s2 = 5.0;
    //Итак, переменная hypot типизирована неявно и
    // относится к типу double, поскольку результат,
    // возвращаемый методом Sqrt(), имеет тип double,
    var hypot = Math.Sqrt((s1 * s1) + (s2 * s2));
    Console.Write("Гипотенуза треугольника со сторонами "
             + s1 + " by " + s2 + " равна ");
    Console.WriteLine("{0:#.###}.", hypot);
    // Следующий оператор не может быть скомпилирован,
    // поскольку переменная s1 имеет тип double и
    // ей нельзя присвоить десятичное значение.
    // s1 = 12.2М; // Ошибка!
  }
}

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

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

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

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

И последнее замечание: одновременно можно объявить только одну неявно типизированную переменную. Поэтому объявление

var s1 =4.0, s2=5.0; // Ошибка!

является неверным и не может быть скомпилировано. Ведь в нем предпринимается попытка объявить обе переменные, s1 и s2, одновременно.

Оглавление книги


Генерация: 4.502. Запросов К БД/Cache: 3 / 1
поделиться
Вверх Вниз