Переменные в с: объявление, инициализация, типы, представление и область видимости.

Переменные в C++ | Уроки С++

  Обновл. 29 Авг 2020  | 

Программируя на языке C++, мы создаем, обрабатываем и уничтожаем объекты. Объект — это часть памяти, которая может хранить значение. В качестве аналогии мы можем использовать почтовый ящик, куда мы помещаем информацию и откуда её извлекаем. Все компьютеры имеют оперативную память, которую используют программы. При создании объекта, часть оперативной памяти выделяется для этого объекта. Большинство объектов, с которыми мы будем работать в языке C++, являются переменными.

Переменные

Cтейтмент a = 8; выглядит довольно простым: мы присваиваем значение 8 переменной a. Но что такое a? a — это переменная, объект с именем.

На этом уроке мы рассмотрим только целочисленные переменные. Целое число — это число, которое можно записать без дроби, например: -11, -2, 0, 5 или 34.

Для создания переменной используется стейтмент объявления (разницу между объявлением и определением переменной мы рассмотрим несколько позже). Вот пример объявления целочисленной переменной a (которая может содержать только целые числа):

При выполнении этой инструкции центральным процессором часть оперативной памяти выделяется под этот объект. Например, предположим, что переменной a присваивается ячейка памяти под номером 150. Когда программа видит переменную a в выражении или в стейтменте, то она понимает, что для того, чтобы получить значение этой переменной, нужно заглянуть в ячейку памяти под номером 150.

Одной из наиболее распространенных операций с переменными является операция присваивания, например:

Когда процессор выполняет эту инструкцию, он понимает её как «поместить значение 8 в ячейку памяти под номером 150».

Затем мы сможем вывести это значение на экран с помощью std::cout:

std::cout << a; // выводим значение переменной a (ячейка памяти под номером 150) на экран

l-values и r-values

В языке C++ все переменные являются l-values. l-value (в переводе «л-значение», произносится как «ел-валью») — это значение, которое имеет свой собственный адрес в памяти. Поскольку все переменные имеют адреса, то они все являются l-values (например, переменные a, b, c — все они являются l-values). l от слова «left», так как только значения l-values могут находиться в левой стороне в операциях присваивания (в противном случае, мы получим ошибку). Например, стейтмент 9 = 10; вызовет ошибку компилятора, так как 9 не является l-value. Число 9 не имеет своего адреса в памяти и, таким образом, мы ничего не можем ему присвоить (9 = 9 и ничего здесь не изменить).

Противоположностью l-value является r-value (в переводе «р-значение», произносится как «ер-валью»). r-value — это значение, которое не имеет постоянного адреса в памяти. Примерами могут быть единичные числа (например, 7, которое имеет значение 7) или выражения (например, 3 + х, которое имеет значение х плюс 3).

Вот несколько примеров операций присваивания с использованием r-values:

int a;      // объявляем целочисленную переменную a
a = 5;      // 5 имеет значение 5, которое затем присваивается переменной а
a = 4 + 6;  // 4 + 6 имеет значение 10, которое затем присваивается переменной а

int b;      // объявляем целочисленную переменную b
b = a;      // a имеет значение 10 (исходя из предыдущих операций), которое затем присваивается переменной b
b = b;      // b имеет значение 10, которое затем присваивается переменной b (ничего не происходит)
b = b + 2;  // b + 2 имеет значение 12, которое затем присваивается переменной b

Давайте детально рассмотрим последнюю операцию присваивания:

Здесь переменная b используется в двух различных контекстах. Слева b используется как l-value (переменная с адресом в памяти), а справа b используется как r-value и имеет отдельное значение (в данном случае, 12). При выполнении этого стейтмента, компилятор видит следующее:

И здесь уже понятно, какое значение присваивается переменной b.

Сильно беспокоиться о l-values или r-values сейчас не нужно, так как мы еще вернемся к этой теме на следующих уроках. Всё, что вам нужно сейчас запомнить — это то, что в левой стороне операции присваивания всегда должно находиться l-value (которое имеет свой собственный адрес в памяти), а в правой стороне операции присваивания — r-value (которое имеет какое-то значение).

Инициализация vs. Присваивание

В языке C++ есть две похожие концепции, которые новички часто путают: присваивание и инициализация.

После объявления переменной, ей можно присвоить значение с помощью оператора присваивания (знак равенства =):

int a; // это объявление переменной
a = 8; // а это присваивание переменной a значения 8

В языке C++ вы можете объявить переменную и присвоить ей значение одновременно. Это называется инициализацией (или «определением»).

int a = 8; // инициализируем переменную a значением 8

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

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

Правило: Если у вас изначально имеется значение для переменной, то используйте инициализацию, вместо присваивания.

Неинициализированные переменные

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

Использование неинициализированных переменных может привести к ошибкам, например:

#include <iostream>

int main()
{
// Объявляем целочисленную переменную a
int a;

// Выводим значение переменной a на экран (a — это неинициализированная переменная)
std::cout << a;

return 0;
}

В этом случае компилятор присваивает переменной a ячейку в памяти, которая в данный момент свободна (не используется). Затем значение переменной a отправляется на вывод. Но что мы увидим на экране? Ничего, так как компилятор это не пропустит — выведется ошибка, что переменная a является неинициализированной. В более старых версиях Visual Studio компилятор вообще мог бы вывести какое-то некорректное значение (например, 7177728, т.е. мусор), которое было бы содержимым той ячейки памяти, которую он присвоил нашей переменной.

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

Хорошей практикой считается всегда инициализировать свои переменные. Это будет гарантией того, что ваша переменная всегда имеет определенное значение и вы не получите ошибку от компилятора.

Правило: Убедитесь, что все ваши переменные в программе имеют значения (либо через инициализацию, либо через операцию присваивания).

Тест

Какой результат выполнения следующих стейтментов?

int a = 6;
a = a — 3;
std::cout << a << std::endl; // №1

int b = a;
std::cout << b << std::endl; // №2

// В этом случае a + b является r-value
std::cout << a + b << std::endl; // №3

std::cout << a << std::endl; // №4

int c;
std::cout << c << std::endl; // №5

Ответы

Чтобы просмотреть ответ, кликните на него мышкой.

Ответ №1

Программа выведет 3: a – 3 = 3, что и присваивается переменной a.

Ответ №2

Программа выведет 3: переменной b присваивается значение переменной a (3).

Ответ №3

Программа выведет 6: a + b = 6. Здесь не используется операция присваивания.

Ответ №4

Программа выведет 3: значением переменной a до сих пор является 3.

Ответ №5

Результатом будет ошибка, так как c — это неинициализированная переменная.

Оценить статью:

Загрузка…

Поделиться в социальных сетях:

Переменные в языке C

Переменные в языке C

Переменная в С — именованная область памяти, имеющая определенный тип. Данные, находящиеся в переменной (то есть по ее адресу в памяти), называются значением этой переменной.

Все переменные в языке С должны быть объявлены перед использованием. При использовании в программе ранее не объявленной переменной компилятор выдаст сообщение об ошибке вроде

test.c: In function ‘main’:
test.c:7: error: ‘x’ undeclared (first use in this function)
test.c:7: error: (Each undeclared identifier is reported only once
test.c:7: error: for each function it appears in.)

В этом сообщении указывается имя файла и номер строки, в которой обнаружена ошибка (test.c:5), а также описание ошибки (`x‘ undeclared — объект с именем x не объявлен).

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

Как правило, для хранения целых чисел следует использовать тип int, а для действительных чисел — double.

Объявление переменной имеет следующий вид:

<тип переменой> <один или несколько идентификаторов переменных через запятую>;

Например, переменные n и m типа int можно объявить такой строкой:

Переменную x типа double можно объявить такой строкой:

Значения переменных сразу после объявления не определены и являются произвольными.

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

Идентификатор переменной — это ее имя, которое должно быть последовательностью букв латинского алфавита, символа подчеркивания и цифр, начинающейся с буквы. Примеры правильных идентификаторов: а, n, Year, CaMeL. Пример неправильного идентификатора: 100ege. Имена переменных чувствительны к регистру букв, то есть Number, number, NUMBER и nUMbeR — это четыре разные переменные.

Допустимо инициализировать переменную прямо в конструкции ее объявления: int n = 10, m = 2;

Переменной можно присвоить новой значение при помощи операции присваивания, например, так:

или

(в последнем примере переменной m записано

Переменные в языке Си. Объявление переменных в Си.

Пожалуйста, приостановите работу AdBlock на этом сайте.

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

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

Как объявить переменную?

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

Рис.1. Общий синтаксис объявления переменной.».

В примере на рисунке мы создаём переменную с именем num, в которой можно будет хранить целые числа. На то, что мы собираемся использовать переменную для хранения целых чисел, указывает тип данных int.

Ещё парочка примеров:

Листинг 1. Объявление переменных

int z;  // переменная z  целого типа
char w; // переменная w символьного типа

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

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

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

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

Peremennaya, flag, f3, var4, KolichestvoBukv, fd4s, FLaG, key_number

Неправильные имена переменных

2num – начинается с цифры

num flat – содержит пробел в имени

nomer-telefona – содержит дефис

И ещё один важный момент. В языке программирования Си регистр букв очень важен. Например, переменные с именами flag, FLAG, FlAg, fLAg — это всё различные переменные. Кроме того, есть ряд слов, которые нельзя использовать для названия переменных. Например, int, void, return и другие. Это специальные ключевые слова, которые зарезервированы для нужд самого языка и нигде в другом месте не могут быть использованы.

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

Листинг 2. Объявление нескольких переменных

int a,c; // объявляем переменные a и c целого типа
double x, y, z; // объявляем сразу три вещественные переменные 

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

Переменная в памяти компьютера.

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

Можно считать, что при объявлении мы сообщаем компьютеру, чтобы он выделил под переменную место в памяти и связал это место определенным именем. Количество места, которое будет выделено в памяти для хранения переменной, зависит от типа этой переменной. Проиллюстрируем эту мысль следующим рисунком.

Листинг 3. Объявление двух переменных

int w; // объявляем целочисленной переменной w
double z; // объявляем вещественной переменной z 

Рис.3. Переменные в памяти компьютера.

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

Переменные и типы данных в языке C#

Знакомство с языком С#, как с объектно-ориентированным языком, мы начинаем с изучения переменных и типов данных. В ходе урока вы изучите что такое типы данных и переменные, а также научитесь работать с ними.

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

Типы переменных в языке C# указываются перед названием переменной. От конкретного типа данных будет зависеть содержимое переменной. Если мы укажем что переменная с типом данных для целых чисел int, то в неё мы не сможем записать строку или число с точкой.

В ходе программы мы можем записывать новые значения в переменную, но тип данных должен оставаться неизменным:

float some_value = 2.95f;
some_value = 6.9f; // Записали новое значение

Рассмотрим все типы данных для создания переменных.

Целые числа

• byte — предназначен для хранения целых чисел. Диапазон чисел от -128 до 127, если число будет большим 127 или меньшим -128 , то выдастся ошибка;
• short — предназначен для хранения целых чисел. Диапазон чисел от -32768 до 32767;
• int — предназначен для хранения целых чисел. Диапазон чисел от -2147483648 до 2147483647;
• long — предназначен для хранения целых чисел. Диапазон чисел от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807.

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

Числа с точкой

• float — для создания чисел с плавающей точкой. Диапазон чисел от от -3.4*10³⁸ до 3.4*10³⁸;
• double — для создания чисел с плавающей точкой. Диапазон чисел от от ±4.9*10^-324 до ±1. 8*10³⁰⁸.

Прочие типы данных

• bool — логический тип данных. Предназначен для записи истинного (true) или ложного (false) значения;
• char — тип данных для работы с символами. Позволяет поместить в одинарных кавычках какой-либо символ;
• string — тип данных для текста. В двойных кавычках можно сохранить одно или множество слов.

Типы данных в языке С# в формате таблицы:

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

int a = 0; // Добавление значения сразу
byte c; // Создание переменной без значения
short b, y = 342; // Создание нескольких переменных

Для вызова переменной вы можете обратиться к ней по имени. Чтобы записать данные в переменную с типом float или double необходимо после числа дописать букву f или d соответсвенно.

Переменные в Си. Операции

Переменные в си Операции с переменными в си

Переменные в си служат для хранения,  изменения информации. У каждой переменной в си есть имя и значения. Значения переменной в ходе программы си можно изменять. Чтобы работать с переменными в си,  их нужно сначала объявить. Это значит указать их тип и имя.
Примеры объявления переменных в си

int a;  // объявлена целочисленная переменная  с   именем  a

float b, c;  //объявлены вещественные  переменные  b и с

char e;  // объявлена символьная переменная с именем e

Чтобы работать со  строкой символов в си используется объявление массива символов.
char имя строки[длина строки];

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

char  name[50]; //объявлена строка с именем name  длиной 50

Чтобы присвоить или изменить значение переменной используется  =
Примеры присваивания значений переменных в си

int a,b,c; // объявлены целочисленные переменные a, b, c

a=10; //  переменной a присваивается значение 10

b=20; //  переменной b присваивается значение  20

c=a+b; // в переменную с присваивается сумма a и b

char c; // объявлена символьная переменная с

c=’V’; // символьной переменной c  присваивается символ V

char name[50]; // объявлена строка name

name=”Вася”;  // строке присваивается  текст Вася

Знаки арифметических действий с числовыми переменными в си

+ — сложение, вычитание

* / умножение, деление

% остаток от деления

Стандартные функции для числовых переменных

abs(i) модуль целого числа i

fabs(x) модуль вещественного числа x

sqrt(x) квадратный корень из вещественного числа x

pow(x,y) вычисляет x в степени y

Вернуться к содержанию   Перейти к следующему уроку Вывод информации на экран в Си.

Поделиться

Переменные в С# ~ ..:= Codder =:..

443

Переменная – это именованная область памяти. Ранее мы проходили тему, что такое переменные и для чего им нужно давать правильные имена. В переменную можно записывать данные и использовать далее в программе. Данные, записанные в переменной, называются значением переменной.
C# – типизированный язык. Каждая переменная должна быть определенного типа данных. Ниже, в таблице наведены встроенные типы данных языка C#:

Константа – это переменная, значение которой нельзя изменить. Константы используются для гарантирования того, что данные в этой переменной не изменятся. Ключевое слово  const

На практике договоримся использовать  

ВАЖНО!. C#  регистрозависимый язык программирования. Для него переменные Area, area,  и т.д это РАЗНЫЕ переменные. Помните об этом, дабы избежать проблем.

Как объявляются переменные и их тип? Просто…

Указываем тип и имя переменной. Например

int age, height;

C# допускается присвоение переменной значения сразу же при объявлении

int age = 35, height = 180;
bool answer=true;
const  int months = 12; 

Присвоение переменным начальных значений называется инициализацией переменных

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Похожее

Константы и переменные

Константа, переменная — это базовые понятия в любом языке
программирования. Дадим им определения.

Константа — это величина, которая при
выполнении программы остаётся неизменной.

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

Описание и инициализация переменных

Прежде чем использовать в программе какую-то переменную, надо дать
ей описание, то есть сказать, какое имя имеет
переменная и каков её тип. Вначале указывается тип переменной, а
затем её имя. Например:

int k; // это
переменная целого типа int

double x; // это
переменная вещественного типа удвоенной точности

Если имеется
несколько переменных одного типа, то допускается их описание через
запятую в одном операторе, например:

double a, b, c;

После описания
переменной её можно использовать, но возникает вопрос: а какое
значение имеет переменная сразу же после её описания? Ответ
таков: в программе на языке C или C++
переменная после описания имеет произвольное значение,
то есть ей просто выделяется свободный участок памяти и на этом всё
заканчивается. В переменной хранится та последовательность двоичных
цифр, которая была там до выделения памяти под эту переменную. Такой
подход таит определённую опасность: можно по ошибке использовать в
выражении переменную, которой не было присвоено ни какое значение:

double x, y;

y = 2 * x;

Так как
переменная x
ни как не была определена, т. е. имела произвольное
значение (чаще всего — это очень большое число или наоборот —
очень маленькое), то и переменная y
получит явно не то значение, на которое рассчитывал
пользователь.

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

double a=3, b=4, c=5;

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

Задание и использование констант

Выше было дано определение констант. Теперь рассмотрим работу с
константами более подробно.

Все константы вне зависимости от типа данных можно подразделить на
две категории: именованные константы и константы, которые не имеют
собственного имени. Например:

25
— константа целого
типа;

3.14
— вещественная константа;

‘A’
— символьная
константа.

Все три приведённые здесь константы не имеют имени, они заданы
своим внешним представлением и используются в программе
непосредственно, например так:

int k=25; // переменная
k инициализирована константой — целым
числом 25.

В ряде случаев
константе удобнее дать имя и использовать её далее по имени. Обычно
это делается для математических или физических констант.

В языке C был
единственный способ создания именованных
констант — с помощью
директивы препроцессора #define,
например:

#define PI 3. 14

……………

double t;

t = PI * 2; // здесь
использована именованная константа PI, заданная
выше

В
языке C++ появился ещё один способ —
использование константных переменных,
то есть переменных, которые нельзя изменять после инициализации.
Рассмотрим на том же примере:

const double PI=3.14; // здесь
PI —
константная переменная

double t;

t=PI * 2;

В
чём преимущество от использования константных переменных вместо
задания констант с помощью директивы препроцессора #define?
Всё очень просто: при использовании константной переменной компилятор
проверяет правильность задания константы, и если она будет задана
неверно, то будет выдана ошибка именно в операторе, в котором дано
определение константной переменной.

Если использована именованная
константа, заданная директивой препроцессора #define,
то ошибка будет показана только там, где используется константа.
Например:

// в директиве
препроцессора сделаем ошибку:

#define PI ююю

…………..

double t;

t = PI * 2; // в этой строке
компилятор выдаст ошибку,

            //
хотя на самом деле ошибка допущена гораздо раньше!

C Переменные, константы и литералы

Переменные

В программировании переменная — это контейнер (область хранения) для хранения данных.

Для обозначения области хранения каждой переменной должно быть присвоено уникальное имя (идентификатор). Имена переменных — это просто символическое представление области памяти. Например:

  int playerScore = 95;  

Здесь playerScore — это переменная типа int . Здесь переменной присвоено целочисленное значение 95 .

Значение переменной можно изменить, отсюда и имя переменной.

  char ch = 'а';
// какой-то код
ch = 'l';  

Правила присвоения имени переменной

1. Имя переменной может содержать только буквы (как прописные, так и строчные), цифры и символ подчеркивания.
2. Первая буква переменной должна быть буквой или знаком подчеркивания.
3. Нет правила относительно длины имени (идентификатора) переменной. Однако в некоторых компиляторах могут возникнуть проблемы, если имя переменной длиннее 31 символа.

Примечание: Вы всегда должны пытаться давать значащие имена переменным. Например: firstName — лучшее имя переменной, чем fn .

C — язык со строгой типизацией. Это означает, что тип переменной не может быть изменен после того, как он объявлен. Например:

  int number = 5; // целочисленная переменная
число = 5,5; // ошибка
двойной номер; // ошибка  

Здесь тип переменной number — int . Этой переменной нельзя присвоить значение с плавающей точкой (десятичное) 5.5 . Кроме того, вы не можете переопределить тип данных переменной на double . Кстати, чтобы хранить десятичные значения в C, вам нужно объявить его тип либо double , либо float .

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

Литералы

Литералы — это данные, используемые для представления фиксированных значений. Их можно использовать прямо в коде.Например: 1 , 2,5 , ‘c’ и т. Д.

Здесь 1 , 2,5 и ‘c’ — литералы. Почему? Вы не можете присвоить этим условиям разные значения.

1. Целые числа

Целое число — это числовой литерал (связанный с числами) без дробной или экспоненциальной части. В программировании на C есть три типа целочисленных литералов:

• десятичное (основание 10)
• восьмеричный (основание 8)
• шестнадцатеричный (основание 16)

Например:

Десятичный: 0, -9, 22 и т.  Д.
Восьмеричный: 021, 077, 033 и т. Д.
Шестнадцатеричный: 0x7f, 0x2a, 0x521 и т. Д. 

В программировании на C восьмеричное начинается с 0 , а шестнадцатеричное — с 0x .

2. Литералы с плавающей запятой

Литерал с плавающей запятой — это числовой литерал, имеющий либо дробную, либо экспоненциальную форму. Например:

-2,0
0,0000234
-0,22E-5 

Примечание: E-5 = 10 -5

3. Персонажи

Символьный литерал создается заключением одного символа в одинарные кавычки. Например: ‘a’ , ‘m’ , ‘F’ , ‘2’ , ‘}’ и т. Д.

4. Последовательность побега

Иногда необходимо использовать символы, которые нельзя ввести или которые имеют особое значение в программировании на C. Например: новая строка (ввод), табуляция, вопросительный знак и т. Д.

Для использования этих символов используются escape-последовательности.

Например: \ n используется для новой строки. Обратная косая черта \ вызывает переход от обычного способа обработки символов компилятором.

5. Строковые литералы

Строковый литерал — это последовательность символов, заключенная в двойные кавычки. Например:

"хорошо" // строковая константа
"" // нулевая строковая константа
"" // строковая константа из шести пробелов
"x" // строковая константа, состоящая из одного символа.
"Земля круглая \ n" // выводит строку с новой строкой 

Константы

Если вы хотите определить переменную, значение которой нельзя изменить, вы можете использовать ключевое слово const .Это создаст константу. Например,

  const двойной PI = 3,14;  

Обратите внимание, мы добавили ключевое слово const .

Здесь PI — символическая константа; его значение не может быть изменено.

  const двойной PI = 3,14;
PI = 2,9; // Ошибка  

Вы также можете определить константу с помощью директивы препроцессора #define . Мы узнаем об этом в руководстве по макросам C.

переменных C ++

Переменные C ++

Переменные — это контейнеры для хранения значений данных.

В C ++ существует различных типов переменных (определенных разными ключевыми словами), например:

• int — сохраняет целые числа (целые числа) без десятичных знаков, например 123 или -123
• double — хранит числа с плавающей запятой с десятичными знаками, например 19,99 или -19,99
• char — хранит отдельные символы, такие как «a» или «B».
  Значения символов заключены в одинарные кавычки
• строка — хранит текст, например «Hello World».Строковые значения заключены в двойные кавычки
• bool — сохраняет значения с двумя состояниями:
  правда или ложь

Объявление (создание) переменных

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

Синтаксис

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

Где тип — один из типов C ++ (например, int ), и
переменная — это имя переменной (например, x или
myName ). Знак равенства используется для присвоения значений переменной.

Чтобы создать переменную, которая должна хранить число, посмотрите на следующий пример:

Пример

Создайте переменную с именем myNum типа int и присвойте ей значение 15 :

int myNum = 15;
cout << myNum;

Попробуй сам »

Вы также можете объявить переменную без присвоения значения и присвоить значение позже:

Обратите внимание, что если вы присвоите новое значение существующей переменной, оно перезапишет предыдущее значение:

Пример

int myNum = 15; // myNum равно 15
myNum = 10; // Теперь myNum равно 10
cout << myNum; // Выводит 10

Попробуй сам »

Другие типы

Демонстрация других типов данных:

Пример

int myNum = 5;
// Целое число (целое число без десятичных знаков)
double myFloatNum = 5.99;
// Число с плавающей запятой (с десятичными знаками)
char myLetter = ‘D’;
// Символ
string myText = «Hello»;
// Строка (текст)
bool
myBoolean = true; // логическое значение (истина или
ложь)

Вы узнаете больше об отдельных типах в главе «Типы данных».

Отображаемые переменные

Объект cout используется вместе с <<
оператор для отображения переменных.

Чтобы объединить текст и переменную, разделите их символом <<
оператор:

Сложить переменные вместе

Чтобы добавить переменную к другой переменной, вы можете использовать +
оператор:

Переменные в C ++

Переменная - это имя, связанное со значением, которое можно изменить. Например, когда я пишу int num = 20; здесь имя переменной - num, которое связано со значением 20, int - это тип данных, который представляет, что эта переменная может содержать целочисленные значения.Мы рассмотрим типы данных в следующем уроке. В этом уроке мы обсудим переменные.

Синтаксис объявления переменной в C ++

 тип_данных имя_переменной = значение1, имя_переменной = значение2; 

Например:

 int num1 = 20, num2 = 100; 

Мы также можем записать это так:

 int num1, num2;
число1 = 20;
число2 = 100; 

Типы переменных

Переменные можно разделить на категории в зависимости от их типа данных. Например, в приведенном выше примере мы видели переменные целого типа. Ниже приведены типы переменных, доступные в C ++.

int : Этот тип переменных содержит целочисленное значение.

char : содержит символьные значения, такие как «c», «F», «B», «p», «q» и т. Д.

bool : содержит логическое значение true или false.

double : значение с плавающей запятой двойной точности.

с плавающей запятой : значение с плавающей запятой одинарной точности.

Типы переменных в зависимости от их области действия

Прежде чем идти дальше, давайте сначала обсудим, что такое область действия. Когда мы обсуждали программу Hello World, мы видели фигурные скобки в программе следующим образом:

 int main {

// Какой-то код

} 

Любая переменная, объявленная внутри этих фигурных скобок, имеет область действия, ограниченную этими фигурными скобками. Если вы объявите переменную в функции main () и попытаетесь использовать эту переменную вне функции main (), вы получите ошибку компиляции.

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

1. Глобальная переменная
2. Локальная переменная

Глобальная переменная

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

Давайте рассмотрим пример, чтобы понять это:

Пример глобальной переменной

Здесь у нас есть глобальная переменная myVar , объявленная вне main.Мы дважды обращались к переменной в функции main () без каких-либо проблем.

 #include 
используя пространство имен std;
// Это глобальная переменная
char myVar = 'A';
int main ()
{
   cout << "Значение myVar:" << myVar << endl;
   myVar = 'Z';
   cout << "Значение myVar:" << myVar;
   возврат 0;
} 

Выход:

 Значение myVar: A
Значение myVar: Z 

Локальная переменная

Локальные переменные объявляются в фигурных скобках любой пользовательской функции, основной функции, циклов или любых управляющих операторов (if, if-else и т. Д.), И их область действия ограничена этими фигурными скобками.

Пример локальной переменной

 #include 
используя пространство имен std;

char myFuncn () {
// Это локальная переменная
char myVar = 'A';
}
int main ()
{
   cout << "Значение myVar:" << myVar << endl;
   myVar = 'Z';
   cout << "Значение myVar:" << myVar;
   возврат 0;
} 

Вывод:
Ошибка времени компиляции, потому что мы пытаемся получить доступ к переменной myVar вне ее области.Область действия myVar ограничена телом функции myFuncn () внутри этих фигурных скобок.

Могут ли глобальная и локальная переменные иметь одинаковое имя в C ++?

Давайте посмотрим пример с одинаковыми именами глобальной и локальной переменной.

 #include 
используя пространство имен std;
// Это глобальная переменная
char myVar = 'A';
char myFuncn () {
   // Это локальная переменная
   char myVar = 'B';
   return myVar;
}
int main ()
{
   cout << "Вызов функции:" << myFuncn () << endl;
   cout << "Значение myVar:" << myVar << endl;
   myVar = 'Z';
   cout << "Вызов функции:" << myFuncn () << endl;
   cout << "Значение myVar:" << myVar << endl;
   возврат 0;
} 

Выход:

 Функциональный вызов: B
Значение myVar: A
Функциональный вызов: B
Значение myVar: Z 

Как вы можете видеть, когда я изменил значение myVar в основной функции, это изменило только значение глобальной переменной myVar , потому что область действия локальной переменной myVar ограничена функцией myFuncn () .

переменных в C - C Programming Tutorial

1. Дом
2. Учебное пособие по программированию на C
3. Переменные в C

Последнее обновление 27 июля 2020 г.

Переменные используются для хранения данных, они названы так, потому что их содержимое может изменяться.C - это строго типизированный язык, это просто означает, что после того, как вы объявите переменную определенного типа данных, вы не сможете изменить тип переменной позже в программе. Напомним, что C предоставляет 4 основных типа:

1. внутренний
2. поплавок
3. двойной
4. символ

Объявление переменных

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

Синтаксис: тип данных имя_переменной;

Создадим объявленную переменную i .

 int i; // объявление переменной типа int
 

Здесь i объявлен как переменная типа int , поэтому она может принимать только целые значения, вы не можете использовать i для хранения строковой константы.В 16-битной системной переменной i может принимать значения от -32768 до 32767 , а в 32-битной системе i может принимать значения от -2147483648 до 2147483647 .

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

 int x, y, z; // объявление трех переменных x, y и z типа int
 

Здесь x , y и z относятся к типу int .

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

Когда объявлена ​​переменная, она содержит неопределенное значение, также известное как значение мусора.Если вы хотите, вы можете присвоить переменной какое-то начальное значение с помощью оператора присваивания, т.е. ( = ). Присвоение значения переменной называется инициализацией переменной. Вот несколько примеров инициализации переменных:

 int a = 12, b = 100;
поплавок f = 1,2;
char ch = 'а';
двойной d1, d2, d3 = 1,2;
 

Примечание: В последнем операторе инициализируется только переменная d3 , переменные d1 и d2 содержат значение мусора.

Пожалуйста, включите JavaScript, чтобы просматривать комментарии от Disqus.

переменных C

Резюме : в этом руководстве вы узнаете о переменных C , которые позволяют вам манипулировать данными в вашей программе.

Что такое переменная?

Переменная - это значимое имя места хранения данных в памяти компьютера. При использовании переменной вы ссылаетесь на адрес памяти компьютера.

Именование переменных

У каждой переменной есть имя, которое называется именем переменной.Имя переменной также называется идентификатором. В языке C имя переменной должно соответствовать следующим правилам:

• Имя переменной может содержать буквы, цифры и знак подчеркивания ( _ ). Первым символом имени переменной должна быть буква или знак подчеркивания ( _ ). Однако вам следует избегать использования подчеркивания ( _ ) в качестве первой буквы, потому что это может противоречить стандартным системным переменным.
• Длина имени переменной в Visual C ++ может составлять до 247 символов, но обычно достаточно 31 символа.
• Имя переменной не должно совпадать с зарезервированными словами или ключевыми словами C.

В следующей таблице показаны ключевые слова в C:

1

9016f1 extern

9016f1

9016f1 9 плавать t

общие соглашения об именах переменных:

• Используйте описательное имя переменной.
• Начинается со строчной буквы.
• Разделите слова в имени переменной подчеркиванием ( _ ), например, min_height или смешайте нижний и верхний регистры, например, minHeight.

Обратите внимание, что переменная C чувствительна к регистру, поэтому min_height и Min_height - разные переменные.

Объявление переменных C

Перед использованием переменной ее необходимо объявить. Чтобы объявить переменную, вы указываете ее тип данных и ее имя.Оператор объявления переменной всегда заканчивается точкой с запятой (; ). Например:

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

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

• C резервирует место в памяти для хранения значения переменной . Объем памяти зависит от типа данных, связанных с переменной.
• C также выделяет пробелы, которые связаны с именем переменной и уникальным адресом.

Переменная может быть объявлена ​​в любой точке программы перед ее использованием. Рекомендуется объявлять переменную ближе всего к ее первому месту использования. В C объявление переменной также означает ее определение.

Инициализация переменных C

Для удобства C позволяет инициализировать переменную при ее объявлении, например:

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

Не делайте этого:

Назначение переменных C

Чтобы присвоить значение переменной, вы можете либо инициализировать ее с помощью объявления, либо использовать оператор присваивания ( = ), чтобы присвоить ей значение. См. Следующий пример:

Сначала мы объявили переменную x и инициализировали ее значение 10 .Затем мы присвоили 20 x . Затем мы присвоили x y , поэтому значение y равно 20 .

Обратите внимание, что оператор присваивания (=) означает присвоение значения правой части переменной слева. Это не означает равенство.

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

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

Обратите внимание, что ключевое слово register работает как директива, т. Е. Не гарантирует выделение регистра для хранения значения переменной. Это выбор компилятора.

внешние переменные

Когда вы разрабатываете программу на C, вы обычно организуете код в файлы заголовков с .h и файлы исходного кода с расширением .c .

В файле заголовка у вас может быть следующая строка кода:

Поскольку мы использовали модификатор extern , мы сообщаем компилятору, что существует целочисленная переменная counter , определенная где-то еще, чтобы компилятор не выделить память для переменной счетчика . Этот оператор только объявляет переменную counter .

Каждый раз, когда компилятор видит следующий код в файле исходного кода:

Он выделяет память для переменной counter .Этот оператор определяет переменную счетчика.

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

• Было ли это руководство полезным?
• Да Нет

Изучение C: типы данных и переменные | Майкл Макмиллан

Фото Даниала Игдери на Unsplash

Язык Си существует с конца 1960-х годов. Кен Томпсон и Деннис Ричи из Bell Labs разработали язык, одновременно разрабатывая операционную систему Unix.Фактически, эти два понятия действительно идут вместе, поскольку многие мотивирующие факторы для возможностей C были основаны на том, насколько хорошо язык будет работать для разработки быстрой и эффективной операционной системы.

Удивительно, но язык Си по-прежнему довольно популярен. Он неизменно занимает первое место в рейтинге популярных языков программирования TIOBE. Кроме того, что, возможно, наиболее важно, синтаксическая структура C является основой синтаксиса многих других современных языков программирования, включая C ++, Java, C # и JavaScript.

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

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

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

Предложить пользователю ввести значение данных

Считать значение данных в переменную

Вот еще один очень общий шаблон программы - Input, Process, Output :

Ввод данных в программу

Обработка данных

Вывод обработанных данных

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

Вот еще один шаблон - Накопить до завершения:

Пока есть еще данные для ввода:

Значение входных данных

Значение данных процессов

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

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

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

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

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

• char : для хранения одного байта или символа.
• в т: для хранения целых чисел.
• float : для хранения чисел с одинарной точностью.
• double : для хранения чисел с двойной точностью.

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

Существует также ряд квалификаторов, которые вы можете использовать с некоторыми из этих типов для изменения размера данных, которые вы можете хранить в переменной. Например, с целыми числами вы можете применить квалификаторы short или long , чтобы изменить потенциальный размер сохраняемого числа.Опять же, эти квалификаторы зависят от компилятора. Я продемонстрирую, как определить возможности хранения типа данных после введения переменных.

Два других квалификатора, которые вы можете использовать для переменных int (и char ): со знаком и без знака . Число без знака всегда будет положительным или 0, тогда как число со знаком может быть отрицательным. char переменных хранятся в виде целого числа, поэтому к ним можно применять эти квалификаторы.

Когда число используется в операторе отдельно, оно считается константой (иногда также называемой литералом). Если вы хотите указать номер как длинный, вы можете поставить l (ell) или, лучше, L после числа, например 68567894L .

Числа с плавающей запятой по умолчанию имеют тип double. Если вместо этого вы хотите обозначить число как число с плавающей запятой, вы можете использовать f или F после числа, как в 3.14159F .

C позволяет создавать символьные константы, состоящие из одинарных букв в одинарных кавычках, например ‘k’ . Этот символ имеет числовое значение символа, основанное на наборе символов операционной системы, но на самом деле набор символов, используемый для хранения символов, всегда является набором символов ASCII. Если вы не знакомы с ASCII, перейдите сюда для получения дополнительной информации.

Постоянная переменная - это переменная, значение которой не может измениться в течение срока службы программы.Значения, которые имеют особое значение в программе, обычно определяются как константы. Например, если математическая библиотека языка программирования не определяет число «пи», вы должны объявить его как константу. Вот как это выглядит:

 const int PI = 3.4159; 

Константы обычно пишутся заглавными буквами, поэтому они выделяются в программе.

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

тип данных имя-переменной;

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

Вот несколько примеров объявления переменных в C:

 int number; 
 коэффициент плавучести; 
 double pay_rate; 
 char ltr; 

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

 int высший, самый низкий, средний; 
 двойной первый, второй, последний; 

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

имя-переменной = выражение;

Знак равенства ( = ) называется оператором присваивания . Не думайте, что этот оператор означает равенство. Вместо этого оператор присваивания означает, что переменная «получает» результат выражения справа от нее.

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

Вот несколько примеров отчетов о назначении:

 зарплата = 15,25; 
 test_score = 83; 
 ltr = 'а'; 

Вы можете объединить объявление переменной с присвоением ей начального значения в один оператор. Иногда это называется оператором инициализации или просто инициализатором .

Вот шаблон синтаксиса для этого оператора:

тип данных имя-переменной = выражение;

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

 плавающая зарплата = 15,25; 
 int hours_worked = 40; 
 двойной коэффициент = 0,48; 
 char ltr = 'Z'; 

В одном операторе можно инициализировать несколько переменных одного типа. Вот несколько примеров:

 int score1 = 88, score2 = 77, score3 = 93; 
 удвоенная ставка1 = 2,34, ставка 2 = 3,33, ставка 3 = 1,11; 

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

Спасибо за прочтение. Пожалуйста, ответьте на эту статью или напишите мне по электронной почте с вашими комментариями и предложениями.

Понимание переменных в программировании на C

В этой статье обсуждается природа и использование переменных языка C в контексте встроенных приложений.

Дополнительная информация

Многие из нас слышали слово «переменная» на уроках математики задолго до того, как мы узнали много, если вообще что-нибудь, о компьютерном программировании. Математическая переменная - это величина, значение которой неизвестно или не ограничено одним числом.Это использование похоже, но не идентично концепции переменной C. Два важных отличия: во-первых, в математике мы обычно используем такую ​​букву, как x или y , для представления переменной, тогда как в C мы часто используем описательное слово или фразу, например, temperature , MaxValue , или Number_of_Samples . Во-вторых, бывают ситуации, в которых мы используем переменную C для определения величины, которая известна и не предназначена для того, чтобы когда-либо отличаться от исходного значения.

Переменные в аппаратном обеспечении

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

Разработчики встраиваемых систем часто работают с 8-битными процессорами. В этих устройствах основной размер данных всегда составляет один байт. Память организована по байтам, размер регистров составляет один байт, а сам ЦП рассчитан на обработку 8-битных данных. Это довольно неудобное ограничение, потому что во многих ситуациях значение переменной превышает максимальное значение 8-битного числа.

В конце концов, все ваши тщательно определенные переменные C с умными именами оказываются в виде битов в памяти (или регистрах).

Язык C не ограничивает размер переменной 8 битами, даже если вы работаете с 8-битным процессором. Это означает, что одна переменная в вашей прошивке может соответствовать нескольким регистрам или ячейкам памяти в оборудовании. «Ручное» управление многобайтовыми переменными (то есть через язык ассемблера) - не мое удовольствие, но компиляторы совершенно не возражают, и они отлично справляются со своей задачей.

Определение переменных

Первый шаг в использовании переменной - определение этой переменной.Существенными компонентами определения переменной являются тип и имя.

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

• char : однобайтовое значение со знаком
• int : двух- или четырехбайтовое значение со знаком
• long : четырехбайтовое значение со знаком
• с плавающей запятой : четырехбайтовое значение, которое может иметь числа после десятичной точки - другими словами, оно не ограничивается целыми числами
• бит : значение переменной может быть нулем или единицей

Это визуальное представление того, как последовательность битов интерпретируется по-разному в зависимости от того, интерпретируется ли переменная как знаковая (с использованием записи дополнения до двух) или как беззнаковая.См. Эту статью для получения дополнительной информации.

Следующий код показывает определения переменных, которые состоят только из базового типа и имени (более технический способ обращения к имени - «идентификатор»):

  int ADC_result;
char ReceivedByte;
float Reference_Voltage;  

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

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

Вот примеры определений переменных, которые включают инициализацию:

  int ADC_result = 0;
char ReceivedByte = 0x00;
float Reference_Voltage = 2,4;  

Точная настройка определений переменных

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

Следующие ключевые слова могут оказаться полезными в ваших проектах прошивки:

• без знака : Как вы могли догадаться, это указывает компилятору интерпретировать переменную как значение без знака, а не как значение со знаком. Я определяю большинство своих переменных как беззнаковые, потому что мне редко нужны отрицательные числа.
• const : квалификатор типа const указывает компилятору, что значение переменной не должно изменяться. Как я упоминал в начале статьи, иногда значение «переменной» C не является переменной. Если вы сделаете ошибку в своем коде и попытаетесь изменить значение константной переменной, компилятор выдаст ошибку.
• volatile : сложные компиляторы не просто берут исходный код и транслируют его прямо на сборку. Они также пытаются заставить код работать более эффективно, и этот процесс называется «оптимизацией».«В целом оптимизация - это хорошо. Однако время от времени это может испортить вам день, потому что компилятор оптимизирует только на основе кода и не может учитывать аппаратные события, которые взаимодействуют с вашим кодом. Когда переменная имеет квалификатор изменчивого типа, компилятор знает, что он должен быть осторожен с оптимизацией, связанной с этой переменной.

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

• типы памяти, такие как xdata , idata и code : эти слова заставляют компилятор найти переменную в определенной части памяти микропроцессора. Тип памяти кода особенно удобен: ресурсы ОЗУ в микроконтроллере часто намного более ограничены, чем энергонезависимая память программ, а тип памяти кода позволяет вам использовать дополнительную память программы для хранения данных, которые используются в вашей программе , но никогда модифицированный .

Вот несколько примеров:

  unsigned char UART_byte; // Диапазон допустимых значений переменной от 0 до 255.
const float PI = 3,14159;
volatile unsigned char ADC_Register // Регистр может быть изменен аппаратно, поэтому мы используем квалификатор volatile, чтобы избежать оптимизаций, которые заставили бы программу игнорировать события, генерируемые оборудованием.
беззнаковый символьный код CalibrationValue = 78;  

Использование переменных

Немногое сказать о том, как использовать переменные после того, как они были определены.Собственно, что касается самой переменной, большая часть работы - это определение. После этого вы просто включаете идентификатор переменной в математические операции, циклы, вызовы функций и т. Д. Хороший компилятор не только обрабатывает детали аппаратной реализации, но и ищет способы оптимизации кода в отношении скорости выполнения или размера программы.

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

Заключение

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

Языковая серия C

.