Переменная в c это: Переменные в языке C

Типы данных — Основы С++

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

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

Области видимости

В С++ существует понятие области видимости (scope) переменной. Эта область ограничивается блоком кода, в котором переменная определена. Рассмотрим пример:

#include <iostream>
int a = 1;  // глобальная переменная
int main() {
    int b = 2;  // локальная переменная
    {
        int c = 3;  // локальная переменная внутри блока
        std::cout << a << " " << b << " " << c << "\n";  // корректно
    }
    // Эта строчка не скомпилируется,
    // так как переменная c не определена в данной области:
    std::cout << c << "\n";
}

В этом примере есть три области:

• глобальная, в которой определена переменная a;
• тело функции main, в которой определена переменная b;
• внутренний блок, в котором определена переменная c.

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

Рассмотрим пример:

#include <iostream>
int main() {
    int x = 1;
    std::cout << x << "\n";  // напечатает 1
    {
        int x = 2;  // новая переменная, к предыдущему x не имеет отношения
        std::cout << x << "\n";  // напечатает 2
    }
    std::cout << x << "\n";  // снова напечатает 1
}

Инициализация локальных переменных

Локальные переменные простых типов, таких как int, не инициализируются по умолчанию нулём. Компилятор просто выделяет для них байты в стековой памяти, но при этом он не обязан как-либо их заполнять. Это один из принципов C++: мы не должны платить за то, что не используем.

Следующий фрагмент кода может напечатать всё что угодно:

#include <iostream>
int main() {
    int x;
    std::cout << x << "\n";  // неопределённое поведение!
    int y;
    std::cin >> y;  // а это допустимый сценарий
}

Компиляторы g++ и clang++ обычно дают предупреждения о чтении неинициализированных переменных при использовании опции -Wall или -Wuninitialized:

$ clang++ -Wall program. 
          = 0
1 warning generated.

Заметим, что std::string является сложным типом и переменные такого типа всегда по умолчанию инициализируются пустой строкой. Поэтому нет необходимости писать std::string s = "";. Пишите просто std::string s;.

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

С типом int мы уже знакомы. Рассмотрим другие фундаментальные типы данных в С++. Это так называемые интегральные типы и типы для вещественных чисел.

int main() {
    char c = '1';    // символ
    bool b = true;   // логическая переменная, принимает значения false и true
    int i = 42;      // целое число (занимает, как правило, 4 байта)
    short int i = 17;            // короткое целое (занимает 2 байта)
    long li = 12321321312;       // длинное целое (как правило, 8 байт)
    long long lli = 12321321312; // длинное целое (как правило, 16 байт)
    float f = 2.71828;           // дробное число с плавающей запятой (4 байта)
    double d = 3.  141592;         // дробное число двойной точности (8 байт)
    long double ld = 1e15;       // длинное дробное (как правило, 16 байт)
}

Обратите внимание, что символы, в отличие от строк (то есть массивов символов), записываются в апострофах, а не в кавычках. В примере выше мы записываем в переменную c символ единицы. Фактически в памяти хранится ASCII-код этого символа, который равен 49.

Напомним, что каждый тип данных занимает заранее известное количество байтов памяти. Стандарт языка С++ не накладывает жёстких ограничений на размеры типов, они могут отличаться для разных платформ и компиляторов.

О том, что делать с этой особенностью, мы расскажем ниже. А пока отметим, что узнать размер переменной или типа на этапе компиляции можно с помощью оператора sizeof.

Например, на 64-битной Linux-системе компилятор clang++ использует такие размеры для типов:

int main() {
    std::cout << "char: " << sizeof(char) << "\n";                //  1
    std::cout << "bool: " << sizeof(bool) << "\n";                //  1
    std::cout << "short int: " << sizeof(short int) << "\n";      //  2 (по стандарту >= 2)
    std::cout << "int: " << sizeof(int) << "\n";                  //  4 (по стандарту >= 2)
    std::cout << "long int: " << sizeof(long int) << "\n";        //  8 (по стандарту >= 4)
    std::cout << "long long int: " << sizeof(long int) << "\n";   //  8 (по стандарту >= 8)
    std::cout << "float: " << sizeof(float) << "\n";              //  4
    std::cout << "double: " << sizeof(double) << "\n";            //  8
    std::cout << "long double: " << sizeof(long double) << "\n";  // 16
}

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

По умолчанию числовые типы – знаковые. 32 — 1 }

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

#include <iostream>
#include <limits>  // необходимо для numeric_limits
int main() {
    // посчитаем для типа int:
    std::cout << "minimum value: " << std::numeric_limits<int>::min() << "\n"
              << "maximum value: " << std::numeric_limits<int>::max() << "\n";
}

Данный пример на 64-битной Linux-системе напечатает:

minimum value: -2147483648
maximum value: 2147483647

Приведённые выше примеры вывода оператора sizeof верны для 64-битных архитектур, которые на сегодняшний день распространены повсеместно. Однако если бы мы скомпилировали и запустили такую программу на компьютере с 32-битной архитектурой, то получили бы другие результаты. Например, sizeof(long int) стал бы равен 4, в то время как на современных компьютерах мы получили бы 8. Также бывают встраиваемые системы, под которые тоже можно писать на С++. Там битность архитектуры может быть ещё меньше, чем 32.

В заголовочном файле cstdint стандартной библиотеки имеются целочисленные типы с фиксированным размером:

• int8_t / uint8_t
• int16_t / uint16_t
• int32_t / uint32_t
• int64_t / uint64_t

Число в имени типа означает количество бит, используемых для хранения в памяти. Например, int32_t содержит 32 бита (4 байта) и часто соответствует типу int. Если система не поддерживает какой-то тип, то программа с ним просто не скомпилируется.

Переполнение целочисленных типов

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

#include <iostream>
int main() {
    unsigned int a = 123456;  // на 64-битной платформе sizeof(a) == 4
    // Произведение a * a не помещается в 4 байта, так как оно больше 2^32
    std::cout << a * a << "\n";
}

В этом примере выражение a * a будет иметь тот же тип, что и аргументы, поскольку результат не помещается в него целиком. То, что на самом деле будет вычислено, зависит от знаковости типа.

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

int main() {
    unsigned int x = 0;      // на 64-битной платформе sizeof(x) == 4
    unsigned int y = x - 1;  // 4294967295, то есть 2**32 - 1
    unsigned int z = y + 1;  // 0
}

Наоборот, для знаковых типов переполнение приводит к так называемому неопределённому поведению (UB, undefined behavior).

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

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

Арифметические операции

Бинарные операции +, - и * работают для чисел стандартным образом. Результат операции деления /, применённой к целым числам, всегда округляется в сторону нуля. Таким образом, для положительных чисел операция / возвращает неполное частное. Остаток от деления целых чисел можно получить с помощью операции %.

int main() {
    int a = 7, b = 3;
    int q = a / b;  // 2
    int r = a % b;  // 1
}

Если при делении нужно получить обычное частное, то один из аргументов нужно привести к вещественному типу (например, double) с помощью оператора static_cast:

int main() {
    int a = 6, b = 4;
    double q = static_cast<double>(a) / b;  // 1. 5
}

Можно было бы написать чуть более кратко: double q = a * 1.0 / b;. Тогда преобразование аргументов произошло бы неявно.

Арифметические операции над символами, а также сравнение символов друг с другом — это фактически операции над их ASCII-кодами:

#include <iostream>
int main() {
    char c = 'A';
    c += 25;  // увеличиваем ASCII-код символа на 25
    std::cout << c << "\n";  // Z
}

Операция + применительно к строкам означает конкатенирование (то есть склейку). Это пример перегрузки операции: изначальному оператору сложения в стандартной библиотеке для строки придали новый смысл.

#include <string>
int main() {
    std::string a = "Hello, ";
    std::string b = " world!";
    std::string c = a + b;  // Hello, world!
}

Для каждой бинарной операции (например, +) есть версия со знаком равенства (+=) для случая, когда левый аргумент совпадает с переменной, которой присваивается результат:

int main() {
    int x = 5;
    x += 3;  // x = x + 3
    x *= x;  // x = x * x
}

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

int main() {
    int x = 5;
    ++x;  // 6
    --x;  // снова 5
}

Числа с плавающей точкой

В языке C++ существуют три встроенных типа для записи дробных чисел: float (4 байта), double (8 байт) и long double (16 или 8 байт, в зависимости от платформы). В большинстве случаев рекомендуется использовать тип double. Тип float разумно использовать там, где обрабатываются огромные массивы чисел, и возникает необходимость экономить память.

Как правило, хранение дробных чисел в С++ основано на стандарте IEEE 754. Число представляется в виде двоичной дроби в экспоненциальной записи: отдельно хранятся бит знака, порядок и мантисса.

Такое представление выгодно отличается от чисел с фиксированной точкой, где хранится фиксированное количество разрядов. Оно позволяет, хотя и с разной степенью точности, представлять числа, отличающиеся на порядки.

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

Автоматический вывод типа

Компилятор C++ умеет автоматически выводить тип переменной по значению, которое ей присваивается. Для этого вместо типа надо написать ключевое слово auto:

int main() {
    auto x = 42;  // int
    auto pi = 3.14159;  // double
}

Ключевое слово auto позволяет сократить код и не выписывать сложные типы (нам встретятся дальше монстры вроде std::unordered_multimap<Key, Value>::const_iterator). Важно подчеркнуть, что точный тип переменной всё равно становится известен в момент компиляции.

При использовании auto со строками нужно быть осторожным. Важно знать, что конструкция auto s = "hello" выведет низкоуровневый тип const char * (указатель на неизменяемый набор символов в памяти), а не тип-обёртку std::string.

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

Глобальные переменные C++

Концепция глобальных переменных играет очень важную роль в программировании на C ++. Это позволяет нам использовать переменную в любом месте нашей программы и изменять ее значения в соответствии с нашими требованиями. Цель написания этого руководства — познакомить вас с концепцией глобальных переменных в C ++. После этого мы также хотим поделиться с вами некоторыми примерами, с помощью которых вы сможете очень четко понять использование глобальных переменных в C ++ в Ubuntu 20.04.

Содержание

1. Глобальные переменные в C ++ в Ubuntu 20.04
2. Метод использования глобальных переменных в C ++ в Ubuntu 20.04
3. Пример 1
4. Пример 2
5. Пример 3
6. Заключение

Глобальные переменные в C ++ в Ubuntu 20.04

В зависимости от области действия переменные в C ++ в целом классифицируются как локальные и глобальные переменные. Область видимости переменной отличается от уровня, на котором эта переменная доступна в вашей программе. Локальная переменная — это переменная, область действия которой ограничена функцией, т. Е. Вне тела этой функции эта локальная переменная недоступна. Глобальная переменная — это переменная, область действия которой охватывает всю программу, т. Е. Ее можно получить в любом месте программы. Глобальная переменная объявляется еще до функции «main ()» в C ++ и уничтожается только после того, как ваша программа завершает свое выполнение.

Метод использования глобальных переменных в C ++ в Ubuntu 20.04

Чтобы изучить использование глобальных переменных в C ++, вам нужно будет изучить три примера, описанные ниже. Эти примеры были реализованы на C ++ в системе Ubuntu 20.04, чтобы научить вас основам работы глобальных переменных в C ++.

Пример 1

В этом примере мы намеревались выяснить влияние добавления двух чисел на глобальную переменную «сумма». Для этого мы написали программу на C ++, показанную на следующем изображении:

После включения необходимой библиотеки и пространства имен в код C ++, показанный на изображении выше, мы объявили глобальную переменную целочисленного типа с именем «sum». Мы еще не инициализировали эту переменную, что означает, что изначально эта переменная будет содержать мусорное значение. После этого у нас есть функция main (). Внутри его тела мы объявили две переменные целочисленного типа с именами «a» и «b» и присвоили им значения «10» и «20» соответственно.

Теперь мы хотим вычислить сумму этих двух переменных, сложив «a» и «b» и сохранив результат в нашей глобальной переменной «sum». Следовательно, в нашем коде есть выражение «sum = a + b». Затем мы просто напечатали значение переменной «сумма» на терминале с помощью оператора «cout». Наконец, у нас есть оператор «return 0», поскольку тип возврата нашей функции «main ()» был «int».

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

$ g++ GlobalVariables.cpp –o GlobalVariables

После успешной компиляции нашего кода C ++ мы выполнили его, используя следующую команду:

$ . /GlobalVariables

Когда наш код C ++ был выполнен, значение нашей глобальной переменной «sum» оказалось равным «30», что фактически является суммой наших локальных переменных «a» и «b», как показано на изображении ниже. Это означает, что к глобальным переменным можно получить доступ в любом месте нашего кода, а их значениями можно легко манипулировать в соответствии с нашими потребностями. Первоначально мы не присваивали какое-либо значение нашей глобальной переменной «sum», но все же вместо отображения мусорного значения на терминале переменная «sum» содержала значение «30», так как ее мусорное значение было перезаписано в результате операция сложения в нашем коде C ++.

Пример 2

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

В коде C ++, показанном на изображении выше, мы объявили глобальную переменную с именем «переменная» и инициализировали ее значением «10». Затем мы определили прототип функции с именем «square ()», которая предназначена для вычисления квадрата числа. После этого внутри нашей основной функции мы распечатали нашу глобальную переменную. Затем мы увеличили значение этой глобальной переменной, а затем распечатали это увеличенное значение. Затем мы вызвали функцию square () из функции main (). В этой функции «square ()» у нас есть оператор «переменная = переменная * переменная», который просто вычисляет квадрат нашей глобальной переменной, тем самым обновляя значение «переменной» еще раз. Затем мы распечатали значение этой обновленной переменной в теле нашей функции «square ()». Наконец-то,

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

Пример 3

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

В показанном выше коде C ++ мы объявили глобальную переменную целочисленного типа с именем «переменная» и присвоили ей значение «10». После этого в нашей функции «main ()» мы объявили локальную переменную целочисленного типа с тем же именем, то есть «переменная», и присвоили ей значение «20». Затем мы хотели вывести на терминал значения как локальных, так и глобальных переменных. Значение локальной переменной можно распечатать как есть; однако для ссылки на глобальную переменную с тем же именем нам придется использовать оператор «::» перед именем нашей переменной. После этого тем же оператором мы увеличили глобальную переменную. Затем мы снова распечатали значения как локальных, так и глобальных переменных, за которыми следует оператор «return 0».

После сохранения и компиляции этого кода C ++, когда мы его выполнили, начальные значения наших локальных и глобальных переменных были «20» и «10» соответственно. Однако, когда мы увеличили глобальную переменную, это не повлияло на локальную переменную с тем же именем, т. Е. Только значение глобальной переменной обновилось и стало «11», тогда как значение локальной переменной осталось неизменным, то есть «20», как вы можете видеть на изображении, показанном ниже:

Заключение

Эта статья была призвана развить правильное понимание глобальных переменных в C ++ в Ubuntu 20.04. Для этого мы сначала начали с основного определения и назначения глобальной переменной в зависимости от ее области действия. После этого мы рассмотрели три различных примера, на которых вы можете увидеть, как глобальные переменные используются в C ++. Прочитав все это руководство, вы получите достаточные знания о том, как глобальные переменные объявляются и используются в C ++ в Ubuntu 20.04.

Переменная на языке программирования C

Румман Ансари Инженер-программист 20.10.2022 16392 Поделиться

---

Переменная — это имя зарезервированной области, выделенной в памяти. Другими словами, это имя ячейки памяти. Переменные используются для хранения информации, на которую можно ссылаться и которой можно манипулировать в компьютерной программе. значение переменной может изменяться в зависимости от условий или информации, переданной программе. variable=»vary +able», что означает, что его значение может быть изменено.

Полезно думать о переменных как о контейнерах, содержащих информацию.

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

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

---

Объявление переменной и инициализация в два этапа;

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

имя_переменной = значение_константы ;
 

Пример

возраст ;
возраст = 21;
 

Здесь

тип_данных  – это int

имя_переменной  – это возраст и

Значение_константы  21

Объявление и инициализация переменной за один шаг;

тип_данных имя_переменной = значение_константы ;
 

Пример

возраст = 21;
 

Здесь

data_type  является int

имя_переменной  это возраст и

Значение_константы 21

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

• средний
• высота
Класс
• Сила
• рулон
• семестр
• средняя длина
• и т. д.

Переменная может состоять из букв, цифр, символа подчеркивания (_) и знака доллара;

Правила именования переменных:

• Все имена переменных должны начинаться с буквы алфавита, символа подчеркивания или (_) или знака доллара ($). Соглашение состоит в том, чтобы всегда использовать букву алфавита. Знак доллара и подчеркивание не приветствуются.
• Недопустимая цифра в начале.
• Имя переменной может быть любым допустимым идентификатором.
• После первой начальной буквы имена переменных также могут содержать буквы и цифры от 0 до 9. Пробелы и специальные символы не допускаются.
• Имя может быть любой длины, но не увлекайтесь. Помните, что вам нужно будет ввести это имя.
• Символы верхнего регистра отличаются от символов нижнего регистра. Использование ВСЕХ заглавных букв в основном используется для обозначения постоянных переменных. Помните, что имена переменных чувствительны к регистру.
• Вы не можете использовать ключевое слово C (зарезервированное слово) для имени переменной.
• Пробелы не допускаются.

Целочисленные переменные

Первый тип переменной, о котором нам нужно знать, относится к типу класса int  — short для целого числа. Переменная int может хранить значение в диапазоне от -32768 до +32767. Вы можете думать об этом как о большом положительном или отрицательном целом числе: дробная часть не допускается. Чтобы объявить int  вы используете инструкцию:

  int     имя переменной    ;  

Например:

  внутр. рулон;  

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

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

  roll=20;  

Язык программирования C использует символ «=» для  присвоения . Заявление форма рулон =20; следует интерпретировать как взять числовое значение 20 и сохраните его в ячейке памяти, связанной с целочисленной переменной a . Символ «=» не следует рассматривать как равенство, в противном случае написание операторов вида:

  roll=roll+20;  

заставят математиков взрывать предохранители! Это утверждение следует интерпретировать как 90 116 взять текущий значение, хранящееся в ячейке памяти, связанной с целочисленной переменной a; добавьте числовое значение 20 к его, а затем замените это значение в ячейке памяти, связанной с .

Переменные с десятичными числами

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

  плавающий  

Число с плавающей точкой или с плавающей запятой имеет точность около семи цифр и диапазон примерно от 1.E-36 до 1.E+36. Для хранения числа с плавающей запятой требуется четыре байта.

  double  

Число с двойной точностью или двойной точностью имеет около 13 цифр точности и диапазон примерно от 1.E-303 до 1.E+303. Двойник занимает восемь байтов для хранения.

Например:

  число с плавающей запятой;  
  двойная сумма;  
 

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

  итого=0,0;  
  сумма=12,50;  
 

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

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

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

Например:

  char ch;  

Присвоить или сохранить символьное значение в типе данных char  легко — символ переменная — это просто символ, заключенный в одинарные кавычки. Например, если  c  является a char переменная, в которой можно хранить букву A   используя следующий оператор C:

  ch='A'  

Обратите внимание, что вы можете сохранить только один символ в символов переменная. Позже мы мы будем обсуждать использование строк символов, что может привести к путанице, поскольку строка константа пишется между двойными кавычками. Но на данный момент помните, что переменная char   это ‘A’ , а не «A» .

Другие типы переменных

Тип	Описание
символ	символ ch=»A»; Обычно один октет (один байт). Это целочисленный тип.
целое число	int roll=21; Наиболее естественный размер целого числа для машины.
поплавок	поплавок fl=21,1; Значение с плавающей запятой одинарной точности.
двойной	двойной d=21,22; Значение с плавающей запятой двойной точности.
пустота	Представляет отсутствие типа.

---

Переменные на языке Си. Декларация, инициализация переменных

Распространение любви

Введение:

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

Переменные на языке C:

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

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

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

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

Пример:

// Создана переменная 20 = 90 90 10 in1;   //  Теперь ‘var1’ изменено с 10 на 44. var1 = 44;

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

Основная цель переменных — обеспечить способ хранения и изменения данных.

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

Создание или объявление переменных в C:

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

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

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

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

Как видно из синтаксиса, тип данных должен быть любым действительным типом данных C . И имя_переменной — это имя переменной. Вы можете давать имена своим переменным. Но вам нужно следовать определенным правилам при именовании ваших переменных. Узнайте больше в Правила именования идентификатора или переменных .

Вот несколько ключевых моментов, касающихся объявления переменных.

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

Примеры для демонстрации объявления переменных на языке C:

Пример 1:

// Объявление переменной ‘n’ Integer dataype int n;

В приведенном выше фрагменте мы объявили переменную с именем «n» типа данных Integer. Переменная «n» может использоваться для хранения целочисленных значений.

Пример 2:

// Объявление переменной ‘pi’ с типом данных float float pi;

Мы объявили переменную «pi» с типом данных float. Теперь «pi» может принимать значения данных с плавающей запятой.

Пример 3:

// Объявлена ​​переменная ‘c’ символьного типа данных char c;

Мы создали переменную «c» типа данных Character.

Пример 4:

// Мы пытаемся создать переменную с именем ‘if’ // Но это не разрешено, так как ‘if’ является ключевым словом C с плавающей запятой, если;

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

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

📢 Вы не можете использовать имена ключевых слов для именования ваших переменных. Что приведет к ошибке компиляции.

Пример 5:

1 2 5 559 5 55 5 559 9. /0002. здесь четыре целочисленных переменных: ‘i’, ‘j’, ‘k’ и ‘result’ int i, j, k, результат;   // Здесь мы создали/объявили четыре переменные с плавающей запятой float add, sum, mul, div;

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

До сих пор мы обсуждали объявление переменных. Мы также можем инициализировать переменные значениями (Declaration + Assignment). Давайте узнаем об инициализации переменных в языке C.

Инициализация переменных в программировании на C:

Мы только что обсуждали объявление переменных в языке C. Но нам еще предстоит присвоить значения нашим переменным.

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

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

// Объявление переменной инт п;   // Присвоение значения переменной ‘n’ n=10;

Здесь мы объявили переменную ‘n’, а затем присвоенное значение «10» к нему.

Описанная выше операция представляет собой двухэтапный процесс. На первом этапе мы создали или объявили переменную, а на следующем этапе мы присвоили значение переменной.

1. Объявление или создание Variabel
2. Присвоение значений

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

Примеры инициализации переменных:

Давайте инициализируем несколько переменных.

4 int =10; // Инициализация целочисленной переменной
  
 char ch='M'; // Инициализация символьной переменной
  
 // Инициализация переменной с плавающей точкой 'per'
 float per=78. 3;

1 2 3 4 5 6

Как видно из приведенного выше вывода, мы создали и инициализировали три переменные «n» и «M» и «per» .

Краткие примечания:

• Всегда пытайтесь инициализировать свою переменную. Вы можете инициализировать его с некоторым значением по умолчанию. Много раз программисты забывали инициализировать переменные, что приводило к мусорным значениям.
• Дайте осмысленные имена вашим переменным, что улучшит читаемость кода. Поэтому вместо того, чтобы давать случайные имена, попробуйте назвать переменные с целью переменной.
• Старайтесь следовать одному и тому же соглашению об именах во всех программах. Например, если вы хотите использовать CamelCase , используйте camelCase для всех имен ваших переменных.

Заключение:

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