Как вывести unsigned long long в си

Пределы целых чисел в C и C++

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

В Microsoft C также допускается объявление целочисленных переменных с указанием размера, которые относятся к целочисленным типам с размером 8, 16, 32 или 64 бит. Дополнительные сведения о них см. в статье Целочисленные типы с указанием размера.

Ограничения для целочисленных констант

Константа	Значение	Значение
CHAR_BIT	Количество битов в наименьшей переменной, которая не является битовым полем.	8
SCHAR_MIN	Минимальное значение для переменной типа signed char .	–128
SCHAR_MAX	Максимальное значение для переменной типа signed char .	127
UCHAR_MAX	Максимальное значение для переменной типа unsigned char .	255 (0xff)
CHAR_MIN	Минимальное значение для переменной типа char .	–128 (или 0, если используется параметр /J)
CHAR_MAX	Максимальное значение для переменной типа char .	–127 (или 255, если используется параметр /J)
MB_LEN_MAX	Максимальное число байтов в многобайтовом символе.	5
SHRT_MIN	Минимальное значение для переменной типа short .	-32768
SHRT_MAX	Максимальное значение для переменной типа short .	32767
USHRT_MAX	Максимальное значение для переменной типа unsigned short .	65 535 (0xffff)
INT_MIN	Минимальное значение для переменной типа int .	-2147483647 — 1
INT_MAX	Максимальное значение для переменной типа int .	2147483647
UINT_MAX	Максимальное значение для переменной типа unsigned int .	4 294 967 295 (0xffffffff)
LONG_MIN	Минимальное значение для переменной типа long .	-2147483647 — 1
LONG_MAX	Максимальное значение для переменной типа long .	2147483647
ULONG_MAX	Максимальное значение для переменной типа unsigned long .	4 294 967 295 (0xffffffff)
LLONG_MIN	Минимальное значение для переменной типа long long .	–9 223 372 036 854 775 807 – 1
LLONG_MAX	Максимальное значение для переменной типа long long .	9 223 372 036 854 775 807
ULLONG_MAX	Максимальное значение для переменной типа unsigned long long .	18 446 744 073 709 551 615 (0xffffffffffffffff)

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

Завершение блока, относящегося только к системам Майкрософт

Функции форматированного ввода и вывода в си

Функция scanf имеет следующий заголовок: int scanf(const char * restrict format [,addresses,…]); Например для ввода двух целых и одной вещественной переменной следует писать так:
int c,d;
double f;
scanf(«%d %d %lf”,&c,&d,&f);

Спецификатор типа в СИ

Сочетание символов %d или любое другое называется спецификатором типа. В общем случае он имеет следующий формат:
% [*] [WIDTH] [hh|h|l|ll|L] символ_типа ‘*’ – указывает запрещенные для ввода символы. WIDTH – задает максимальную длину поля ввода. В СИ есть такие вещи как преобразователи типа:
hh — в целочисленный char или unsigned char.
h — в целочисленный short int или unsigned short int.
l — к long int для всех целочисленных типов и к типу double всех вещественных типов.
ll — преобразование в целочисленный long long int или unsigned long long int.
L — преобразование к типу long double всех вещественных типов.
Спецификаторы типа:
d, i – число в десятичной системе, знаковое, целое.
o – число в восьмеричной системе, целое.
X, x – число в шестнадцатеричной системе (почитать о шестнадцатеричной системе счисления ), знаковое, целое.
u – число в десятичной системе исчисления, беззнаковое, целое.
f, e и g – число в десятичной системе исчисления, вещественное.
a — число в шестнадцатеричной системе исчисления, вещественное.
c – символ
s – строка в СИ
p – указатель
% — для ввода символа ‘%’

Функция printf имеет следующий прототип: int printf(const char * restrict format [,variables,…]); Пример вывода двух целых переменных и одной вещественной(5 знаков до запятой и 2 после):
int b,c;
double f;
printf(«%d %d %5.2lf”,b,c,f);

Сочетание %d или любое другое называется спецификатором типа. В общем случае он имеет следующий формат: % [f] [WIDTH][.PREC] [h|hh|l|ll|L] символ_типа f – указывает необходимо ли вводить знак + для положительных чисел. WIDTH – длину поля. PREC – задает количество символов после запятой для вещественных чисел и минимальное количество знаков для целых чисел. Пример: Нам нужно ввести 2 вещественных числа и вывести на экран их сумму:
int main(int argc, char **argv)
<
double x, y, z;
scanf(«%lf %lf”,&x,&y);
z = x + y;
printf(«%5.2lf”, z);
return 0;
>

Типы данных и их вывод в языке программирования C

В этом уроке мы познакомимся с особенностями функции printf() и типами данных: целыми и вещественными числами, символами, массивами и строками. Это далеко не все допустимые в C типы. Есть еще указатели, структуры, объединения, перечисления, также имеется возможность определять собственные типы данных.

Функция printf() и форматированный вывод

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

На прошлом уроке мы выводили строку «Hello World» вот так:

printf("Hello World\n");

Однако то же самое можно сделать так:

printf("%s\n", "Hello World");

Здесь %s — это спецификация строкового формата, т. е. вместо %s будет подставлен следующий аргумент, данные которого должны быть строкой.

Пример вывода целого числа:

printf("%d\n", 5);

Вместо числа 5 может стоять переменная целочисленного типа.

Функция printf() может принимать произвольное число аргументов:

printf("%d %s, %d %s.\n", 3, "dogs", 2, "cats");

При выводе данные подставляются по очередности следования: 3 на место первой спецификации, «dogs» на место второй и т.д. То есть следует строго соблюдать соответствие форматов и последующих данных.

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

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

Целочисленные типы

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

Так, если под переменную какого-либо целочисленного типа выделяется 2 байта, что составляет 16 бит, и ей можно присваивать только положительные числа и ноль, то эти числа будут в диапазоне от 0 до 65535, т. к. 2 16 = 65536, но одна вариация забирается на нуль. Если же тип допускает отрицательные числа, то диапазон допустимых значений уже будет лежать в пределах от -32768 до +32767.

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

#include int main() { int lines, i; int count = 0; lines = 100; i = -1; printf("%5d %5d %5d\n", i, count + 10, lines); }

Обратите внимание, что в Си присваивать значение можно при объявлении переменных.

Обычно под переменную типа int , которая может принимать как положительные так и отрицательные значения, отводится 4 байта, что равно 32-м битам. Отсюда допустимый диапазон значений будет лежать в пределах от -2 147 483 648 до 2 147 483 647. Однако если переменной присвоить максимально допустимое для ее типа значение, а потом увеличивать его, то сообщений об ошибке не будет ни на этапе компиляции, ни на этапе выполнения.

#include int main() { int max = 2147483647; printf("%d\n", max); max = max + 1; printf("%d\n", max); max = max + 9; printf("%d\n", max); }

Результат будет таким:

2147483647 -2147483648 -2147483639

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

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

#include int main()  int min = -2147483648; printf("%d\n", min-1); printf("%d\n", min-2); printf("%d\n", min-10); >

2147483647 2147483646 2147483638

Помимо типа int в языке программирования C существуют другие (модифицированные) целочисленные типы:

• short — отводится меньше байтов, чем на int ;
• long — отводится больше байтов, чем на int (не всегда, зависит от системы);
• unsigned — столько же байт как у int , но без отрицательных чисел; в результате чего знаковый разряд освобождается, и количество положительных значений увеличивается;
• unsigned short ;
• unsigned long .

При выводе длинных чисел следует дополнять спецификацию формата буквой l перед буквой формата. Например:

printf("%ld\n", i); printf("%15ld\n", i);

Символы

Под обычный (в Си есть и другие) символьный тип данных отводится 1 байт памяти. Каждому символу такого типа сопоставляется целое число по таблице символов ASCII.

Тип char языка программирования C включает диапазон чисел от -128 до 127. Многие значения от 0 до 127 могут быть заданы или выведены на экран в виде соответствующих символов. Если значение переменной задается в виде символа, а не числа, то символ заключается в одиночные кавычки, например, так: ‘w’. Также в языке существует тип unsigned char с диапазоном чисел от 0 до 255.

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

Если в программе вы будете использовать целые числа со значениями до 127 или 255 и хотите сэкономить память, то объявите переменную как char или unsigned char .

Получается, что в программе символы — это числа, а числа — символы. Тогда как указать, что мы хотим видеть на экране: символ или число? Для вывода на экран символов используется спецификация формата вида %c .

Так программа, представленная ниже,

#include main()  char ch = 63; unsigned char uch = 'r'; short j = 'b', k = 99; printf("%c == %d\n", ch, ch); printf("%c == %d\n", uch, uch); printf("%c, %c\n", j, k); >

выдает такой результат:

? == 63 r == 114 b, c

Число 63 по таблице символов ASCII соответствует знаку ‘?’. Сначала мы выводим значение переменной ch в формате символа, затем – числа. Тоже самое с переменной uch , однако ее значение было задано через символ, а не число.

Вещественные типы данных

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

double a = 0.0005; printf("%f\n", a); printf("%g\n", 0.0005); printf("%g\n", 0.00005); printf("%e\n", 0.0005);

, то на экране мы увидим следующее:

0.000500 0.0005 5e-05 5.000000e-04

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

В случае %g число выводится как обычно, если количество значащих нулей не больше четырех. Если количество значащих нулей четыре и больше, то число выводится в нормализованном виде (третий случай). Запись 5e-5 означает 5 * 10 -5 , что равно 0.00005. А, например, запись 4.325e+3 является экспоненциальной записью 4.325 * 10 3 , что равно 4325. Если с такой формой представления чисел вы сталкиваетесь первый раз, то почитайте дополнительные источники, например, статью в Википедии «Экспоненциальная запись».

Формат %e выведет число исключительно в нормализованном виде, каким бы это вещественное число ни было.

Если при выводе требуется округлить число до определенной точности, то перед буквой-форматом ставят точку и число-указатель точности. Например, printf(«%.2f», 0.23) выведет на экран 0.23, а не 0.230000. Когда требуется указать еще и поле, то его ширину прописывают перед точкой, например, %10.3f .

Массивы

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

int arr[5], nums[N]; float f_arr[100]; char str[80];

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

#define N 100

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

Индексация массивов в языке программирования C начинается с нуля.

Присваивание значений элементам массивов можно произвести сразу или в процессе выполнения программы. Например:

char vowels[] = 'a', 'e', 'i', 'o', 'u', 'y'>; float f_arr[6]; f_arr[0] = 25.3; f_arr[4] = 34.2; printf("%c, %.2f\n", vowels[4], f_arr[0]);

Когда переменная-массив объявляется и сразу определяется (как в случае vowels ), то размер массива можно не указывать, т. к. он вычисляется по количеству элементов, переданных в фигурных скобках.

Строки

В языке программирования С нет отдельного строкового типа данных, хотя формат вывода строки есть ( %s ). Строки в Си – это массивы символов, последний элемент которых является первым (с номером 0) символом в таблице ASCII. В этом месте таблицы стоит «ничто», которое обозначается в исходном коде как символ ‘\0’.

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

Выше мы объявили и определили массив vowels . Если бы мы его определили вот так:

char vowels[] = 'a', 'e', 'i', 'o', 'u', 'y', '\0'>;

char vowels1[] = "aeiouy";

то он был бы строкой. Во втором случае сами двойные кавычки указывают, что имеется в виду строка, и символ окончания строки ‘\0’ записывается в память автоматически.

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

printf("%s\n", vowels); printf("%f\n", f_arr); // ошибка

Функция sizeof()

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

При выводе на экран значения, возвращаемого sizeof() используется формат %lu (длинное целое без знака). Примеры:

int a = 10; int b[100]; printf("Integer: %lu \n", sizeof(a)); printf("Float: %lu \n", sizeof(float)); printf("Array of 100 integers: %lu \n", sizeof(b));

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

Курс с решением задач:
pdf-версия

Переменные

Теги: Си переменные. char, int, unsigned, long, long long, float, double, long double, long float, lexical scoping. Объявление переменных. Область видимости. Инициализация переменных. Имена переменных. Экспоненциальная форма.

Переменные

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

А также ряд других слов, специфичных для данной версии компилятора, например far, near, tiny, huge, asm, asm_ и пр.

Например, правильные идентификаторы
a, _, _1_, Sarkasm, a_long_variable, aLongVariable, var19, defaultX, char_type
неверные
1a, $value, a-long-value, short

Си — регистрозависимый язык. Переменные с именами a и A, или end и END, или perfectDark и PerfectDarK – это различные переменные.

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

• 1) Размер переменной в байтах (сколько байт памяти выделит компьютер для хранения значения)
• 2) Представление переменной в памяти (как в двоичном виде будут расположены биты в выделенной области памяти).

Целые

• char — размер 1 байт. Всегда! Это нужно запомнить.
• short — размер 2 байта
• int — размер 4 байта
• long — размер 4 байта
• long long — размер 8 байт.

Указанные выше значения характерны для компилятора VC2012 на 32-разрядной машине. Так что, если ваша программа зависит от размера переменной, не поленитесь узнать её размер.

Теперь давайте определим максимальное и минимальное число, которое может хранить переменная каждого из типов. Числа могут быть как положительными, так и отрицательными. Отрицательные числа используют один бит для хранения знака. Иногда знак необходим (например, храним счёт в банке, температуру, координату и т.д.), а иногда в нём нет необходимости (вес, размер массива, возраст человека и т.д.). Для этого в си используется модификатор типа signed и unsigned. unsigned char — все 8 бит под число, итого имеем набор чисел от 00000000 до 11111111 в двоичном виде, то есть от 0 до 255 signed char от -128 до 128. В си переменные по умолчанию со знаком. Поэтому запись char и signed char эквивалентны.

Таб. 1 Размер целых типов в си.

Тип	Размер, байт	Минимальное значение	Максимальное значение
unsigned char	1	0	255
signed char ( char )	1	-128	127
unsigned short	2	0	65535
signed short ( short )	2	-32768	32767
unsigned int ( unsigned )	4	0	4294967296
signed int ( int )	4	-2147483648	2147483647
unsigned long	4	0	4294967296
signed long ( long )	4	-2147483648	2147483647
unsigned long long	8	0	18446744073709551615
signed long long ( long long )	8	-9223372036854775808	9223372036854775807

sizeof

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

#include #include int main() < char c; short s; int i; long l; long long L; //Вызов sizeof как "функции" printf("sizeof(char) = %d\n", sizeof(c)); printf("sizeof(short) = %d\n", sizeof(s)); printf("sizeof(int) = %d\n", sizeof(i)); printf("sizeof(long) = %d\n", sizeof(l)); printf("sizeof(long long) = %d\n", sizeof(L)); //Вызов как оператора printf("sizeof(char) = %d\n", sizeof c); printf("sizeof(short) = %d\n", sizeof s); printf("sizeof(int) = %d\n", sizeof i); printf("sizeof(long) = %d\n", sizeof l); printf("sizeof(long long) = %d\n", sizeof L); _getch(); >

(Я думаю ясно, что переменные могут иметь любое валидное имя). Эту программу можно было написать и проще

#include #include int main() < printf("sizeof(char) = %d\n", sizeof(char)); printf("sizeof(short) = %d\n", sizeof(short)); printf("sizeof(int) = %d\n", sizeof(int)); printf("sizeof(long) = %d\n", sizeof(long)); printf("sizeof(long long) = %d\n", sizeof(long long)); //нельзя произвести вызов sizeof как оператора для имени типа //sizeof int - ошибка компиляции _getch(); >

В си один и тот же тип может иметь несколько названий
short === short int
long === long int
long long === long long int
unsigned int === unsigned

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

• float — 4 байта,
• long float — 8 байт
• double — 8 байт
• long double — 8 байт.

Таб. 2 Размер типов с плавающей точкой в си.

Тип	Размер, байт	Количество значащих знаков мантиссы	Минимальное значение	Максимальное значение
float	4	6-7	1.175494351 E – 38	3.402823466 E + 38
double	8	15-16	2.2250738585072014 E – 308	1.7976931348623158 E + 308

Переполнение переменных

Си не следит за переполнением переменных. Это значит, что постоянно увеличивая значение, скажем, переменной типа int в конце концов мы «сбросим значение»

#include #include void main() < unsigned a = 4294967295; int b = 2147483647; //Переполнение беззнакового типа printf("%u\n", a); a += 1; printf("%u", a); //Переполнение знакового типа printf("%d\n", b); b += 1; printf("%d", b); getch(); >

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

Постфиксное обозначение типа

• 11 — число типа int
• 10u — unsigned
• 22l или 22L — long
• 3890ll или 3890LL — long long (а также lL или Ll)
• 80.0f или 80.f или 80.0F — float (обязательно наличие десятичной точки в записи)
• 3.0 — число типа double

#include #include int main()

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

int a = 10u; double g = 3.f;

Шестнадцатеричный и восьмеричный формат

В о время работы с числами можно использовать шестнадцатеричный и восьмеричный формат представления. Числа в шестнадцатиричной системе счисления начинаются с 0x, в восьмеричной системе с нуля. Соответственно, если число начинается с нуля, то в нём не должно быть цифр выше 7:

#include #include void main()

Экспоненциальная форма представления чисел

Э кспоненциальной формой представления числа называют представление числа в виде M e ± p , где M — мантиса числа, p — степень десяти. При этом у мантисы должен быть один ненулевой знак перед десятичной запятой.
Например 1.25 === 1.25e0, 123.5 === 1.235e2, 0.0002341 === 2.341e-4 и т.д.
Представления 3.2435e7 эквивалентно 3.2435e+7
Существеут и другое представление («инженерное»), в котором степень должна быть кратной тройке. Например 1.25 === 1.25e0, 123.5 === 123.5e0, 0.0002341 === 234.1e-6, 0.25873256 === 258.73256e-3 и т.д.

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

В си переменные объявляются всегда в начале блока (блок — участок кода ,ограниченный фигурными скобками)

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

int a; double parameter;

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

long long arg1, arg2, arg3;

#include #include int main() < int a = 10; int b; while (a>0) < int z = a*a; b += z; >>

Здесь объявлены переменные a и b внутри функции main, и переменная z внутри тела цикла. Следующий код вызовет ошибку компиляции

int main()

Это связано с тем, что объявление переменной стоит после оператора присваивания. При объявлении переменных можно их сразу инициализировать.
int i = 0;
При этом инициализация при объявлении переменной не считается за отдельный оператор, поэтому следующий код будет работать

int main()

Начальное значение переменной

О чень важно запомнить, что переменные в си не инициализируются по умолчанию нулями, как во многих других языках программирования. После объявления переменной в ней хранится «мусор» — случайное значение, которое осталось в той области памяти, которая была выделена под переменную. Это связано, в первую очередь, с оптимизацией работы программы: если нет необходимости в инициализации, то незачем тратить ресурсы для записи нулей (замечание: глобальные переменные инициализируются нулями, почему так, читайте в этой статье).

#include #include int main()

Если выполнять эту программу на VC, то во время выполнения вылетит предупреждение
Run-Time Check Failure #3 — The variable ‘i’ is being used without being initialized.
Если нажать «Продолжить», то программа выведет «мусор». В многих других компиляторах при выполнении программы не будет предупреждения.

Область видимости переменной

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

#include #include int global = 100; void foo() < printf("foo: %d\n", global); >void bar(int global) < printf("bar: %d\n", global); >int main()

Будет выведено
foo: 100
bar: 333
Здесь глобальная переменная global видна всем функциям. Но аргумент функции затирает глобальную переменную, поэтому при передаче аргумента 333 выводится локальное значение 333.
Вот другой пример

#include #include int global = 100; int main()

Программа выведет 555. Также, как и в прошлом случае, локальная переменная «важнее». Переменная, объявленная в некоторой области видимости не видна вне её, например

#include #include int global = 100; int main() < int x = 10; < int y = 30; printf("%d", x); >printf("%d", y); >

Этот пример не скомпилируется, потому что переменная y существует только внутри своего блока.
Вот ещё пример, когда переменные, объявленные внутри блока перекрывают друг друга

#include #include int global = 100; int main() < int x = 10; < int x = 20; < int x = 30; printf("%d\n", x); >printf("%d\n", x); > printf("%d\n", x); getch(); >

Программа выведет
30
20
10
Глобальных переменных необходимо избегать. Очень часто можно услышать такое. Давайте попытаемся разобраться, почему. В ваших простых проектах глобальные переменные выглядят вполне нормально. Но представьте, что у вас приложение, которое

• 1) Разрабатывается несколькими людьми и состоит из сотен тысяч строк кода
• 2) Работает в несколько потоков

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

Безусловно, есть ситуации, когда глобальные переменные упрощают программу, но такие ситуации случаются не часто и не в ваших домашних заданиях, так что НЕ СОЗДАВАЙТЕ ГЛОБАЛЬНЫХ ПЕРЕМЕННЫХ!
Переменные могут быть не только целочисленными и с плавающей точкой. Существует множество других типов, которые мы будем изучать в дальнейшем.

ru-Cyrl 18- tutorial Sypachev S.S. 1989-04-14 sypachev_s_s@mail.ru Stepan Sypachev students

Всё ещё не понятно? – пиши вопросы на ящик