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

Содержание

Переменные в 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) на экран

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <iostream>

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

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

return 0;
}

#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

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*1038 до 3.4*1038;
  • double — для создания чисел с плавающей точкой. Диапазон чисел от от ±4.9*10-324 до ±1. 8*10308.

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

  • 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#:

Тип Область значений Размер
sbyte -128 до 127 Знаковое 8-бит целое
byte 0 до 255 Беззнаковое 8-бит целое
char U+0000 до U+ffff 16-битовый символ Unicode
bool true или false 1 байт*
short -32768 до 32767 Знаковое 16-бит целое
ushort 0 до 65535 Беззнаковое 16-бит целое
int -2147483648 до 2147483647 Знаковое 32-бит целое
uint 0 до 4294967295 Беззнаковое 32-бит целое
long -9223372036854775808 до 9223372036854775807 Знаковое 64-бит целое
ulong 0 до 18446744073709551615 Беззнаковое 64-бит целое
float ±1,5*10-45 до ±3,4*1033 4 байта, точность — 7 разрядов
double ±5*10-324 до ±1,7*10306 8 байтов, точность — 16 разрядов
decimal (-7,9 * 1028 до 7,9 * 1028) / (100–28) 16 байт, точность — 28 разрядов

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

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

bool true или false (По умолчанию —  true)
string набор символов
char один символ
int -2147483648 до 2147483647 Знаковое 32-бит целое
float ±1,5*10-45 до ±3,4*1033 4 байта, точность — 7 разрядов
double ±5*10-324 до ±1,7*10306 8 байтов, точность — 16 разрядов
long -9223372036854775808 до 9223372036854775807 Знаковое 64-бит целое

ВАЖНО!. 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-последовательности.

Последовательности побега
Последовательности побега Персонаж
\ b Backspace
\ f Подача формы
\ п Новая строка
Возврат
\ т Горизонтальный выступ
\ v Вертикальный язычок
\ Обратная косая черта
\ ' Одинарные кавычки
\ " Двойные кавычки
\? Вопросительный знак
\ 0 Пустой символ

Например: \ 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