C++ Zmienne i typy danych: Int, Char, Float, Double

C++ Zmienne typy danych

C++ definiuje cały zestaw typów pierwotnych

unieważnić typ nie ma żadnych powiązanych wartości i może być używany tylko w kilku okolicznościach. Najczęściej jest to typ zwracany przez funkcje, które nie zwracają wartości.

typy arytmetyczne obejmują znaki, liczby całkowite, wartości logiczne i liczby zmiennoprzecinkowe. Typ arytmetyczny jest dalej dzielony na 2 kategorie

1. Typy zmiennoprzecinkowe. Typ float (lub float) reprezentuje liczby dziesiętne. Standard IEEE określa minimalną liczbę cyfr znaczących. Większość kompilatorów zwykle zapewnia większą precyzję niż określone minimum. Zazwyczaj floaty są reprezentowane przez 32 bity, double przez 64 bity, a long double przez 96 lub 128 bitów.
2. Typy integralne (które obejmują typy znakowe, całkowite i logiczne). The Boolean type ma tylko dwa typy wartości: True lub False. Istnieje kilka zwęglać typów, z których większość istnieje w celu wspierania internacjonalizacji. Najbardziej podstawowym typem znaku jest char. Znak ma ten sam rozmiar co pojedynczy bajt maszynowy, co oznacza pojedynczy bajt.

Typy integralne może być podpisany lub niepodpisany.

Podpisany typ: Reprezentują liczby ujemne lub dodatnie (w tym zero). W typie ze znakiem zakres musi być równo podzielony między wartościami +ve i -ve. Zatem 8-bitowy znak ze znakiem będzie zawierał wartości od –127 do 127.

Typ bez znaku: W typie bez znaku wszystkie wartości wynoszą >= 0. 8-bitowy znak bez znaku może zawierać liczby od 0 do 255 (włącznie).

Nazwa zmiennej lub identyfikatory

Identyfikatory mogą składać się z kilku liter, cyfr i znaku podkreślenia lub ich kombinacji. Nie ma ograniczeń co do długości nazwy.

Identyfikatory muszą

• zaczynać się od litery lub znaku podkreślenia („_”).
• I uwzględniają wielkość liter; wielkie i małe litery są różne:

// definiuje cztery różne zmienne typu int

int guru99, gurU99, GuRu99, GURU99;

C++ język zarezerwował pewne nazwy dla swojego użytku.

Istnieje wiele przyjętych konwencji nazewnictwa zmiennych w różne języki programowaniaPrzestrzeganie tych konwencji może poprawić czytelność programu.

• Identyfikator powinien przynajmniej w pewnym stopniu wskazywać na jego znaczenie.
• Nazwy zmiennych są zazwyczaj pisane małymi literami – guru99, nie Guru99 lub GURU99.
• Definiowane przez nas klasy zwykle zaczynają się od dużej litery.
• Identyfikatory zawierające wiele słów powinny wizualnie rozróżniać każde słowo. Na przykład witryna_guru99, a nie witryna guru99.

C++ Deklaracja i definicja zmiennej

Deklaracja zmiennej powoduje, że nazwa jest znana programowi w zakresie, w jakim jest zdefiniowana. Przykład:

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

int a,b;
a=b=1000;

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

Kwalifikator stałej w C++

Załóżmy, że istnieje zmienna buffsize, która określa liczbę danych wejściowych, które należy pobrać od użytkownika. Tutaj nie chcemy zmieniać wartości buffsize w całym programie. Chcemy zdefiniować zmienną, której wartość wiemy, że nie powinna się zmieniać.

W takim przypadku użyj słowa kluczowego const

const int bufSize = 512;    // input buffer size

Definiuje to bufSize jako stałą. Każda próba przypisania lub zmiany bufSize kończy się błędem.

Tutaj nie możemy zmienić wartości obiektu const po jego utworzeniu, musi on być obowiązkowo zadeklarowany i zainicjowany. W przeciwnym razie kompilator zgłosi błąd.

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 

Zakres zmiennych w C++

Zakres to zakres programu, w którym zmienna ma znaczenie. Przeważnie ta sama nazwa może być używana w odniesieniu do różnych podmiotów w różnych zakresach. Zmienne są widoczne od momentu ich zadeklarowania aż do końca zakresu, w którym występuje ich deklaracja.

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

Ten program definiuje 3 nazwy, tj. main, sum i val. Używa nazwy przestrzeni nazw std, wraz z dwiema innymi nazwami z tej przestrzeni nazw — cout i endl.

• Nazwa funkcji „main” jest zdefiniowana poza nawiasami klamrowymi. Nazwa funkcji main — podobnie jak większość innych nazw zdefiniowanych poza funkcją — ma zasięg globalny. Co oznacza, że ​​po zadeklarowaniu nazwy znajdujące się na Zakres globalny są dostępne w całym programie.
• Suma zmiennej jest definiowana w zakresie bloku będącego treścią funkcji głównej. Dostęp do niej można uzyskać z miejsca deklaracji oraz w pozostałej części treści głównej funkcji. Jednak nie poza nim. Oznacza to, że suma zmienna ma zakres bloku.
• Zmienna val jest zdefiniowana w zakresie instrukcji „for”. Można go z łatwością użyć w tym stwierdzeniu, ale nie gdzie indziej w funkcji głównej. To ma zasięg lokalny.

Zagnieżdżony zakres

Zakres może zawierać inne zakresy. Zawarty (lub zagnieżdżony) zakres nazywany jest zakresem wewnętrznym. Zakres zawierający jest zakresem zewnętrznym.

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

Wyjście nr 1 pojawia się przed lokalną definicją ponownego użycia. Zatem to wyjście

instrukcja to ta, która używa nazwy reused zdefiniowanej w zasięgu globalnym. To stwierdzenie wyprowadza

42 0

Wyjście nr 2 występuje po lokalnej definicji ponownego wykorzystania. Teraz ma to swój zakres. Dlatego ta druga instrukcja wyjściowa po prostu używa obiektu lokalnego o nazwie reused, a nie obiektu globalnego i wyników

0 0

Wyjście nr 3 zastępuje domyślny scoping zasady korzystania z operator zakresu. Zakres globalny nie ma nazwy. Tak więc, gdy operator zakresu (::) ma pustą lewą stronę. Interpretuje to jako żądanie pobrania nazwy po prawej stronie zakresu globalnego. Tak więc wyrażenie używa globalnego ponownego użycia i wyprowadza

42 0

Konwersja typu zmiennej

Zmienną jednego typu można przekształcić w inny. Nazywa się to „konwersją typów”. Zobaczmy zasady konwersji różnych C++ typy zmiennych:

Przypisanie zmiennej typu bool wartości innej niż bool zwraca false, jeśli wartość wynosi 0, a true w przeciwnym wypadku.

bool b = 42;            // b is true

Przypisanie wartości bool do jednego z pozostałych typów arytmetycznych daje 1, jeśli wartość bool jest prawdziwa, i 0, jeśli wartość bool jest fałszywa.

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

Przypisanie wartości zmiennoprzecinkowej do zmiennej typu int daje wartość, która jest obcinana. Zapisana wartość to część przed przecinkiem dziesiętnym.

int i = 3.14;               // i has value 3

Przypisanie wartości int do zmiennej typu float powoduje, że część ułamkowa przyjmuje wartość zero. Precyzja jest zwykle tracona, jeśli liczba całkowita ma więcej bitów, niż może pomieścić zmienna zmiennoprzecinkowa.

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

Jeśli spróbujemy przypisać wartość spoza zakresu do zmiennej typu bez znaku, wynikiem będzie pozostała część wartości %(modulo)

Na przykład 8-bitowy typ znaku bez znaku może przechowywać wartości od 0 do 255 włącznie. Przypisanie wartości spoza tego zakresu spowoduje, że kompilator przypisze resztę tej wartości modulo 256. Dlatego też, zgodnie z powyższą logiką, przypisanie –1 do 8-bitowego znaku bez znaku nadaje temu obiektowi wartość 255.

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

Jeśli spróbujemy przypisać wartość spoza zakresu do obiektu typu podpisanego, wynik będzie nieprzewidywalny. Jest nieokreślone. Program może wydawać się działać na zewnątrz, może ulec awarii lub może generować wartości śmieciowe.

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

Kompilator stosuje ten sam typ konwersji, gdy używamy wartości jednego typu, gdy oczekiwana jest wartość innego typu.

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

Jeśli ta wartość = 0, wówczas warunek jest fałszywy; wszystkie inne (niezerowe) wartości dają prawdę. Zgodnie z tą samą koncepcją, gdy używamy boola w wyrażeniu arytmetycznym, jego wartość jest zawsze konwertowana na 0 lub 1. W rezultacie użycie boola w wyrażeniu arytmetycznym jest zwykle prawie na pewno nieprawidłowe.

Przestroga: nie mieszaj typów podpisanych i niepodpisanych

Wyrażenia łączące znaki ze znakiem i bez znaku mogą dawać zaskakujące i błędne wyniki, gdy wartość ze znakiem jest ujemna. Jak omówiono powyżej, wartości ze znakiem są automatycznie konwertowane na wartości bez znaku.

Na przykład w wyrażeniu arytmetycznym, takim jak

x* y

Jeśli x wynosi -1, a y wynosi 1 i jeśli zarówno x, jak i y są int, to zgodnie z oczekiwaniami wartość wynosi -1.

Jeśli x jest int, a y jest bez znaku, wartość tego wyrażenia zależy od liczby bitów liczby całkowitej na maszynie kompilującej. Na naszej maszynie to wyrażenie daje 4294967295.

Zarejestruj zmienne

Dostęp do zmiennych rejestrowych jest szybszy w porównaniu ze zmiennymi pamięciowymi. Tak więc zmienne, które są często używane w a C++ program można umieścić w rejestrach za pomocą zarejestrować słowo kluczowe. Słowo kluczowe Register mówi kompilatorowi, aby przechował daną zmienną w rejestrze. To wybór kompilatora, czy umieścić go w rejestrze, czy nie. Generalnie kompilatory same dokonują różnych optymalizacji, które obejmują umieszczenie niektórych zmiennych w rejestrze. Nie ma ograniczeń co do liczby zmiennych rejestrowych w pliku a C++ program. Ale kompilator może nie przechowywać zmiennej w rejestrze. Dzieje się tak dlatego, że pamięć rejestrów jest bardzo ograniczona i jest najczęściej używana przez system operacyjny.

W celu określenia:

register int i;

Komentarze

Komentarze to fragmenty kodu ignorowane przez kompilator. Umożliwia programiście robienie notatek w odpowiednich obszarach kodu źródłowego/programu. Komentarze mają formę bloków lub pojedynczych wierszy. Komentarze do programu mają charakter objaśniający. Można go zaliczyć do C++ kod, który pomaga każdemu przeczytać jego kod źródłowy. Wszystkie języki programowania umożliwiają jakąś formę komentarzy. C++ obsługuje zarówno komentarze jednoliniowe, jak i wielowierszowe.

• Komentarze jednowierszowe to te, które zaczynają się od // i trwają do końca linii. Jeśli ostatnim znakiem w wierszu komentarza jest \, komentarz będzie kontynuowany w następnym wierszu.
• Komentarze wielowierszowe to te, które zaczynają się od /* i kończą na */.

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

Sekwencje ewakuacyjne

Niektóre znaki, takie jak backspace i znaki kontrolne, nie mają widocznego obrazu. Takie znaki są znane jako znaki niedrukowalne. Inne znaki (pojedyncze i podwójne cudzysłowy, znak zapytania i ukośnik odwrotny) mają specjalne znaczenie w wielu językach programowania.

Nasze programy nie mogą bezpośrednio używać żadnego z tych znaków. Zamiast tego możemy użyć sekwencji ucieczki do reprezentowania takiego znaku. Sekwencja ucieczki rozpoczyna się od ukośnika odwrotnego.

C++ język programowania definiuje kilka sekwencji ucieczki:

Używamy sekwencji ucieczki tak, jakby był to pojedynczy znak:

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

Możemy także napisać uogólnione sekwencje specjalne \x, po których następuje jedna lub więcej cyfr szesnastkowych. Lub używamy znaku \, po którym następuje jedna, dwie lub trzy cyfry ósemkowe. Uogólniona sekwencja ucieczki reprezentuje wartość liczbową znaku. Kilka przykładów (zakładając zestaw znaków Latin-1):

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

Możemy użyć predefiniowanych sekwencji ucieczki, tak jak używamy dowolnego innego znaku.

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

FAQ