C++ Переменные и типы: Int, Char, Float, Double, строка и логическое значение

C++ Переменные типы данных

C++ определяет целый набор примитивных типов

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

Наша команда арифметические типы включать символы, целые числа, логические значения и числа с плавающей запятой. Арифметический тип, если его разделить на 2 категории.

1. Типы с плавающей запятой. Число с плавающей запятой (или тип с плавающей запятой) представляет десятичные числа. Стандарт IEEE определяет минимальное количество значащих цифр. Большинство компиляторов обычно обеспечивают большую точность, чем указанный минимум. Обычно числа с плавающей запятой представлены 32 битами, двойные числа — 64 битами, а длинные двойные числа — 96 или 128 битами.
2. Интегральные типы (которые включают символьные, целые и логические типы). Логический type имеет только два типа значений: True или False. Есть несколько колесница типы, большинство из которых существуют для поддержки интернационализации. Самый простой тип символов — char. Символ имеет тот же размер, что и один машинный байт, что означает один байт.

Наша команда Интегральные типы могут быть подписаны или не подписаны.

Знаковый тип: Они представляют собой отрицательные или положительные числа (включая ноль). В знаковом типе диапазон должен быть равномерно разделен между значениями +ve и -ve. Таким образом, 8-битный знаковый символ будет содержать значения от –127 до 127.

Беззнаковый тип: В беззнаковом типе все значения >= 0. 8-битный беззнаковый символ может содержать числа от 0 до 255 (оба включительно).

Имя переменной или идентификаторы

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

Идентификаторы должны

• начинаются с буквы или подчеркивания («_»).
• И чувствительны к регистру; Прописные и строчные буквы различаются:

// определяет четыре разные переменные типа int

int guru99, gurU99, GuRu99, GURU99;

Наша команда C++ язык зарезервировал некоторые имена для своего использования.

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

• Идентификатор должен давать хотя бы некоторое представление о своем значении.
• Имена переменных обычно пишутся строчными буквами — guru99, а не Guru99 или GURU99.
• Классы, которые мы определяем, обычно начинаются с заглавной буквы.
• Идентификаторы, содержащие несколько слов, должны визуально различать каждое слово. Например, guru99_website, а не guru99website.

C++ Объявление и определение переменной

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

int a=5;
int b;
char c='A'; 

int a,b;
a=b=1000;

List initialization
int a(5);
int b{5};

Константный квалификатор в C++

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

В таком случае используйте ключевое слово const

const int bufSize = 512;    // input buffer size

Это определяет bufSize как константу. Любая попытка назначить или изменить bufSize приводит к ошибке.

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

const int i = get_size();  // ok: initialized at run time
const int j = 42;          // ok: initialized at compile time
const int k;               // error: k is uninitialized const
int i = 42;
const int ci = i;    	   // ok: the value in i is copied into ci 

Область видимости переменных в C++

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

#include <iostream>	
int main()	
{	
    int sum = 0;	
    // sum values from 1 through 10 inclusive	
    for (int val = 1; val <= 10; ++val)	
        sum += val;  // equivalent to sum = sum + val	
    cout << "Sum of 1 to 10 inclusive is "<< sum <<endl;	
    return 0;	
}	 

Эта программа определяет три имени: main, sum и val. Он использует имя пространства имен std вместе с двумя другими именами из этого пространства имен — cout и endl.

• Имя функции «main» определяется вне фигурных скобок. Имя функции main — как и большинство других имен, определенных вне функции — имеет глобальную область действия. Это означает, что однажды объявленные имена, находящиеся в начале глобальный охват доступны на протяжении всей программы.
• Переменная sum определяется в пределах блока, который является телом основной функции. Доступ к нему можно получить из точки объявления и из остальной части тела основной функции. Однако не за его пределами. Это означает, что переменная sum имеет объем блока.
• Переменная val определена в области действия «оператор for». Его можно легко использовать в этом операторе, но не где-либо еще в основной функции. В нем есть локальный охват.

Вложенная область

Область может содержать другие области. Содержащаяся (или вложенная) область называется внутренней областью. Содержащая область видимости является внешней областью действия.

#include <iostream>	
using namespace std;	
// Program for illustration purposes only: It is bad style for a function	
// to use a global variable and also define a local variable with the same name	
int reused = 42;  // reused has global scope	
int main()	
{	
    int unique = 0; // unique has block scope	
    // output #1: uses global reused; prints 42 0	
    cout << reused << " " << unique << endl;	
    int reused = 0; // new, local object named reused hides global reused	
    // output #2: uses local reused; prints 0 0	
    cout << reused << " " << unique << endl;	
    // output #3: explicitly requests the global reused; prints 42 0	
    cout << ::reused << " " << unique << endl;	
    return 0;	
}	 

Выход # 1 появляется перед локальным определением повторного использования. Таким образом, этот вывод

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

42 0

Выход # 2 происходит после локального определения повторного использования. Теперь это в рамках. Следовательно, этот второй оператор вывода просто использует локальный объект с именем reused, а не глобальный, и выводит

0 0

Выход # 3 переопределяет правила области видимости по умолчанию, используя оператор области видимости. Глобальная область действия не имеет имени. Таким образом, когда оператор области видимости (::) имеет пустую левую часть. Он интерпретирует это как запрос на получение имени в правой части глобальной области видимости. Таким образом, выражение использует глобальное повторное использование и выводит

42 0

Преобразование типов переменных

Переменную одного типа можно преобразовать в другой. Это известно как «преобразование типов». Давайте посмотрим правила конвертации различных C++ типы переменных:

Присвоение значения non-bool переменной bool дает false, если значение равно 0, и true в противном случае.

bool b = 42;            // b is true

Присвоение логического значения одному из других арифметических типов дает 1, если логическое значение истинно, и 0, если логическое значение ложно.

bool b = true;
int i = b;              // i has value 1

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

int i = 3.14;               // i has value 3

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

Int i=3;
double pi = i;          // pi has value 3.0

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

Например, 8-битный тип беззнакового символа может содержать значения от 0 до 255 включительно. Присвоение значения за пределами этого диапазона приведет к тому, что компилятор присвоит остаток этого значения по модулю 256. Следовательно, по приведенной выше логике присвоение –1 8-битному беззнаковому символу дает этому объекту значение 255.

unsigned char c = -1;   // assuming 8-bit chars, c has value 255

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

signed char c2 = 256;   // assuming 8-bit chars, the value of c2 is undefined

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

int i = 42;
if (i) // condition will evaluate as true
i = 0; 

Если это значение = 0, то условие ложно; все остальные (ненулевые) значения возвращают значение true. По той же концепции, когда мы используем логическое значение в арифметическом выражении, его значение всегда преобразуется либо в 0, либо в 1. В результате использование логического значения в арифметическом выражении обычно почти наверняка неверно.

Внимание: не смешивайте знаковые и беззнаковые типы.

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

Например, в арифметическом выражении типа

x* y

Если x равен -1, а y равен 1, и если x и y являются целыми числами, то значение, как и ожидалось, равно -1.

Если x — целое число, а y — беззнаковое, то значение этого выражения зависит от того, сколько бит имеет целое число на компилирующей машине. На нашей машине это выражение дает 4294967295.

Регистрировать переменные

Доступ к переменным регистров осуществляется быстрее по сравнению с переменными памяти. Итак, переменные, которые часто используются в C++ программу можно поместить в регистры с помощью зарегистрироваться ключевое слово. Ключевое слово Register указывает компилятору сохранить данную переменную в регистре. Помещать его в регистр или нет — выбор компилятора. Обычно компиляторы сами выполняют различные оптимизации, включая помещение некоторых переменных в регистр. Нет ограничений на количество регистровых переменных в C++ программа. Но компилятор не может сохранить переменную в регистре. Это связано с тем, что регистровая память очень ограничена и чаще всего используется ОС.

Определять:

register int i;

Комментарии

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

• Однострочные комментарии те, которые начинаются с // и продолжаются до конца строки. Если последний символ в строке комментария — \, то комментарий продолжится на следующей строке.
• Многострочные комментарии те, которые начинаются с /* и заканчиваются */.

/* This is a comment */
/* C++ comments can  also 
* span multiple lines 
*/

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

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

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

Наша команда C++ язык программирования определяет несколько escape-последовательностей:

Что он делает?	Характер
Новая линия	\n
Вертикальная табуляция	\v
бэкслэш	\\
Возврат каретки	\r
Горизонтальная вкладка	\t
Возврат на одну позицию	\b
Вопросительный знак	\?
Подача страницы	\f
Оповещение (звонок)	\a
Double цену	\ ”
Одинарные цитаты	\ '

Мы используем escape-последовательность, как если бы это был один символ:

cout << '\n';        // prints a newline
cout << "\tguru99!\n";   // prints a tab followed by "guru99!" and a newline 

Мы также можем написать обобщенные escape-последовательности \x, за которыми следуют одна или несколько шестнадцатеричных цифр. Или мы используем \, за которым следует одна, две или три восьмеричные цифры. Обобщенная escape-последовательность представляет числовое значение символа. Некоторые примеры (при условии использования набора символов Latin-1):

\7 (bell)    \12 (newline)      \40 (blank)
\0 (null)    \115 ('M')         \x4d ('M') 

Мы можем использовать заранее определенные escape-последовательности, как и любой другой символ.

cout << "Hi \x4dO\115!\n";  // prints Hi MOM! followed by a newline
cout << '\115' << '\n';     // prints M followed by a newline 

Резюме

• A C++ переменная предоставляет нам возможность именованного хранения.
• C++ Типы переменных: int, double, колесница, float, строка, bool и т. д.
• Содержимая (или вложенная) область называется внутренней областью, а содержащая область — внешней областью.
• Переменную одного типа можно преобразовать в другой. Это известно как «преобразование типов».
• Доступ к переменным регистров осуществляется быстрее по сравнению с переменными памяти.
• Комментарии — это части кода, игнорируемые компилятором.
• Некоторые символы, такие как символы возврата и управляющие символы, не имеют видимого изображения.