1.2 Переменные в C# (Csharp)

С# - Научиться или умереть

1.2 Переменные в C# (Csharp)

  Ну что ж, знать WriteLine() - очень хорошо, но если мы хотим сделать что-нибудь дельное, нам надо познакомиться с переменными. Из-за того, что они очень важны в работе любой программы, нам придется изрядно потрудиться. Но не надо вешать нос! То что мы выучим сегодня точно также работает и в Java, и в C++. Так что мы изучим такое, что приготся и в других языках!

  Переменная работает как хранилище, сосуд для информации. Зачем нам это надо? В общем, для гибкости. Мы можем вложить в нее любое значение, а потом использовать и изменять как душе угодно, да и когда душе угодно. Зачем писать код десятки раз, когда можно сделать это однажды и просто использовать одну переменную с нужными нам данными? Переменные особенно важны когда имеем дело с вводом данных извне и понадобится где-то хранить информацию, которую предоставил пользователь. Прежде чем войти в эту быструю реку, познакомимся с переменными поближе, узнаем как они работают. Смотрим:

string programmerName = "Dr.Acid";
Console.WriteLine("Эту статью написал " + programmerName + ".");

  Мдааа... Достаточно загадочно , нет? Как мы наверно уже догадались "string" ("строка") - это просто термин, который подразумевает текст ("строка" букв,если угодно). Код свыше должен выдать такой результат:

Эту статью написал Dr.Acid.

  Теперь, когда мы знаем с чем имеем дело, давайте внимательнее посмотрим на строку, где мы "объявили" переменную (кстати, говорю это впервые). Первое слово в строке, "string", говорит С# что мы создаем переменную строкового типа (да, есть переменные и другого, но это позже, а сейчас СКОНЦЕНТРИРУЙСЯ!) Второе слово, "programmerName"(" имяПрограммиста" в переводе) - имя нашей переменной. Имена могут быть разнообразной последовательностью букв,чисел и подчеркиваний. Если имя не начинается с цифры, или содержит знаки пунктуации кроме подчеркивания, это правильные имена. Очевидно, что необходимо сделать имя переменой как можно более полезной, например своим именем указать на содержание. То есть в данном случае "programmerName" - отличное имя для переменной, а "engineOil"("Машинное масло" в переводе) - нет.

  Знак "=" говорит С# что мы хотим присвоить нашей переменной значение, а текст в кавычках - само значение. Теперь С# знает что надо вставить слово "Dr.Acid" везде где используется переменная programmerName. Изменение значения переменной не сложнее изменения текста в кавычках.

  Еще мы можем копировать значение переменной, сделав ее "равной" другой переменной того же типа. Например:

string coolProgrammer = programmerName;

  "programmerName" уже имеет значение - "Dr.Acid". Как только этот код выполнится, "coolProgrammer" ("крутойПрограммист") тоже будет иметь значение "Dr.Acid". Мы в любое время можем изменить значение переменной, используя оператор присваивания "=" …

coolProgrammer = " Ты";

  Теперь "coolProgrammer" имеет значение "Ты" (Знаю,знаю подхалимство ничего хорошего не даст). Заметим, что мы не использовали ключевое слово "String" в начале строки. Это потому что мы уже "объявили" coolProgrammer как переменную строкового типа, немного раньше. Нужно указывать тип переменной в самый первый раз, когда упоминаем о ней, а если попытаемся объявить ее по новой, С# злостно накричит на нас. Заметим, что совсем не обязательно сразу же давать переменной значение. Следующий пример абсолютно легален:

string profession;
profession = "плотник";

  Просто надо запомнить что мы не имеем права использовать переменные где-либо в коде до тех пор, пока не дадим им значение. Ну что ж, хватит наверно про строки. Давайте сохранять числа! Смотрим:

int headCount = 29;
Console.WriteLine("В аудитории " + headCount + " человек.");

  "int" - это целое число, безо всяких десятичных дробей. Они идеальны в ситуациях, где дробные числа не нужны(вести подсчет людей в дробях довольно неудобно, да и кто хочет кругом были их части?) Как видно, выводить их в консоль можно также как и переменные строкового типа.

  Можно даже конвертировать строки в целые, но нужно быть осторожным! Операция сработает только если ВСЯ строка представляет из себя целое. Например, "10","-412",и "38899" все без проблем сконвертируются в целые. А вот "мяу", "-34-", и даже "100 мяу" - нет. А если операция конверсии провалится, в программе возникнет фатальная ошибка и она вылетит: без извинений, без предупреждений, как снег на голову... Позже мы научимся справляться и с этим, а пока нужно просто быть осторожным с конвертированием строк в целые. Вот как мы это делаем:

string someNumberText = "123";
int convertedNumber = Convert.ToInt32(someNumberText);
Console.WriteLine("Я получил число " + convertedNumber + " из строки!");

  Также нам ничего не стоит сконвертировать переменную любого типа в строоковый, используем метод ToString() . Смотрим:

string convertedString = convertedNumber.ToString();
Console.WriteLine("Я получил эту строку из переменной целого типа: " + convertedString);

  Фактически каждый тип имеет метод ToString(), который значительно облегчает конвертацию чисел в строки. Пока что это нам может и не понадобится, но запомнить это надо. Хорошо запомнить! Конечно, не каждое число можно представить как гладковыбритое целое. Часто нам нужно использовать дробные числа, знакомтесь :

double height = 35.5;
Console.WriteLine("Высота равна: " + height);

  Мы используем тип "double"("двойной") чтобы иметь под рукой дроби.(Изначально это назвали "double" потому, что памяти занимает вдвое больше, чем "int". Все просто!) Ах, да, есть еще и метод Convert.ToDouble() , для того чтобы получать дробные числа из строк. Работает так же как и для целых. Кстати, а что если нам надо присвоить целое значение в переменную типа "double"? Ну, грубо говоря, "int" - это "double", содержащий меньше информации... Так что это не сложнее чем:

int integerHeight = 40;
height = integerHeight;
Console.WriteLine("Теперь высота равна: " + height);

  Как видим, можно без проблем "вставлять" целые значения в двойные. А вот присваивание значения double переменной целого типа не так-то и просто. Так как INTы содержат только целые значения, любая дробная информация двойной переменной будет утеряна при присваивании ее INTу. С# обычно не "любит" делать этого, поэтому мы должны указать программе, что все в порядке. Заметим, что С# не позаботится о том, чтобы округлить нашу дробь до близжайшего целого (если не заставим, а об этом позже). Просто все дробные значения будут "выброшены" из числа.

height = 32.953;
integerHeight = (int)height;
Console.WriteLine("Целая height теперь равна: " + integerHeight);

  (int) просто говорит С# :"Говорю тебе - это целая!" Существует две разновидности double - "float" и "decimal". "float"ы менее точные, а "decimal"ы невероятно точные. Нужно использовать явные преобразования ( (int) в нашем примере) для того чтобы передавать значения между переменными этих типов: double, float и decimal. Чаще всего можно увидеть "float"ы в изобразительных командах(координаты и т.д.), тогда как "decimal"ы используются там, где требуется абсолютная точность, например действия с деньгами. Не надо внушать себе что надо везде использовать "decimal"ы из-за их точности. Скорость и эффективность - важнейшие элемты программы, поэтому не надо содержать информацию в числе, где после запятой 100,000 цифр, когда можно обойтись и 1,000. Фактически, мы не будем иметь дело с "float" и "decimal" довольно долго.
А теперь позабавимся. Следующий код прикольно читать?

Console.WriteLine("Имя - " + programmerName + ", высота - " + height + ", кол-во - " + headCount);

  Если ответ "да", то это вранье. На самом деле эта строка достаточно сложна. Нужно разбираться, что там такое творится между всеми этими плюсами. Разве не было бы учше иметь целое, "ненарезанное" сообщение и отбросить всю возню с переменными в конец? Может даже вот так?

Console.WriteLine("Имя - {0}, высота - {1}, кол-во - {2}", programmerName, height, headCount);

  Этот код даст тот же резултат, что и предидущий, но просто мы откладываем указание переменных на конец. Все что нужно сделать - это вставить указатели на переменные там, где нам нужно их видеть, а потом, в конце, прописать все переменные в правильном порядке. {0} указаывает на первую переменную из списка,который мы указали в конце, {1} - вторую и т.д.(отсчет начинается с 0). А количество вот таких "вставок" практически бесконечно!
  Ну ладно, еще пару трюков и на сегодня хватит. Можно одновременно объявить сразу несколько переменных. Вот так:

int a, b, c, d;

...а также можно присвоить одно значение сразу нескольким переменным. Смотрим:

a = b = c = d = 100;

  Ну вот и все... Конечно, это все очень хорошо - переменные всякие... Но программа будет выдавать один и тот же результат при каждом запуске, до тех пор, пока программист не изменит начальный код. Время учиться обрабатывать данные, введенные пользователем... Но сначала пример кода:

using System;

namespace B_Variables
{
  class Class1
  {
    [STAThread]
    static void Main(string[] args)
    {
      // объявляем строковую переменную, присваиваем ей значение
      string programmerName = "Dr.Acid";
      Console.WriteLine("Эту статью написал " + programmerName + ".");

      // копируем значение одной переменной в другую
      string coolProgrammer = programmerName;
      Console.WriteLine(coolProgrammer + " is a cool programmer!");

      // Объявляем целое
      int headCount = 29;
      Console.WriteLine("В аудитории " + headCount + " человек.");

      // переводим строку в число
      string someNumberText = "123";
      int convertedNumber = Convert.ToInt32(someNumberText);
      Console.WriteLine("Я получил число " + convertedNumber + " из строки!");


      // переводим число в строку
      string convertedString = convertedNumber.ToString();
Console.WriteLine("Я получил эту строку из переменной целого типа: " + convertedString);

      // объявляем дробную переменную
      double height = 25.8;
      Console.WriteLine("Высота равна: " + height);

      // еще можем в любое время изменить значение переменной 
      height = 58.32;
      Console.WriteLine("Теперь высота равна: " + height);

      // придаем дробной переменной целое значение
      int integerHeight = 40;
      height = integerHeight;
      Console.WriteLine("Теперь высота равна: " + height);

      // придаем целой переменной дробное значение (указываем)
      height = 32.953;
      integerHeight = (int)height;
      Console.WriteLine("Теперь высота равна (целое) : " + integerHeight);

      // можно использовать сколько угодно переменных при выводе информации

      // Уродливый вид
      Console.WriteLine("Имя - " + programmerName + ", высота - " + height + ", кол-во - " + headCount);

      // Красивый вид
      Console.WriteLine("Имя - {0}, высота - {1}, кол-во - {2}", programmerName, height, headCount);

      // объявляем несколько переменных
      int a, b, c, d;

      // присваиваем значение нескольким переменным
      a = b = c = d = 100;
      Console.WriteLine("a={0}, b={1}, c={2}, d={3}", a, b, c, d);

      // Заставим программу подождать пока пользователь не нажмет "Enter"
      Console.ReadLine();
    }
  }
}

В данной статье был использован материал из цикла "Professor Mustard Lessons - Learn C# or Die Trying"