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

Внешние переменные и функции в C

Глобальные переменные — это еще одно название внешних переменных. Такие переменные указываются даже вне метода. Во всей реализации метода такие переменные остаются доступными глобально. Методы могут изменять значение универсальных переменных. Внешние переменные объявляются и указываются с использованием «внешней» терминологии. Они не ограничены каким-либо методом. Они присутствуют в коде, т.е. поскольку такие переменные являются глобальными. Глобальные переменные имеют стандартное нулевое значение инициализации. Срок их жизни ограничен продолжительностью реализации программы. Такие внешние переменные должны быть указаны и описаны в другом месте кода, обычно в отдельном исходном файле. Каждую глобальную переменную можно было объявить в документе только один раз.

Для максимально возможного количества документов глобальные переменные вполне могут быть определены как внешние. Объявление include может использоваться для приема всех extern-выражений в любом программном документе. Давайте рассмотрим несколько примеров внешних переменных и функций, чтобы понять их работу при использовании операционной системы Ubuntu 20.04 Linux. Войдите в систему из своей системы Linux и откройте оболочку терминала с помощью «Ctrl + Alt + T».

Содержание

1. Внешняя переменная в C
2. Внешняя функция в C
3. Заключение

Внешняя переменная в C

Сразу после открытия терминала вы должны создать сценарий C для работы. Поскольку этот пример предназначен для работы с переменной extern в языке C, мы будем работать с двумя файлами отдельно. «Extern» использовался для ссылки на переменную, которая существует в другом файле. Итак, во-первых, мы создали основной файл C, используя ключевое слово «nano» в команде.

$ nano main.c

Пришло время создать код основной функции. Во-первых, включите в код библиотеку заголовков и внешнюю переменную «a». Мы еще не присвоили значение переменной «а». Функция main использовалась для вывода значения внешней переменной «a», которая будет объявлена ​​в другом файле. Переменная extern сможет получить это значение из файла. На этом основная функция заканчивается. Сохраните этот документ C с помощью «Ctrl + S» и оставьте его, используя «Ctrl + X».

Мы должны создать новый файл типа C, «test.c», используя ключевое слово «nano» в команде.

$ nano test.c

Теперь, когда документ открыт, напишите в нем простой код ниже. Заголовочный файл был включен, а переменная целочисленного типа «a» была указана со значением «24». Это значение переменной будет доступно для файла main.c с помощью переменной «extern» в этом файле. Сохраните и закройте документ.

Скомпилируйте оба документа одновременно с помощью компилятора «GCC». Попробуйте выполнить приведенный ниже запрос «gcc» с указанными в нем именами файлов.

$ gcc main.c test.c

После процесса компиляции оба файла теперь должны выполняться. Итак, для этого воспользуйтесь указанным ниже запросом «a.out» в окне консоли. В окне вывода был показан результат из файла main.c при использовании значения переменной «a» из другого файла «test.c». Это из-за внешней переменной, которая ссылается на значение переменной файла.

$ ./a.out

Возьмем еще один пример переменной extern. Откройте файл «main.c». На этот раз мы работаем над одним файлом.

$ nano main.c

Попробуйте в этом файле приведенный ниже код. Этот код содержит одну внешнюю переменную, определенную вне основной функции, то есть «x». Другая переменная, «y», также используется как внешняя в основном методе. Это должно показать, что extern работает одинаково как внутри, так и за пределами функции. Основная функция имеет одну автоматическую переменную целочисленного типа «z» со значением «76», а переменная «y» здесь указана как «extern». Мы использовали два оператора печати. Первый выводит на печать значение автоматической переменной «z», а второй показывает значение обеих внешних переменных «x» и «y». После этого мы изменили значение внешней переменной «x», и оператор печати покажет измененное значение в терминале.

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

Выполните файл «main.c» со старой командой «a.out» с точкой и обратной косой чертой в начале. Результат находится на вашем экране. Первая строка показывает значение локальной переменной. Другая строка показывает значение обеих внешних переменных, а последняя показывает обновленное значение внешней переменной «x».

Внешняя функция в C

Функция extern относится к функции, определенной в другом файле, и работает так же, как переменная extern, но с отличными рабочими возможностями. Итак, откройте файл main.c, чтобы обновить его.

$ nano main.c

В основном файле есть одно целое число без знака, «stp», имеющее в нем значение 0. Была указана внешняя функция «func», которая будет определена в другом файле. В основной функции есть оператор while для вызова внешнего метода func. Затем значение переменной «stp» было указано как «1», и код завершается.

Откройте другой файл «test.c».

$ nano “test.c”.

Здесь переменная «stp» указана как внешняя переменная, и реализован метод «func». Он проверяет переменную «stp» с помощью оператора «if» и печатает какое-то сообщение.

Скомпилируйте оба файла одновременно.

$ gcc main.c test.c

После выполнения он показывает выходное сообщение, указанное в файле «test.c», указанном в функции «func».

Заключение

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

Поменять значения двух переменных — Программирование на C, C# и Java

Поменять значения двух переменных

admin 28.10.2016 C, C#, Java, Легкий уровень, Легкий уровень, Легкий уровень, Уроки программирования 8 комментариев

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

Как только вы начнете писать свою второю в жизни программу (первая — вывод слов Hello World), вы столкнетесь с необходимостью обмена значениями между двумя числовыми переменными, поскольку манипуляции с данными непременно это предполагают. В примерах кода, которые приводятся в статье мы оперируем с целочисленными переменными типа int, но данные примеры легко адаптировать под любой вид числовых переменных: byte, long, float, double и т.

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

Примеры подходят и будут работать во всех Си-подобных языках программирования: C, C++, C#; а также в языке Java.

Поменять значения двух переменных

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

Начнем с тезиса о том, что переменные в программе имеют содержимое. Они содержат информацию. Для того, чтобы провести какую-либо аналогию с жизнью, нужно подумать: а какие предметы что-нибудь в себе содержат? Первое, что приходит на ум — это ёмкость с жидкостью.

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

С помощью него удастся перелить содержимое одного стакана в другой. Вот так:

1. Перелить молоко из первого стакана в третий.
2. Перелить кока-колу из второго стакана в первый.
3. Из третьего стакана перелить молоко во второй стакан. Готово!

Иллюстрация действий приводится на рисунке ниже.

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

Пусть даны переменные a и b, и их значения нужно поменять местами. Нам понадобится промежуточная временная третья переменная, назовем её temp (сокращение от английского слова temporary — временный). Чтобы выполнить замену, придется также выполнить три действия:

1. Присвоим переменной temp значение из переменной a.
2. Присвоим a значение b.
3. Присвоим b значение переменный temp. Готово!

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

int a = 3; int b = 5; int tmp; tmp = a; a = b; b = tmp;

1 2 3 4 5 6 7 8

int a = 3; int b = 5;   int tmp;   tmp = a; a = b; b = tmp;

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

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

. Как же это сделать?

Объявим a = 3, b = 5. Чтобы поменять значения этих переменных, необходимо выполнить четыре операции (но не придётся использовать промежуточную временную переменную), они приведены в таблице. В столбцах значений переменных намеренно представлены выражения (а не их результат) для большей наглядности.

Операция	a	b
a = a + b	3	5
b = b — a	3 + 5	5
b = -b	3 + 5	5 — 3 — 5 = -3
a = a — b	3 + 5	3
	3 + 5 — 3 = 5	3

Формализуем табличные данные в виде кода:

int a = 3; int b = 5; a = a + b; b = b — a; b = -b; a = a — b;

1 2 3 4 5 6 7

int a = 3; int b = 5;   a = a + b; b = b — a; b = -b; a = a — b;

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

Спасибо за прочтение статьи!

C, c#, Java, Для начинающих, Переменные, си

Поделиться в соц. сетях:

• ← Восьмеричная система счисления
• Вычисление суммы квадратов чисел →

переменных в C: все, что вам нужно знать

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

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

Что такое переменные в C?

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

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

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

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

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

Для объявления любой переменной в C строго соблюдается следующий синтаксис:

Синтаксис:

<тип данных> <список-переменных>;

Пример:

инт а, б, сумма;

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

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

Есть два способа использования переменных в C. Чтобы использовать переменные, вы должны либо объявить их, либо инициализировать их на этапе объявления.

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

Ниже описан процесс подробно, но просто.

Синтаксис:

<тип данных> <имя-переменной = значение>;

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

Синтаксис:

<тип данных> , ,…..;

Пример:

int а = 10, б = 20, в;

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

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

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

Правила и нормы

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

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

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

Недопустимое объявление имен переменных:

Вывод:

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

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

Вы подробно изучите их с надлежащими техническими определениями и примерами следующим образом.

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

Язык C

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

• Локальные переменные
• Глобальные переменные
• Статические переменные
• Внешние переменные
• Автоматические переменные

Вы подробно ознакомитесь с каждым из них.

1. Локальные переменные

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

Пример:

Выход:

После локальных переменных вы узнаете все о глобальных переменных.

2. Глобальные переменные

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

Пример:

Выход:

После глобальных переменных у вас есть статические переменные.

3. Статические переменные

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

Пример:

Выход:

• В приведенном выше примере вы объявляете статическую переменную «сумма» и инициализируете ее начальное значение нулем.
• После первого вызова функции значение суммы увеличивается на единицу, оставаясь неизменным на протяжении всего времени выполнения программы.
• Значение суммы будет увеличено на единицу для следующего вызова функции и сохранения/отображения нового значения 2. 

За статическими переменными следуют внешние переменные.

4. Внешние переменные

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

Пример:

Объявить внешние переменные в файле с расширением .h (заголовочный файл demo.h)

В файле 1 (демонстрация c): доступ к внешним переменным x и y для выполнения операций сложения путем включения заголовочного файла (демонстрация h).

Выход:

Чтобы получить доступ к одним и тем же внешним переменным x и y во втором файле (demo1.c) для выполнения операции вычитания, вы включаете заголовочный файл (demo.h).

Выход:

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

5. Автоматические переменные

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

Пример:

     

Выход:

Продвигайтесь по карьерной лестнице в качестве разработчика стека MEAN с помощью программы Full Stack Web Developer — MEAN Stack Master’s Program. Зарегистрируйтесь сейчас!

Следующие шаги

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

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

Если у вас есть какие-либо вопросы относительно учебника «Переменные в C», сообщите нам об этом в разделе комментариев ниже. Наши специалисты свяжутся с вами как можно скорее.

Почему в C переменные объявлены без значения?

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

Во-первых, однократное объявление всех переменных в начале блока позволяет написать однопроходный неоптимизирующий компилятор, который выделяет память для всех автоматических переменных в стеке (и всех статических в стеке). сегмент данных). Керниган и Ритчи не хотели заставлять свой компилятор реализовывать ни дополнительный проход для создания полного списка всех переменных, используемых в каждом блоке, ни алгоритм вывода типов (подобный тому, который Карри разработал несколько десятилетий назад, но опубликовал лишь в 1919 году). 69). Поскольку они хотели, чтобы переменные C были статически типизированы, это требовало полного объявления каждой переменной перед использованием. (Функции, с другой стороны, не были статически типизированы в K&R C, и поэтому еще не имели прототипов.) Размещение всех этих объявлений в начале блока позволяло компилятору рассчитать, сколько места в стеке нужно выделить и какое будет адрес каждой переменной до того, как она начнет генерировать код, который ее использует.

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

Другая причина заключалась в том, что господствовавшая в то время парадигма программирования считала рискованным не требовать объявления переменных перед их использованием. Одним из хорошо известных примеров во время разработки C был несчастный случай, вызванный ошибкой в ​​программе на Фортране, когда программист намеревался написать DO 31 = 3,1 (цикл, который повторялся три раза), но вместо этого имел опечатку DO 31 = 3,1 . Одна из рекомендаций расследования заключалась в том, что отчасти виноват дизайн языка. Поскольку компилятор Фортрана игнорировал пробелы, не имел зарезервированных ключевых слов и позволял неявно определять переменные путем присвоения им значения, он интерпретировал эту строку как создание новой переменной с именем DO31 типа REAL и установкой ее значения в 3.1. . В начале 1970-х, когда был изобретен C, поэтому считалось более безопасным требовать явного объявления переменных перед кодом, чтобы было легко найти, где была объявлена ​​​​любая переменная, и исправить опечатки в имени идентификатора. (Сам Фортран в 1970-х годах получил команду отключить функцию неявных переменных.)

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

Современные компиляторы теперь используют более сложный алгоритм распределения регистров, такой как алгоритм Чайтина. Тем не менее, для некоторых целей все еще может быть полезно компилировать по старинке: если вы отключите оптимизацию на GCC, вы гарантированно получите исполняемый файл, который хорошо взаимодействует с отладчиком GDB. Каждая переменная, названная в исходном коде, будет иметь уникальное место в памяти, которое можно просмотреть.