C++ Променливи и типове: Int, Char, Float, Double, String & Bool

C++ Променливи типове данни

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

- анулира type няма свързани стойности с него и може да се използва само при няколко обстоятелства. Най-често се използва като тип връщане на функции, които не връщат стойност.

- аритметични видове включват знаци, цели числа, булеви стойности и числа с плаваща запетая. Аритметичен тип, ако се раздели допълнително на 2 категории

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

- Интегрални типове може да бъде подписан или неподписан.

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

Неподписан тип: В неподписан тип всички стойности са >= 0. 8-битов неподписан char може да съдържа 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};

Const Квалификатор в C++

Да предположим, че има променлива buffsize, която посочва броя на входовете, които трябва да бъдат взети от потребителя. Тук не искаме да променяме стойността на buffsize в цялата програма. Искаме да дефинираме променлива, чиято стойност знаем, че не трябва да се променя.

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

const int bufSize = 512;    // input buffer size

Това дефинира bufSize като константа. Всеки опит за присвояване или промяна на bufSize дава грешка.

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

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;	
}	 

Тази програма дефинира 3 имена, а именно, main, sum и val. Той използва името на пространството от имена std, заедно с две други имена от това пространство от имена - cout и endl.

• Името на функцията „main“ е дефинирано извън фигурните скоби. Името на функцията main - както повечето други имена, дефинирани извън функция - има глобален обхват. Което означава, че веднъж декларирани, имената, които са в глобален обхват са достъпни в цялата програма.
• Променливата сума е дефинирана в обхвата на блока, който е тялото на основната функция. Той може да бъде достъпен от точката на деклариране и в останалата част от тялото на основната функция. Но не и извън него. Това означава, че променливата сума има блоков обхват.
• Променливата val е дефинирана в обхвата на “for statement”. Може лесно да се използва в този оператор, но не и другаде в основната функция. Има локален обхват.

Вложен обхват

Обхватът може да съдържа други обхвати. Съдържащият се (или вложен) обхват се нарича вътрешен обхват. Съдържащият обхват е външният обхват.

#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++ типове променливи:

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

bool b = 42;            // b is true

Присвояването на bool на един от другите аритметични типове дава 1, ако bool е true, и 0, ако bool е false.

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-битов unsigned char тип може да съдържа стойности от 0 до 255 включително. Присвояването на стойност извън този диапазон ще доведе до това компилаторът да присвои остатъка от тази стойност по модул 256. Следователно, по логиката по-горе, присвояването на –1 на 8-битов неподписан char дава на този обект стойността 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, тогава условието е невярно; всички други (различни от нула) стойности дават истина. Съгласно същата концепция, когато използваме bool в аритметичен израз, неговата стойност винаги се преобразува в 0 или 1. В резултат на това използването на bool в аритметичен израз обикновено е почти сигурно неправилно.

Внимание: Не смесвайте подписани и неподписани типове

Изрази, които смесват знак и без знак, могат да дадат изненадващи и грешни резултати, когато стойността със знак е отрицателна. Както беше обсъдено по-горе, стойностите със знак се преобразуват автоматично в неподписани.

Например в аритметичен израз като

x* y

Ако x е -1 и y е 1 и ако x и y са int, тогава стойността е, както се очаква, -1.

Ако x е int и y са без знак, тогава стойността на този израз зависи от това колко бита има цяло число на компилиращата машина. На нашата машина този израз дава 4294967295.

Регистрирайте променливи

Променливите в регистрите са по-бързи за достъп в сравнение с променливите в паметта. И така, променливите, които често се използват в a C++ програмата може да бъде поставена в регистри с помощта на регистрирам ключова дума. Ключовата дума register казва на компилатора да съхранява дадената променлива в регистър. Изборът на компилатора е дали да го постави в регистър или не. Като цяло самите компилатори правят различни оптимизации, които включват поставяне на някои от променливите в регистъра. Няма ограничение за броя на регистърните променливи в a C++ програма. Но компилаторът може да не съхранява променливата в регистър. Това е така, защото паметта на регистъра е много ограничена и най-често се използва от операционната система.

За да определите:

register int i;

Коментари

Коментарите са частите от кода, игнорирани от компилатора. Тя позволява на програмиста да прави бележки в съответните области на изходния код/програмата. Коментарите идват или в блокова форма, или в единични редове. Коментарите по програмата са обяснителни изявления. Може да се включи в C++ код, който помага на всеки, който чете неговия изходен код. Всички езици за програмиране позволяват някаква форма на коментари. C++ поддържа както едноредови, така и многоредови коментари.

• Едноредови коментари са тези, които започват с // и продължават до края на реда. Ако последният знак в ред за коментар е \, тогава коментарът ще продължи в следващия ред.
• Многоредови коментари са тези, които започват с /* и завършват с */.

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

Ескейп последователности

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

Нашите програми не могат да използват нито един от тези знаци директно. Вместо това можем да използваме екранираща последователност, за да представим такъв char. Екранираща последователност започва с обратна наклонена черта.

- C++ програмен език дефинира няколко изходни последователности:

Какво прави той?	Характер
Нова линия	\n
Вертикален раздел	\v
Обратна наклонена черта	\\
Връщане на каретата	\r
Хоризонтален раздел	\t
Backspace	\b
Въпросителен знак	\?
Formfeed	\f
Предупреждение (звънец)	\a
Double цитирам	\ "
Единичен цитат	\'

Използваме екранираща последователност, сякаш е един знак:

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

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

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

Можем да използваме предварително дефинирани екраниращи последователности, както използваме всеки друг символ.

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

Oбобщение

• A C++ променливата ни предоставя възможност за наименувано съхранение.
• C++ типове променливи: int, double, овъглявам, float, string, bool и др.
• Съдържащият се (или вложен) обхват се нарича вътрешен обхват, а съдържащият обхват е външен обхват.
• Променлива от един тип може да се преобразува в друг. Известно е като „Преобразуване на типа“.
• Променливите в регистрите са по-бързи за достъп в сравнение с променливите в паметта.
• Коментарите са частите от кода, игнорирани от компилатора.
• Някои символи, като символи за връщане назад и контролни знаци, нямат видимо изображение.