Когда нужно объявлять переменные

Переменные

JavaScript-приложению обычно нужно работать с информацией. Например:

1. Интернет-магазин – информация может включать продаваемые товары и корзину покупок.
2. Чат – информация может включать пользователей, сообщения и многое другое.

Переменные используются для хранения этой информации.

Переменная

Переменная – это «именованное хранилище» для данных. Мы можем использовать переменные для хранения товаров, посетителей и других данных.

Для создания переменной в JavaScript используйте ключевое слово let .

Приведённая ниже инструкция создаёт (другими словами, объявляет) переменную с именем «message»:

let message;

Теперь можно поместить в неё данные (другими словами, определить переменную), используя оператор присваивания = :

let message; message = 'Hello'; // сохранить строку 'Hello' в переменной с именем message

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

let message; message = 'Hello!'; alert(message); // показывает содержимое переменной

Для краткости можно совместить объявление переменной и запись данных в одну строку:

let message = 'Hello!'; // определяем переменную и присваиваем ей значение alert(message); // Hello!

Мы также можем объявить несколько переменных в одной строке:

let user = 'John', age = 25, message = 'Hello';

Такой способ может показаться короче, но мы не рекомендуем его. Для лучшей читаемости объявляйте каждую переменную на новой строке.

Многострочный вариант немного длиннее, но легче для чтения:

let user = 'John'; let age = 25; let message = 'Hello';

Некоторые люди также определяют несколько переменных в таком вот многострочном стиле:

let user = 'John', age = 25, message = 'Hello';

…Или даже с запятой в начале строки:

let user = 'John' , age = 25 , message = 'Hello';

В принципе, все эти варианты работают одинаково. Так что это вопрос личного вкуса и эстетики.

var вместо let

В старых скриптах вы также можете найти другое ключевое слово: var вместо let :

var message = 'Hello';

Ключевое слово var – почти то же самое, что и let . Оно объявляет переменную, но немного по-другому, «устаревшим» способом.

Есть тонкие различия между let и var , но они пока не имеют для нас значения. Мы подробно рассмотрим их в главе Устаревшее ключевое слово «var».

Аналогия из жизни

Мы легко поймём концепцию «переменной», если представим её в виде «коробки» для данных с уникальным названием на ней.

Например, переменную message можно представить как коробку с названием «message» и значением «Hello!» внутри:

Мы можем положить любое значение в коробку.

Мы также можем изменить его столько раз, сколько захотим:

let message; message = 'Hello!'; message = 'World!'; // значение изменено alert(message);

При изменении значения старые данные удаляются из переменной:

Мы также можем объявить две переменные и скопировать данные из одной в другую.

let hello = 'Hello world!'; let message; // копируем значение 'Hello world' из переменной hello в переменную message message = hello; // теперь две переменные содержат одинаковые данные alert(hello); // Hello world! alert(message); // Hello world!

Повторное объявление вызывает ошибку

Переменная может быть объявлена только один раз.

Повторное объявление той же переменной является ошибкой:

let message = "Это"; // повторение ключевого слова 'let' приводит к ошибке let message = "Другое"; // SyntaxError: 'message' has already been declared

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

Функциональные языки программирования

Примечательно, что существуют функциональные языки программирования, такие как Scala или Erlang, которые запрещают изменять значение переменной.

В таких языках однажды сохранённое «в коробку» значение остаётся там навсегда. Если нам нужно сохранить что-то другое, язык заставляет нас создать новую коробку (объявить новую переменную). Мы не можем использовать старую переменную.

Хотя на первый взгляд это может показаться немного странным, эти языки вполне подходят для серьёзной разработки. Более того, есть такая область, как параллельные вычисления, где это ограничение даёт определённые преимущества. Изучение такого языка (даже если вы не планируете использовать его в ближайшее время) рекомендуется для расширения кругозора.

Имена переменных

В JavaScript есть два ограничения, касающиеся имён переменных:

1. Имя переменной должно содержать только буквы, цифры или символы $ и _ .
2. Первый символ не должен быть цифрой.

Примеры допустимых имён:

let userName; let test123;

Если имя содержит несколько слов, обычно используется верблюжья нотация, то есть, слова следуют одно за другим, где каждое следующее слово начинается с заглавной буквы: myVeryLongName .

Самое интересное – знак доллара ‘$’ и подчёркивание ‘_’ также можно использовать в названиях. Это обычные символы, как и буквы, без какого-либо особого значения.

Эти имена являются допустимыми:

let $ = 1; // объявили переменную с именем "$" let _ = 2; // а теперь переменную с именем "_" alert($ + _); // 3

Примеры неправильных имён переменных:

let 1a; // не может начинаться с цифры let my-name; // дефис '-' не разрешён в имени

Регистр имеет значение

Переменные с именами apple и APPLE – это две разные переменные.

Нелатинские буквы разрешены, но не рекомендуются

Можно использовать любой язык, включая кириллицу или даже иероглифы, например:

let имя = '. '; let 我 = '. ';

Технически здесь нет ошибки, такие имена разрешены, но есть международная традиция использовать английский язык в именах переменных. Даже если мы пишем небольшой скрипт, у него может быть долгая жизнь впереди. Людям из других стран, возможно, придётся прочесть его не один раз.

Зарезервированные имена

Существует список зарезервированных слов, которые нельзя использовать в качестве имён переменных, потому что они используются самим языком.

Например: let , class , return и function зарезервированы.

Приведённый ниже код даёт синтаксическую ошибку:

let let = 5; // нельзя назвать переменную "let", ошибка! let return = 5; // также нельзя назвать переменную "return", ошибка!

Создание переменной без использования use strict

Обычно нам нужно определить переменную перед её использованием. Но в старые времена было технически возможно создать переменную простым присвоением значения без использования let . Это все ещё работает, если мы не включаем use strict в наших файлах, чтобы обеспечить совместимость со старыми скриптами.

// заметка: "use strict" в этом примере не используется num = 5; // если переменная "num" раньше не существовала, она создаётся alert(num); // 5

Это плохая практика, которая приводит к ошибке в строгом режиме:

"use strict"; num = 5; // ошибка: num is not defined

Константы

Чтобы объявить константную, то есть, неизменяемую переменную, используйте const вместо let :

const myBirthday = '18.04.1982';

Переменные, объявленные с помощью const , называются «константами». Их нельзя изменить. Попытка сделать это приведёт к ошибке:

const myBirthday = '18.04.1982'; myBirthday = '01.01.2001'; // ошибка, константу нельзя перезаписать!

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

Константы в верхнем регистре

Широко распространена практика использования констант в качестве псевдонимов для трудно запоминаемых значений, которые известны до начала исполнения скрипта.

Названия таких констант пишутся с использованием заглавных букв и подчёркивания.

Например, сделаем константы для различных цветов в «шестнадцатеричном формате»:

const COLOR_RED = "#F00"; const COLOR_GREEN = "#0F0"; const COLOR_BLUE = "#00F"; const COLOR_ORANGE = "#FF7F00"; // . когда нам нужно выбрать цвет let color = COLOR_ORANGE; alert(color); // #FF7F00

• COLOR_ORANGE гораздо легче запомнить, чем «#FF7F00» .
• Гораздо легче допустить ошибку при вводе «#FF7F00» , чем при вводе COLOR_ORANGE .
• При чтении кода COLOR_ORANGE намного понятнее, чем #FF7F00 .

Когда мы должны использовать для констант заглавные буквы, а когда называть их нормально? Давайте разберёмся и с этим.

Название «константа» просто означает, что значение переменной никогда не меняется. Но есть константы, которые известны до выполнения (например, шестнадцатеричное значение для красного цвета), а есть константы, которые вычисляются во время выполнения сценария, но не изменяются после их первоначального назначения.

const pageLoadTime = /* время, потраченное на загрузку веб-страницы */;

Значение pageLoadTime неизвестно до загрузки страницы, поэтому её имя записано обычными, а не прописными буквами. Но это всё ещё константа, потому что она не изменяется после назначения.

Другими словами, константы с именами, записанными заглавными буквами, используются только как псевдонимы для «жёстко закодированных» значений.

Придумывайте правильные имена

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

Название переменной должно иметь ясный и понятный смысл, говорить о том, какие данные в ней хранятся.

Именование переменных – это один из самых важных и сложных навыков в программировании. Быстрый взгляд на имена переменных может показать, какой код был написан новичком, а какой – опытным разработчиком.

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

Пожалуйста, потратьте время на обдумывание правильного имени переменной перед её объявлением. Делайте так, и будете вознаграждены.

Несколько хороших правил:

• Используйте легко читаемые имена, такие как userName или shoppingCart .
• Избегайте использования аббревиатур или коротких имён, таких как a , b , c , за исключением тех случаев, когда вы точно знаете, что так нужно.
• Делайте имена максимально описательными и лаконичными. Примеры плохих имён: data и value . Такие имена ничего не говорят. Их можно использовать только в том случае, если из контекста кода очевидно, какие данные хранит переменная.
• Договоритесь с вашей командой об используемых терминах. Если посетитель сайта называется «user», тогда мы должны называть связанные с ним переменные currentUser или newUser , а не, к примеру, currentVisitor или newManInTown .

Звучит просто? Действительно, это так, но на практике для создания описательных и кратких имён переменных зачастую требуется подумать. Действуйте.

Повторно использовать или создавать новую переменную?

И последняя заметка. Есть ленивые программисты, которые вместо объявления новых переменных повторно используют существующие.

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

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

Дополнительная переменная – это добро, а не зло.

Современные JavaScript-минификаторы и браузеры оптимизируют код достаточно хорошо, поэтому он не создаёт проблем с производительностью. Использование разных переменных для разных значений может даже помочь движку оптимизировать ваш код.

Итого

Мы можем объявить переменные для хранения данных с помощью ключевых слов var , let или const .

• let – это современный способ объявления.
• var – это устаревший способ объявления. Обычно мы вообще не используем его, но мы рассмотрим тонкие отличия от let в главе Устаревшее ключевое слово «var» на случай, если это всё-таки вам понадобится.
• const – похоже на let , но значение переменной не может изменяться.

Переменные должны быть названы таким образом, чтобы мы могли легко понять, что у них внутри.

Задачи

Работа с переменными

важность: 2

1. Объявите две переменные: admin и name .
2. Запишите строку «Джон» в переменную name .
3. Скопируйте значение из переменной name в admin .
4. Выведите на экран значение admin , используя функцию alert (должна показать «Джон»).

В коде ниже каждая строка решения соответствует одному элементу в списке задач.

let admin, name; // можно объявить две переменные через запятую name = "Джон"; admin = name; alert( admin ); // "Джон"

Что такое переменная в программировании

Переменная (от англ. variable) — поименованная или адресуемая иным способом область памяти, которую можно использовать для доступа к данным. Звучит сложно и пугающе, не правда ли? Однако на практике такое определение вашему ребенку не потребуется. По крайней мере, на начальных этапах изучения программирования.

Переменная простыми словами — это хранилище данных. Сюда можно положить какое-то значение (например, число, строку или другой тип данных). Еще более простой вариант представить себе переменную — подумать о том, что нас окружает. Например, переменной может быть какой-то небольшой мешочек, куда можно положить, к примеру, яблоко. Оно будет там находиться до тех пор, пока мы не решим произвести с яблоком какие-то действия.

Переменную в любой программе необходимо объявлять. То есть достать этот мешочек перед тем, как положить в него яблоко. В современных приложениях переменных может быть сколько угодно много. Например, в одном мешочке хранится яблоко, в другом — конфета.

Зачем нужны переменные и как они работают

В переменных хранятся определенные данные, которые можно впоследствии использовать в программе. Для того, чтобы переменная появилась, необходимо ее объявить (зарезервировать ячейку памяти под определенные данные). В разных языках переменные объявляются по-разному в зависимости от синтаксиса. Где-то это может быть слово «var», где-то «let». Существуют также неизменяемые переменные, которые задаются только раз и объявляются словом «const».

Переменные в программе нужны не только для хранения данных, но и для различных операций с ними. Например, можно создать простой калькулятор, используя всего три переменные — a, b и c. Как это будет работать? Не углубляясь в тонкости синтаксиса каждого отдельно взятого языка программирования, покажем простой пример:

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

Кстати, данные можно записывать сразу в программе. Если взять наш пример выше, вместо латинских букв мы можем сразу же использоваться цифры. Например, 1+2 = 3. Однако в этом случае программа, которую вы напишете, не будет обладать должной гибкостью. То есть можно посчитать в ней только заданные значения и для того, чтобы что-то изменить, каждый раз придется в коде писать новые числа и только тогда мы получим другой результат.

Переменные позволяют добавить гибкости приложению. То есть мы сами можем менять их значения и каждый раз получать необходимые результаты без вмешательства в код программы.

Переменные в Scratch

При работе с средой разработки Scratch также используются переменные. Здесь есть отдельный раздел, где может их создавать. При нажатии на специальную кнопку, у нас появится окно, где можно задавать имя и значение переменной. Также, в Scratch есть возможность определения области видимости, то есть будет ли переменная доступна только одному спрайту или всем.

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

А если планируется использование переменных в разных областях видимости (спрайтах), здесь допустимо использование одинаковых имен.

Как называть переменные? Можно просто латинскими буквами. Однако наиболее популярный и эффективный вариант — описательное именование, чтобы мы, работая с кодом в будущем, могли знать, какое именно значение в переменной и что туда «положить» в случае, если планируются такие действия. При обучении через скретч лучше сразу пользоваться английскими названиями переменных. Дело в том, что во взрослом программировании весь код пишется исключительно на английском и в будущем, если ребенок в будущем будет работать с иностранными компаниями, ему придется изучить этот язык.

Например, у нас есть переменная, в которую заносятся какие-то животные. Ее можно назвать «Zhivotnye», но лучше сразу писать «Animals».

Для чего можно использовать переменные в Scratch? В целом, для любой программы, которую мы здесь пишем. Например, у нас есть два персонажа, и они должны двигаться по экрану. Мы можем задать им скорость вручную, а можем внести эти данные в переменную и затем менять скорость одновременно для обоих персонажей. Это будет более эффективно.

Помимо скорости, в качестве переменных могут выступать и другие динамические параметры, например, количество шагов. И это далеко не все возможности.

Выводы

Переменная — это основа для любого языка программирования. Она необходима для оперативного доступа к данным и манипулирования с ними. На уроках в ProgKids ваш ребенок более глубоко познакомится с переменными и узнает о том, как они применяются на практике.

Как объявить переменную в Java? Инициализация переменной в Java. Константы в Java

В этой статье мы рассмотрим, что такое Java-переменные, что значит инициализация переменных, а также как объявлять константу и зачем вообще нужны переменные и константы в Java.

Переменная — это контейнер, содержащий какое-либо значение. При этом под переменным значением понимают строковое, числовое или логическое значение. Само определение говорит нам о том, что переменная может изменяться по ходу выполнения программы. А вот если у нас задана константа, то это значение меняться не может. Но давайте обо всём по порядку.

Виды переменных в Java

Существуют следующие типы переменных в Java: 1) примитивные (целые — byte, short, char, int, long; дробные или с плавающей точкой — float, double, логические — boolean); 2) ссылочные (создаются с применением конструкторов классов и нужны для доступа к объектам).

Так как Java является строго типизированным языком программирования, каждая переменная, объявляемая разработчиком, должна иметь связанный с переменным значением тип данных.

Как объявлять переменные в Java?

Перед использованием переменной нужно её объявить. Для объявления переменной в Java используют следующий синтаксис:

 
тип данных переменная [ = значение], [переменная [= значение], . ] ;
 
Идём дальше: если нужно объявить больше чем одну переменную указанного типа, допускается применение списка с запятыми:
 
 
int a, b, c; // объявление трёх целых переменных a, b и c
 
Инициализация переменной
 
Перед использованием переменной, нужно задать ей начальное значение. Этот процесс называется инициализация. Без инициализации мы можем получить ошибку во время выполнения программы, поэтому инициализация очень важна. Для инициализации переменной используют оператор присваивания. Слева указывается имя переменной, справа её значение.
 
Вот пример инициализации:
 
 
int x = 10; // объявление и инициализация переменной System.out.println(x); // 10
 
Ниже посмотрим другие примеры инициализации и объявления переменных в Java:
 
 
int a = 10, b = 10; // Пример инициализации переменных double pi = 3.14159; // Объявление переменной pi и присвоение ей величины «пи» byte b = 22; // Инициализация переменной b типа byte char a = 'a'; // Переменной a типа char присваиваем значение 'a'
 
Типы переменных в Java
 
Продолжаем наш небольшой урок для начинающих, посвящённый инициализации переменных в Java. Итак, можно выделить 3 типа переменных: - локальные; - статические (переменные класса); - переменные экземпляра.
 
Теперь давайте рассмотрим их подробнее.
 
Локальные переменные в Java
 
Свойства локальных переменных: - объявляются в методах, блоках или конструкторах; - создаются, когда метод, блок или конструктор запускаются; - уничтожаются после завершения метода, конструктора либо блока; - видимы лишь в пределах объявленного метода, блока либо конструктора; - реализуются на уровне стека внутри; - в Java не существует значений по умолчанию для локальных переменных, поэтому они должны объявляться и проходить этап инициализации непосредственно перед первым использованием; - для переменной нельзя использовать модификаторы доступа.
 
Пример локальных переменных
 
Итак, «age» — это наша переменная, определяемая внутри метода pupAge() , причём область её действия ограничивается лишь этим методом:
 
 
public class Test < public void pupAge()< int age = 0; age = age + 7; System.out.println("Возраст собаки: " + age); >public static void main(String args[]) < Test test = new Test(); test.pupAge(); >>
 
В итоге мы получим следующий результат:
 
 
Возраст собаки: 7
 
Пример локальных переменных без инициализации
 
Мы уже говорили о том, что переменная без инициализации приведёт к ошибке компиляции и упоминали о важности такой процедуры, как инициализация. Давайте чуть-чуть изменим код и попробуем выполнить нашу программу без инициализации переменной «age»:
 
 
public class Test < public void pupAge()< int age; //начальное значение не задано, значит, инициализация отсутствует age = age + 7; System.out.println("Возраст собаки: " + age); >public static void main(String args[]) < Test test = new Test(); test.pupAge(); >>
 
Запустив компиляцию без инициализации, мы увидим следующую ошибку:
 
 
Test.java:4:variable number might not have been initialized age = age + 7; ^ 1 error //так как инициализация отсутствует, программа не «может понять», к чему прибавлять цифру 7
 
Пожалуй, об инициализации уже поговорили достаточно. Идём дальше.
 
Переменные экземпляра
 
Для начала рассмотрим основные свойства переменных экземпляра: - объявляются в классе, однако за пределами метода, блока, конструктора; - когда в стеке выделяется пространство для объекта, создаётся слот для всех значений переменных экземпляра; - в Java эти переменные создаются тогда, когда объект создаётся посредством ключевого слова «new», а удаляются, когда объект уничтожается; - переменные включают значения, ссылающиеся более чем на один метод, блок или конструктор; - переменные экземпляра можно объявить на уровне класса, а также до и после использования; - для переменных экземпляра могут быть предоставлены модификаторы доступа; - эти переменные в Java видимы для всех методов, блоков и конструкторов в классе. Рекомендуется делать их private. Также можно делать их видимыми для подклассов данных переменных посредством модификаторов доступа; - переменные имеют значения по умолчанию: 0 — для чисел, false — для логических значений, null — для ссылок на объект. Значения можно присвоить в конструкторе либо при объявлении; - переменные могут быть доступны при вызове имени переменной внутри класса. При этом в статических методах и разных классах они вызываются посредством полного имени — ObjectReference.VariableName .
 
 
import java.io.*; public class Employee < // Переменная экземпляра открыта для дочернего класса (любого) public String name; // Переменная salary видна лишь в Employee private double salary; // Имя переменной присваивается в конструкторе public Employee (String empName)< name = empName; >// Переменной salary присваивается значение public void setSalary(double empSal) < salary = empSal; >// Метод выводит на экран данные сотрудников public void printEmp() < System.out.println("имя: " + name ); System.out.println("зарплата:" + salary); >public static void main(String args[]) < Employee empOne = new Employee("Сергей"); empOne.setSalary(2000); empOne.printEmp(); >>
 
Результат работы нашей программы следующий:
 
 
имя: Сергей зарплата: 2000.0
 
Рассмотрение переменных класса (статических переменных в Java) выходит за рамки нашей статьи. Давайте лучше поговорим о том, что такое константа и зачем нужны константы в Java.
 
Для чего используются константы?
 
Константы применяются в Java для хранения данных. Константа отличается от переменной. Главное отличие в том, что при использовании константы мы можем присвоить значение лишь один раз.
 
В остальном константа объявляется так же, как и переменная. Правда, в случае использования константы сначала идёт ключевое слово final:
 
 
final int LIMIT = 5; System.out.println(LIMIT); // 5 // LIMIT=57; // данный синтаксис возможен потому, что LIMIT — это константа
 
Как правило, при записи имени константы применяют верхний регистр.
 
Константы позволяют задать переменные, которые больше не должны меняться. Допустим, у нас существует переменная для хранения числа «пи». При инициализации мы можем сразу же объявить, что она константа, ведь её значение постоянно.
 
На этом пока всё. Если хотите знать больше, чем объявление, инициализация и использование переменной, записывайтесь на курс «Разработчик Java». Здесь вы получите навыки разработки серверных приложений, овладеете низкоуровневыми и высокоуровневыми подходами к созданию многопоточных и многопроцессных приложений и много чего ещё.
 
Переменные
 
Теги: Си переменные. char, int, unsigned, long, long long, float, double, long double, long float, lexical scoping. Объявление переменных. Область видимости. Инициализация переменных. Имена переменных. Экспоненциальная форма.
 
Переменные
 
П еременные используются для хранения значений (sic!). Переменная характеризуется типом и именем. Начнём с имени. В си переменная может начинаться с подчерка или буквы, но не с числа. Переменная может включать в себя символы английского алфавита, цифры и знак подчёркивания. Переменная не должна совпадать с ключевыми словами (это специальные слова, которые используются в качестве управляющих конструкций, для определения типов и т.п.)
 
А также ряд других слов, специфичных для данной версии компилятора, например far, near, tiny, huge, asm, asm_ и пр.
 
Например, правильные идентификаторы 
a, _, _1_, Sarkasm, a_long_variable, aLongVariable, var19, defaultX, char_type 
неверные 
1a, $value, a-long-value, short
 
Си - регистрозависимый язык. Переменные с именами a и A, или end и END, или perfectDark и PerfectDarK – это различные переменные.
 
Типы переменных
 
 
1) Размер переменной в байтах (сколько байт памяти выделит компьютер для хранения значения)
 
2) Представление переменной в памяти (как в двоичном виде будут расположены биты в выделенной области памяти).
 
 
Целые
 
 
char - размер 1 байт. Всегда! Это нужно запомнить.
 
short - размер 2 байта
 
int - размер 4 байта
 
long - размер 4 байта
 
long long - размер 8 байт.
 
 
Указанные выше значения характерны для компилятора VC2012 на 32-разрядной машине. Так что, если ваша программа зависит от размера переменной, не поленитесь узнать её размер.
 
Теперь давайте определим максимальное и минимальное число, которое может хранить переменная каждого из типов. Числа могут быть как положительными, так и отрицательными. Отрицательные числа используют один бит для хранения знака. Иногда знак необходим (например, храним счёт в банке, температуру, координату и т.д.), а иногда в нём нет необходимости (вес, размер массива, возраст человека и т.д.). Для этого в си используется модификатор типа signed и unsigned. unsigned char - все 8 бит под число, итого имеем набор чисел от 00000000 до 11111111 в двоичном виде, то есть от 0 до 255 signed char от -128 до 128. В си переменные по умолчанию со знаком. Поэтому запись char и signed char эквивалентны.
 Таб. 1 Размер целых типов в си.  
 
 
Тип
 
Размер, байт
 
Минимальное значение
 
Максимальное значение
 
  
 
 
unsigned char
 
1
 
0
 
255
 
 
 
signed char
( char )
 
1
 
-128
 
127
 
 
 
unsigned short
 
2
 
0
 
65535
 
 
 
signed short
( short )
 
2
 
-32768
 
32767
 
 
 
unsigned int
( unsigned )
 
4
 
0
 
4294967296
 
 
 
signed int
( int )
 
4
 
-2147483648
 
2147483647
 
 
 
unsigned long
 
4
 
0
 
4294967296
 
 
 
signed long
( long )
 
4
 
-2147483648
 
2147483647
 
 
 
unsigned long long
 
8
 
0
 
18446744073709551615
 
 
 
signed long long
( long long )
 
8
 
-9223372036854775808
 
9223372036854775807
 
 
 
 
sizeof
 
В си есть оператор, который позволяет получить размер переменной в байтах. sizeof переменная, или sizeof(переменная) или sizeof(тип). Это именно оператор, потому что функция не имеет возможности получить информацию о размере типов во время выполнения приложения. Напишем небольшую программу чтобы удостовериться в размерах переменных.
 
#include #include int main() < char c; short s; int i; long l; long long L; //Вызов sizeof как "функции" printf("sizeof(char) = %d\n", sizeof(c)); printf("sizeof(short) = %d\n", sizeof(s)); printf("sizeof(int) = %d\n", sizeof(i)); printf("sizeof(long) = %d\n", sizeof(l)); printf("sizeof(long long) = %d\n", sizeof(L)); //Вызов как оператора printf("sizeof(char) = %d\n", sizeof c); printf("sizeof(short) = %d\n", sizeof s); printf("sizeof(int) = %d\n", sizeof i); printf("sizeof(long) = %d\n", sizeof l); printf("sizeof(long long) = %d\n", sizeof L); _getch(); >
 
(Я думаю ясно, что переменные могут иметь любое валидное имя). Эту программу можно было написать и проще
 
#include #include int main() < printf("sizeof(char) = %d\n", sizeof(char)); printf("sizeof(short) = %d\n", sizeof(short)); printf("sizeof(int) = %d\n", sizeof(int)); printf("sizeof(long) = %d\n", sizeof(long)); printf("sizeof(long long) = %d\n", sizeof(long long)); //нельзя произвести вызов sizeof как оператора для имени типа //sizeof int - ошибка компиляции _getch(); >
 
В си один и тот же тип может иметь несколько названий 
short === short int 
long === long int 
long long === long long int 
unsigned int === unsigned 
 
Типы с плавающей точкой
 
 
float - 4 байта,
 
long float - 8 байт
 
double - 8 байт
 
long double - 8 байт.
 
 Таб. 2 Размер типов с плавающей точкой в си.  
 
 
Тип
 
Размер, байт
 
Количество значащих знаков мантиссы
 
Минимальное значение
 
Максимальное значение
 
  
 
 
float
 
4
 
6-7
 
1.175494351 E – 38
 
3.402823466 E + 38
 
 
 
double
 
8
 
15-16
 
2.2250738585072014 E – 308
 
1.7976931348623158 E + 308
 
 
 
 
Переполнение переменных
 
Си не следит за переполнением переменных. Это значит, что постоянно увеличивая значение, скажем, переменной типа int в конце концов мы "сбросим значение"
 
#include #include void main() < unsigned a = 4294967295; int b = 2147483647; //Переполнение беззнакового типа printf("%u\n", a); a += 1; printf("%u", a); //Переполнение знакового типа printf("%d\n", b); b += 1; printf("%d", b); getch(); >
 
Вообще, поведение при переполнении переменной определено только для типа unsigned: Беззнаковое целое сбросит значение. Для остальных типов может произойти что угодно, и если вам необходимо следить за переполнением, делайте это вручную, проверяя аргументы, либо используйте иные способы, зависящие от компилятора и архитектуры процессора.
 
Постфиксное обозначение типа
 
 
11 - число типа int
 
10u - unsigned
 
22l или 22L - long
 
3890ll или 3890LL - long long (а также lL или Ll)
 
80.0f или 80.f или 80.0F - float (обязательно наличие десятичной точки в записи)
 
3.0 - число типа double
 
 
#include #include int main()
 
Следующий код, однако, не будет приводить к ошибкам, потому что происходит неявное преобразование типа
 
int a = 10u; double g = 3.f;
 
Шестнадцатеричный и восьмеричный формат
 
В о время работы с числами можно использовать шестнадцатеричный и восьмеричный формат представления. Числа в шестнадцатиричной системе счисления начинаются с 0x, в восьмеричной системе с нуля. Соответственно, если число начинается с нуля, то в нём не должно быть цифр выше 7:
 
#include #include void main()
 
Экспоненциальная форма представления чисел
 
Э кспоненциальной формой представления числа называют представление числа в виде M e ± p , где M - мантиса числа, p - степень десяти. При этом у мантисы должен быть один ненулевой знак перед десятичной запятой. 
Например 1.25 === 1.25e0, 123.5 === 1.235e2, 0.0002341 === 2.341e-4 и т.д. 
Представления 3.2435e7 эквивалентно 3.2435e+7 
Существеут и другое представление ("инженерное"), в котором степень должна быть кратной тройке. Например 1.25 === 1.25e0, 123.5 === 123.5e0, 0.0002341 === 234.1e-6, 0.25873256 === 258.73256e-3 и т.д.
 
Объявление переменных
 
В си переменные объявляются всегда в начале блока (блок - участок кода ,ограниченный фигурными скобками)
 
При объявлении переменной пишется её тип и имя.
 
int a; double parameter;
 
Можно объявить несколько переменных одного типа, разделив имена запятой
 
long long arg1, arg2, arg3;
 
#include #include int main() < int a = 10; int b; while (a>0) < int z = a*a; b += z; >>
 
Здесь объявлены переменные a и b внутри функции main, и переменная z внутри тела цикла. Следующий код вызовет ошибку компиляции
 
int main()
 
Это связано с тем, что объявление переменной стоит после оператора присваивания. При объявлении переменных можно их сразу инициализировать. 
int i = 0; 
При этом инициализация при объявлении переменной не считается за отдельный оператор, поэтому следующий код будет работать
 
int main()
 
Начальное значение переменной
 
О чень важно запомнить, что переменные в си не инициализируются по умолчанию нулями, как во многих других языках программирования. После объявления переменной в ней хранится "мусор" - случайное значение, которое осталось в той области памяти, которая была выделена под переменную. Это связано, в первую очередь, с оптимизацией работы программы: если нет необходимости в инициализации, то незачем тратить ресурсы для записи нулей (замечание: глобальные переменные инициализируются нулями, почему так, читайте в этой статье).
 
#include #include int main()
 
Если выполнять эту программу на VC, то во время выполнения вылетит предупреждение 
Run-Time Check Failure #3 - The variable 'i' is being used without being initialized. 
Если нажать "Продолжить", то программа выведет "мусор". В многих других компиляторах при выполнении программы не будет предупреждения.
 
Область видимости переменной
 
П еременные бывают локальными (объявленными внутри какой-нибудь функции) и глобальными. Глобальная переменная видна всем функциям, объявленным в данном файле. Локальная переменная ограничена своей областью видимости. Когда я говорю, что переменная "видна в каком-то месте", это означает, что в этом месте она определена и её можно использовать. Например, рассмотрим программу, в которой есть глобальная переменная
 
#include #include int global = 100; void foo() < printf("foo: %d\n", global); >void bar(int global) < printf("bar: %d\n", global); >int main()
 
Будет выведено 
foo: 100 
bar: 333 
Здесь глобальная переменная global видна всем функциям. Но аргумент функции затирает глобальную переменную, поэтому при передаче аргумента 333 выводится локальное значение 333. 
Вот другой пример
 
#include #include int global = 100; int main()
 
Программа выведет 555. Также, как и в прошлом случае, локальная переменная "важнее". Переменная, объявленная в некоторой области видимости не видна вне её, например
 
#include #include int global = 100; int main() < int x = 10; < int y = 30; printf("%d", x); >printf("%d", y); >
 
Этот пример не скомпилируется, потому что переменная y существует только внутри своего блока. 
Вот ещё пример, когда переменные, объявленные внутри блока перекрывают друг друга
 
#include #include int global = 100; int main() < int x = 10; < int x = 20; < int x = 30; printf("%d\n", x); >printf("%d\n", x); > printf("%d\n", x); getch(); >
 
Программа выведет 
30 
20 
10 
Глобальных переменных необходимо избегать. Очень часто можно услышать такое. Давайте попытаемся разобраться, почему. В ваших простых проектах глобальные переменные выглядят вполне нормально. Но представьте, что у вас приложение, которое
 
 
1) Разрабатывается несколькими людьми и состоит из сотен тысяч строк кода
 
2) Работает в несколько потоков
 
 
Во-первых, глобальная переменная, если она видна всем, может быть изменена любой частью программы. Вы изменили глобальную переменную, хотите её записать, а другая часть программы уже перезаписала в неё другое значение (на самом деле это целый класс проблем, которые возникают в многопоточной среде). Во-вторых, при больших размерах проекта не уследить, кто и когда насоздавал глобальных переменных. В приведённых выше примерах видно, как переменные могут перекрывать друг друга, то же произойдёт и в крупном проекте.
 
Безусловно, есть ситуации, когда глобальные переменные упрощают программу, но такие ситуации случаются не часто и не в ваших домашних заданиях, так что НЕ СОЗДАВАЙТЕ ГЛОБАЛЬНЫХ ПЕРЕМЕННЫХ! 
Переменные могут быть не только целочисленными и с плавающей точкой. Существует множество других типов, которые мы будем изучать в дальнейшем.
 
ru-Cyrl 18- tutorial Sypachev S.S. 1989-04-14 sypachev_s_s@mail.ru Stepan Sypachev students
 
    
Всё ещё не понятно? – пиши вопросы на ящик