Toate tipurile de date c. Tipuri de date

Variabilele sunt folosite pentru a stoca diverse date în limbaje de programare. O variabilă este o zonă de memorie care are un nume, altfel numit identificator.

Dăruind numele variabilei, programatorul denumește în același timp zona de memorie în care se vor scrie valorile variabilei pentru stocare cu același nume.

Este un stil bun să numești variabilele în mod semnificativ. Este permisă folosirea literelor mici și majuscule, cifre și un caracter de subliniere, care este considerată o literă în C. Primul caracter trebuie să fie o literă și nu trebuie să existe spații în numele variabilei. În versiunile moderne ale compilatoarelor, lungimea numelui este practic nelimitată. Numele variabilei nu poate corespunde cuvintelor cheie rezervate. Capitalele și litere mici numele variabilelor diferă, variabile oŞi O- variabile diferite.

Cuvinte cheie rezervate auto double int struct break else lung comutare registru tupedef char extern return void case float unsigned implicit pentru uniunea semnată do if sizeof volatile continue enumerarea scurtă
În C, toate variabilele trebuie declarate. Aceasta înseamnă că, în primul rând, la începutul fiecărui program sau funcție trebuie să furnizați o listă cu toate variabilele utilizate și, în al doilea rând, să indicați tipul fiecăreia dintre ele.

Când o variabilă este declarată, compilatorul îi alocă spațiu de memorie în funcție de tipul acesteia. Prin mijloace standard AVR GCC funcționează cu tipuri de date char(tip de caracter) și int(tip întreg).

Tipuri variabile

Tastați char

char- este cel mai economic tip. Tipul de caracter poate fi semnat sau nesemnat. Notat în consecință ca „ semnat char„ (tip semnat) și „ nesemnat char" (tip nesemnat). Tipul semnat poate stoca valori în intervalul de la -128 la +127. Unsigned - de la 0 la 255. O variabilă char are 1 octet de memorie (8 biți).

Cuvinte cheie (modificatoare) semnatŞi nesemnat indicați modul în care este interpretat bitul zero al variabilei declarate, adică dacă este specificat cuvântul cheie fără semn, atunci bitul zero este interpretat ca parte a unui număr, în caz contrar bitul zero este interpretat ca semnat.

Tastați int

Valoare întreagă int Pot fi scurt(scurt) sau lung(lung).

Cuvânt cheie (modificator) scurt plasat după cuvinte cheie semnat sau nesemnat. Astfel, se disting următoarele tipuri: signed short int, unsigned short int, signed long int, unsigned long int.

Variabila de tip semnat scurt int(întreg scurt cu semn) poate lua valori de la -32768 la +32767, unsigned short int(întreg scurt fără semn) - de la 0 la 65535. Pentru fiecare dintre ei sunt alocați exact doi octeți de memorie (16 biți).

La declararea unei variabile de tip semnat scurt int cuvinte cheie semnatŞi scurt poate fi omis, iar un astfel de tip de variabilă poate fi declarat simplu int. De asemenea, este posibil să declarați acest tip cu un singur cuvânt cheie scurt.

Variabilă unsigned short int poate fi declarat ca nesemnat int sau scurt nesemnat.

Pentru fiecare dimensiune semnat lung int sau nesemnat lung int Sunt alocați 4 octeți de memorie (32 de biți). Valorile variabilelor de acest tip pot fi în intervalele de la -2147483648 la 2147483647 și, respectiv, de la 0 la 4294967295.

Există și variabile precum lung lung int, pentru care sunt alocați 8 octeți de memorie (64 de biți). Ele pot fi, de asemenea, semnate sau nesemnate. Pentru un tip semnat, intervalul de valori este de la -9223372036854775808 la 9223372036854775807, pentru un tip nesemnat - de la 0 la 18446744073709551615. Un tip semnat poate fi declarat pur și simplu prin două cuvinte cheie lung lung.

Tip Gamă Gama hexagonală Dimensiune
nesemnat char 0 ... 255 0x00...0xFF 8 biți
semnat char
sau doar
char
-128 ... 127 -0x80...0x7F 8 biți
unsigned short int
sau doar
nesemnat int sau scurt nesemnat
0 ... 65535 0x0000 ... 0xFFFF 16 biți
semnat scurt int sau semnat int
sau doar
scurt sau int
-32768 ... 32767 0x8000...0x7FFF 16 biți
nesemnat lung int
sau doar
nesemnat lung
0 ... 4294967295 0x00000000 ... 0xFFFFFFFF 32 de biți
semnat lung
sau doar
lung
-2147483648 ... 2147483647 0x80000000 ... 0x7FFFFFFF 32 de biți
nesemnat lung lung 0 ... 18446744073709551615 0x0000000000000000 ... 0xFFFFFFFFFFFFFFFFFF pe 64 de biți
semnat lung lung
sau doar
lung lung
-9223372036854775808 ... 9223372036854775807 0x8000000000000000 ... 0x7FFFFFFFFFFFFFFF pe 64 de biți

Variabilele sunt declarate într-o declarație. O instrucțiune de declarație constă dintr-o specificație de tip și o listă de nume de variabile separate prin virgulă. Trebuie să existe un punct și virgulă la sfârșit.

O declarație variabilă are următorul format:

[modificatoare] type_specifier identificator [, identificator] ...

Modificatori- cuvinte cheie semnat, nesemnat, scurt, lung.
Specificator de tip- cuvânt cheie char sau int, care determină tipul variabilei declarate.
Identificator- numele variabilei.

Exemplu: char x;
int a, b, c; nesemnat long long y;, o, În acest fel variabilele vor fi declarate, x, b c nesemnat long long y; y o, În acest fel variabilele vor fi declarate, x. La o variabilă b se vor putea scrie valori de la -128 la 127. În variabile

- de la -32768 la +32767. La o variabilă

- de la 0 la 18446744073709551615. nesemnat long long y; Inițializarea valorii unei variabile la declarare

Este mai bine să evitați amestecarea variabilelor inițializate într-o singură declarație, adică este mai bine să declarați variabilele inițializate pe linii separate.

constante

O variabilă de orice tip poate fi declarată nemodificabilă. Acest lucru se realizează prin adăugare cuvânt cheie const la specificatorul de tip. Variabile cu tip const sunt date numai pentru citire, ceea ce înseamnă că variabilei nu i se poate atribui o nouă valoare. Dacă după cuvânt const Dacă nu există un specificator de tip, atunci constantele sunt tratate ca valori semnate și li se atribuie un tip int sau lung intîn funcție de valoarea constantei: dacă constanta este mai mică de 32768, atunci i se atribuie tipul int, altfel lung int.

Exemplu: const long int k = 25; const m = -50;// implicit const int m=-50 const n = 100000;

// implicit const long int n=100000

Misiunea

Semnul „=" este folosit pentru atribuire în C. Se evaluează expresia din dreapta semnului de atribuire, iar valoarea rezultată este atribuită variabilei din stânga semnului de atribuire. În acest caz, valoarea anterioară stocată în variabilă este ștearsă și înlocuită cu una nouă.
Operatorul „=" nu trebuie înțeles ca egalitate.

De exemplu, expresia a = 5; ar trebui citit ca „atribuiți variabila a la 5”. Exemple: x = 5 + 3;// adăugați valorile 5 și 3, // atribuiți rezultatul variabilei x (scrieți variabilei x) b = a + 4;// adăugați 4 la valoarea stocată în variabila a, // atribuiți rezultatul rezultat variabilei b (scrieți variabilei b) b = b + 2;
// adăugați 2 la valoarea stocată în variabila b, // atribuiți rezultatul rezultat variabilei b (scrieți variabilei b)

În partea dreaptă, valoarea variabilei poate fi folosită de mai multe ori: c = b * b + 3 * b; Exemplu: x = 3;// variabilei x i se va atribui valoarea 3 y = x + 5;// numărul 5 va fi adăugat la valoarea stocată în variabila x, // rezultatul rezultat va fi scris în variabila y z = x * y;// valorile variabilelor x și y vor fi înmulțite, // rezultatul va fi scris în variabila z z = z - 1;
// 1 va fi scăzut din valoarea stocată în variabila z // rezultatul va fi scris în variabila z Astfel, în variabila z

numărul 23 va fi stocat Cu excepţia operator simplu
atribuiri "=", în C există mai mulți operatori de atribuire combinați: "+=", "-=", "*= Exemple: x += y;// la fel ca x = x + y; - se adaugă x și y // și se scrie rezultatul la variabila x // la fel ca x = x - y; - se scade valoarea y din x // si se scrie rezultatul in variabila x x *= y; // la fel ca x = x * y; - înmulțiți x cu y // și scrieți rezultatul în variabila x x /= y; // la fel ca x = x / y; - împărțiți x la y // și scrieți rezultatul în variabila x x %= y; // la fel ca x = x % y; // calculează rest întreg

din împărțirea x la y // și scrieți rezultatul în variabila x

Creșteți și descreșteți Dacă trebuie să modificați valoarea unei variabile la 1, atunci utilizați sau creştere.

scăderea Creştere

- operația de creștere a valorii stocate într-o variabilă cu 1. Exemplu: x++;// valoarea variabilei x va fi mărită cu 1
$WinAVR = ($_GET["avr"]); if($WinAVR) include($WinAVR);?> Decrementează

- operatia de scadere a valorii stocate intr-o variabila cu 1. Exemplu: x--;
// valoarea variabilei x va fi redusă cu 1

Creșterea și descreșterea sunt operatori de atribuire. Când utilizați decrementarea și creșterea împreună cu operatorul de atribuire "=", utilizați notația postfix (x++) sau prefix (++x). Prefixul este executat mai întâi.
Exemple: y = x++; nesemnat long long y; Să presupunem că în variabilă b valoarea 5 a fost stocată nesemnat long long y; se va scrie valoarea 5, după care valoarea variabilei b va fi majorat cu 1. Astfel, in nesemnat long long y; va fi 5, iar în
- 6. y = --x; nesemnat long long y; Dacă în nesemnat long long y; Dacă valoarea 5 a fost stocată, atunci decrementarea va fi efectuată mai întâi b la 4 și apoi această valoare va fi atribuită variabilei nesemnat long long y;Şi b. Astfel,

i se va atribui valoarea 4. În această lecție vei învăța Alfabetul limbajului C++ , și, de asemenea, ce tipuri de date

  • programul îl poate procesa. Poate că acesta nu este cel mai interesant moment, dar aceste cunoștințe sunt necesare În plus, atunci când începi să înveți orice alt limbaj de programare, vei trece printr-o etapă similară de învățare cu mai multă încredere! Un program C++ poate conține următoarele simboluri:
  • litere mari, minuscule latine A, B, C..., x, y, z și liniuță;
  • cifre arabe de la 0 la 9;< > = ! & # ~ ; ^
  • caractere speciale: ( ) , | , () + - / % * . \‘ : ? caractere de spațiu, tab și escape.

linie nouă În testarea programului puteți utiliza comentarii

. Dacă textul conține două caractere oblică // și se termină cu un caracter de linie nouă sau este cuprins între caracterele /* și */, atunci compilatorul îl ignoră.

Date în C++ Pentru a rezolva o problemă, orice program prelucrează unele date. Ele pot fi de diferite tipuri: numere întregi și reale, caractere, șiruri de caractere, matrice. În C++, datele sunt de obicei descrise la începutul funcției. LA limbile includ:

Pentru a genera alte tipuri de date, de bază și așa-zise specificatorii. C++ definește patru specificatori de tip de date:

  • scurt - scurt;
  • lung - lung;
  • semnat - semnat;
  • nesemnat - nesemnat.

Tipul întreg

Variabila de tip intîn memoria computerului poate ocupa fie 2, fie 4 octeți. Depinde de dimensiunea biților procesorului. În mod implicit, toate tipurile întregi sunt considerate semnate, adică specificatorul semnat poate să nu fie specificat. Specificator nesemnat vă permite să reprezentați numai numere pozitive. Mai jos sunt câteva intervale de valori de tip întreg

Tip Gamă Dimensiune
int -2147483648…2147483647 4 octeți
nesemnat int 0…4294967295 4 octeți
semnat int -2147483648…2147483647 4 octeți
scurt int -32768…32767 2 octeți
lung int -2147483648…2147483647 4 octeți
unsigned short int 0…65535 2 octeți

Tip real

Un număr în virgulă mobilă este reprezentat sub forma mE +- p, unde m este mantisa (număr întreg sau fracționar cu virgulă zecimală), p este exponentul (întreg). De obicei valori precum plutire ocupă 4 octeți și dubla 8 octeți. Tabel cu intervale de valori reale:

plutire 3.4E-38…3.4E+38 4 octeți
dubla 1.7E-308…1.7E+308 8 octeți
dublu lung 3.4E-4932…3.4E+4932 8 octeți

tip boolean

Variabila de tip bool poate lua doar două valori adevărat ( adevărat ) sau fasle ( minciună ). Orice valoare care nu este egală cu zero este interpretată ca adevărat. Sens fals reprezentat în memorie ca 0.

tip void

Setul de valori de acest tip este gol. Este folosit pentru a defini funcții care nu returnează o valoare, pentru a specifica o listă goală de argumente ale funcției, cum ar fi tip de bază pentru pointeri și în operațiunile de turnare a tipului.

Conversia tipului de date

În C++, există două tipuri de conversie a tipurilor de date: explicită și implicită.

  • Conversie implicită se întâmplă automat. Acest lucru se face în timpul comparării, atribuirii sau evaluării expresiilor de diferite tipuri. De exemplu, programul următor va scoate în consolă o valoare de tip plutire

#include „stdafx.h” #include folosind namespace std; int main() ( int i=5; float f=10,12; cout<>void"); returnează 0; )

#include „stdafx.h”

#include

folosind namespace std;

int main()

int i = 5 ; float f = 10,12;

cout<< i / f ;

sistem ("pause>>void" );

returnează 0;

Cea mai mare prioritate este acordată tipului în care se pierde cea mai mică cantitate de informații. Nu ar trebui să folosiți în exces conversia de tip implicit, deoarece pot apărea diverse situații neprevăzute.

  • Conversie explicită spre deosebire de implicit, este realizat de programator. Există mai multe moduri de a face această conversie:
  1. Conversia la stiluri C: (plutitor) a
  2. Conversia la stiluri C++: float()

Turnarea tipului poate fi efectuată și folosind următoarele operații:

static_cast<>() const_cast<>() reinterpret_cast<>() dynamic_cast<> ()

static_cast<> ()

const_cast<> ()

reinterpret_cast<> ()

dynamic_cast<> ()

static_cas- convertește tipurile de date aferente. Acest operator aruncă tipuri în conformitate cu regulile obișnuite, care pot fi necesare atunci când compilatorul nu efectuează conversie automată. Sintaxa va arăta astfel:

Tastați static_cast<Тип>(obiect);

Folosind static_cast, nu puteți elimina constanța dintr-o variabilă, dar următorul operator o poate face. const_cast- se foloseste numai atunci cand este necesara indepartarea constanței unui obiect. Sintaxa va arăta astfel:

Tipconst_cast< Tip> (obiect);

reinterpret_cast- folosit pentru a converti diferite tipuri, întreg în pointer și invers. Dacă vedeți un cuvânt nou „index” - nu vă alarmați! Acesta este, de asemenea, un tip de date, dar nu vom lucra cu el în curând. Sintaxa de aici este aceeași cu cea a operatorilor discutați anterior:

Tipreinterpreta_turnați< Tip> (obiect);

dynamic_cast- folosit pentru conversie dinamică tipează, implementează turnarea de pointeri sau referințe. Sintaxă:

Tipdinamic _turnați< Tip> (obiect);

Personaje de control

Sunteți deja familiarizat cu unele dintre aceste „personaje de control” (de exemplu, cu \n). Toate încep cu o bară oblică inversă și sunt, de asemenea, înconjurate de ghilimele duble.

Imagine

Cod hexadecimal

Nume

Sunete beeper

Întoarce-te cu un pas

Traducerea paginii (format)

Alimentare de linie

Retur cu transportul

Tabulare orizontală

Filă verticală

Răspuns:
  1. Tipuri de date întregi:

short int, unsigned short int, int, unsigned int, long, unsigned long.

  1. Tipuri de date în virgulă mobilă (corespunzător tipurilor reale):

plutitor, dublu, dublu lung.

  1. Tip de date caracter:

char (caracter semnat), caracter nesemnat, wchar_t.

  1. Tipul de date boolean:

bool.

  1. Tip de date enumerate (introdus în Visual C++):

enumerare.

2. Care sunt caracteristicile utilizării tipurilor de date întregi?

În C++ principalul tipuri de numere întregi date: short int, unsigned short int, int, unsigned int, long (long int), unsigned long (unsigned long int).

Aceste tipuri de date reprezintă valori dintr-un set de numere întregi. De exemplu:

2 -100 398

Tipurile de date care încep cu prefixul fără semn pot conține numai numere pozitive.

Datele de tip short int, unsigned short int ocupă jumătate din spațiul de memorie decât datele de tip int, unsigned int.

Datele de tip long, unsigned long ocupă de două ori mai mult spațiu de memorie decât datele de tip int, unsigned int.

3. Cum se descrie o variabilă numită x de tip întreg într-un program?

Răspuns:
int x; // număr întreg cu semn

Ca urmare, sub variabila nesemnat long long y; va fi alocat un spațiu de memorie de 4 octeți. Mărimea memoriei alocate pentru o variabilă depinde de caracteristicile computerului, tip sistem de operareși setările compilatorului.

4. Cum se scrie numărul 239 într-o variabilă de tip întreg?

Pentru a face acest lucru, utilizați operatorul de atribuire, care este notat cu simbolul „=”.

Raspunsul 1. Introducerea unui număr într-o variabilă după descrierea acesteia.

int x; x = 239;

Raspunsul 2. Introducerea unui număr într-o variabilă în timpul descrierii acesteia (inițializarea inițială).

int x = 239;

5. Care sunt caracteristicile tipurilor de date în virgulă mobilă?

Tipurile de date cu virgulă mobilă vă permit să reprezentați valori dintr-un set de numere reale. De exemplu:

8.35 -990.399 239.0.

C++ are următoarele tipuri de date de bază în virgulă mobilă:

plutitor, dublu, dublu lung.

O variabilă de tip double ocupă de 2 ori mai mult spațiu în memoria computerului decât o variabilă de tip float.

De asemenea, o variabilă de tip dublu lung ocupă de 2 ori mai mult spațiu în memoria computerului decât o variabilă de tip dublu.

6. Cum se descrie o variabilă care ia o valoare în virgulă mobilă?

Un exemplu de descriere a variabilelor tipurilor float, double, long double:

plutitor f; dublu d; lung dublu ld;

7. Cum se scrie valori numerice într-o variabilă în virgulă mobilă?

Un exemplu de introducere a datelor numerice în variabile cu virgulă mobilă:

float f = -9928,45; // initializarea initiala dublu d; lung dublu ld; d = 0,445332; // operator de atribuire ld = 3892923898239,030903; // operator de atribuire

8. Cum se transformă o variabilă float într-un tip int?

Pentru a face acest lucru, se folosește operația de turnare tip. Între paranteze trebuie să indicați numele tipului la care este distribuită distribuția.

plutire a; int b; a = 8,457; b = (int ) a; // b = 8

Când utilizați operațiuni de turnare a tipurilor, trebuie să țineți cont de restricțiile impuse tipurilor care ocupă mai puțin spațiu în memoria computerului.

De exemplu, o variabilă de tip short int poate reprezenta un interval mai mic de numere decât variabilele de tip float sau double. Următoarea listă depășește o valoare într-o variabilă de tip short int:

scurt int i; plutitor f; f = 3990099,8; i = (int )f; // i = -7597 - preaplin

9. Cum se transformă o variabilă de la tipul int la tipul double?

Exemplu de turnare de la int la dublu:

int i; dublu d; i = 982; d = (dublu)i; // d = 982,0

10. Care sunt caracteristicile utilizării datelor de caractere (date de caractere) într-un program?

Datele de tip char reprezintă valoarea caracterului codului introdus de la tastatură. Codul simbolului este un număr întreg.

De exemplu, codul caracterului „f” este 102.

Un fragment de cod care calculează codul caracterului:

cod int; simbol char; simbol = "f" ; cod = (int )simbol; // cod = 102

Datele de tip char sunt aceleași numere întregi. Datele de tip char ocupă 1 octet în memoria computerului.

Relația caracter-cod este localizată în tabelul de simboluri Windows. Caracterele cu coduri de la 0 la 127 sunt caractere rezervate BIOS. Acestea includ cele mai frecvent utilizate simboluri, simboluri numerice și simboluri latine. Aceste caractere nu pot fi modificate.

Caracterele cu coduri de la 128 la 255 sunt caractere regionale care sunt legate de un anumit alfabet al computerului pe care este instalat sistemul de operare Windows.

11. Care sunt caracteristicile utilizării tipului de date bool (tip logic)?

Variabilele de tip bool pot lua doar două valori:

adevărat - adevăr,

fals - fals.

Aceste variabile sunt folosite pentru a testa expresiile booleene. Valoarea numerică a adevăratului este 1. Valoarea numerică a lui false este 0.

Fragment de cod care definește cifrele valori adevărate si fals:

int rezultat; bool b; rezultat = (int)adevărat; // rezultat = 1 b = fals; rezultat = (int )b; // rezultat = 0

Fragment de cod care convertește tipurile int și float în bool:

int i; plutitor f; bool b; i = 6; b = (bool )i; // b = Adevărat f = 0,0; b = (bool )f; // b = Fals

12. Cum se determină dimensiunea memoriei ocupată de o variabilă de un anumit tip?

Operația sizeof() este utilizată pentru aceasta.

Un fragment de cod care definește dimensiunea unor tipuri de date:

int d; d = dimensiunea(car); // d = 1 d = sizeof(unsigned int); // d = 4 d = sizeof(float); // d = 4 d = dimensiunea(dublu); // d = 8

13. Cum sunt inițializate variabilele de diferite tipuri?

int d = 28; float z = (float )2,85; char c = "k" ; String ^s = „Bună ziua!” ; dublu r = -8,559;

14. Cum se determină valoarea maximă admisibilă (minima admisibilă) a unei variabile de un anumit tip?

Pentru a determina valoarea maximă permisă sau minimă permisă a unei variabile de un anumit tip în . NET Framework Sunt utilizate proprietățile MaxValue și MinValue.

Exemple de determinare a valorilor limită ale variabilelor de diferite tipuri.

Pentru variabile de tip int:

// tastați int int i; lung MaxInt; lung MinInt; MaxInt = (lung )i.MaxValue; // MaxInt = 2147483647 MinInt = (lung )i.MinValue; // MinInt = -2147483648

Pentru variabile de tip short int:

// tastați short int short int si; int MaxInt; int MinInt; MaxInt = (int )si.MaxValue; // MaxInt = 32767 MinInt = (int )si.MinValue; // MinInt = -32768

Pentru variabile de tip unsigned int:

// tastați unsigned int unsigned int ui; unsigned int MaxInt; unsigned int MinInt; MaxInt = ui.MaxValue; // MaxInt = 4294967295 MinInt = ui.MinValue; // MinInt = 0

Pentru variabilele float:

// tip float plutitor f; float MaxF; plutitor MinF; MaxF = f.MaxValue; // MaxF = 3,402823E+38 MinF = f.MinValue; // MinF = -3,402823E+38

Pentru variabile de tip double:

// tip double dublu d; dublu MaxD; dublu minte; Max = d.MaxValue; // Max = 1,79769313486232E+308 Min = d.MinValue; // Min = -1,79769313486232E+308

Pentru variabile de tip char:

// tip char char c; int MaxC; int MinC; Max = (int )c.MaxValue; // Max = 127 Min = (int )c.MinValue; // Min = -128

15. Care sunt caracteristicile utilizării tipului de enumerare?

Tipul de enumerare este un tip de date de enumerare. Specifică valori mnemonice pentru seturi de valori întregi. Fiecare valoare mnemonică are un conținut specific și este reprezentată de un număr întreg.

Un exemplu de utilizare a tipului enum pentru a reprezenta lunile anului:

enumerarea lunilor ( ianuarie, februarie, martie, aprilie, mai, iunie, iulie, august, septembrie, octombrie, noiembrie, decembrie) mn; mn = ianuarie; // mn = 0 mn = martie; // mn = 2 mn = septembrie; // mn = 8

Exemplul de mai jos descrie o variabilă numită mn de tip enum months. Valorile mnemonice pentru luni (ianuarie, februarie, …) încep de la 0 (0, 1, 2, …). Mnemonicul ianuarie este valoarea întreagă 0, mnemonicul februarie este valoarea întreagă 1 și așa mai departe.

Deci, folosind tipul enum, mnemonicii pot fi folosite în textul programului pentru o mai bună claritate a codului sursă.

Puteți scrie și așa:

mn = (număr luni)2; // mn = martie mn = (număr luni)11; // mn = decembrie

16. Care sunt caracteristicile tipuluigol în programe peC++ ?

Tipul de date void este utilizat în următoarele cazuri:

  • dacă trebuie să descrii o funcție care nu returnează nicio valoare (vezi exemplu);
  • dacă trebuie să descrii o funcție care nu primește parametri (vezi exemplul).

Exemplu. MyFun() este o funcție fără parametri care nu returnează nicio valoare (returnează tipul void ) și nu acceptă parametri.

public : void MyFun(void ) { // corp de funcție // ... reveni; // întoarce de la o funcție care nu returnează o valoare } // apelează o funcție din program ... MyFun(); ...

17. Este posibil să se declare o variabilă de tipgol in program?

Acest lucru nu este posibil deoarece tipul void nu este asociat cu o valoare.

Declararea unei variabile de tip void are ca rezultat o eroare de compilare cu următorul mesaj:

„Utilizarea ilegală a tipului nul”

18. Care sunt caracteristicile tipuluiwchar_ t VVizual C++ ?

Variabilele de tip char (vezi paragrafele anterioare) sunt folosite pentru a stoca caractere ASCII pe 8 biți.

Tipul wchar_t este folosit pentru a stoca caractere care fac parte din seturi mari de caractere. De exemplu, alfabetul chinezesc are un număr mare de caractere. 8 cifre nu sunt suficiente pentru a reprezenta întregul set de caractere chinezești. Prin urmare, dacă trebuie să utilizați programul pe piața internațională, este recomandabil să înlocuiți tipul char cu wchar_t.

Exemplu folosind tipul wchar_t.

... wchar_t t; // Pentru variabila t sunt alocați 2 octeți de memorie t = „s”; ...

Tipurile de date din C sunt o clasă de date ale căror valori au caracteristici similare. Tipul definește reprezentarea internă a datelor în memorie. Cele mai de bază tipuri de date: logice, întregi, numere în virgulă mobilă, șiruri de caractere, pointeri.

Cu tastarea dinamică, o variabilă este asociată cu un tip în momentul inițializării. Se pare că o variabilă din diferite părți ale codului poate avea diferite tipuri. Tastare dinamică suportă Java Script, Python, Ruby, PHP.

Tastarea statică este opusul tastării dinamice. Când este declarată, o variabilă primește un tip care nu se schimbă ulterior. Limbajele C și C++ sunt doar atât. Această metodă este cea mai convenabilă pentru scrierea unui cod complex, iar multe erori sunt eliminate în etapa de compilare.

Limbile sunt împărțite în mod neoficial în tastate puternic și tip slab. Tastarea puternică înseamnă că compilatorul va arunca o eroare dacă tipurile așteptate și reale nu se potrivesc.

x = 1 + „2”; //eroare - nu puteți adăuga un simbol la un număr

Un exemplu de tastare slabă.

Verificarea coerenței tipului este efectuată de sistemul de siguranță a tipului. O eroare de tastare apare, de exemplu, atunci când încercați să utilizați un număr ca funcție. Există limbi netipizate. Spre deosebire de cele tastate, acestea vă permit să efectuați orice operație asupra fiecărui obiect.

Cursuri de memorie

Variabilele, indiferent de tipul lor, au propriul domeniu de aplicare și durata de viață.

Cursuri de memorie:

  • auto;
  • static;
  • extern;
  • registru.

Toate variabilele din limbajul C sunt locale în mod implicit. Ele pot fi utilizate numai într-o funcție sau bloc. Când funcția se finalizează, valoarea lor este distrusă.

O variabilă statică este de asemenea locală, dar poate avea o valoare diferită în afara blocului său, iar valoarea este reținută între apelurile de funcție.

Variabila externă este globală. Este disponibil în orice parte a codului și chiar într-un alt fișier.

Specificatorii tipului de date în C pot să nu fie specificați în următoarele cazuri:

  1. Toate variabilele din bloc nu sunt variabile prin urmare, dacă această clasă de memorie particulară este destinată să fie utilizată, atunci specificatorul automat nu este specificat.
  2. Toate funcțiile declarate în afara unui bloc sau funcție sunt globale în mod implicit, deci nu este necesar specificatorul extern.

Pentru a indica tipuri simple specificatorii int, char, float sau double sunt specificati. Modificatorii nesemnat, semnat, scurt, lung, lung lung pot fi înlocuiți cu variabile.

În mod implicit, toate numerele sunt semnate, prin urmare, pot fi doar în intervalul de numere pozitive. Pentru a defini o variabilă de tip char ca semnată, scrieți signed char. Long, long long și short indică cât spațiu de memorie este alocat pentru stocare. Cel mai mare este lung lung, cel mai mic este scurt.

Char este cel mai mic tip de date din C. Numai 1 octet de memorie este alocat pentru stocarea valorilor. Tip variabil caracterul este de obicei atribuit simbolurilor, mai rar numerelor. Valorile caracterelor sunt cuprinse între ghilimele.

Tipul int stochează numere întregi, dimensiunea acestuia este nedefinită - este nevoie de până la 4 octeți de memorie, în funcție de arhitectura computerului.

O conversie explicită a unei variabile fără semn este specificată după cum urmează:

Cea implicită arată așa:

Float și dublu definiți numerele cu un punct. Numerele flotante sunt reprezentate ca -2,3 sau 3,34. Double este folosit pentru o mai mare precizie - mai multe cifre sunt indicate după separatorul întreg și fracționar. Acest tip ocupă mai mult spațiu de memorie decât float.

Void are o valoare goală. Definește funcții care nu returnează nimic. Acest specificator specifică o valoare goală în argumentele metodei. Pointerii, care pot accepta orice tip de date, sunt, de asemenea, definiți ca nuli.

tip boolean Bool

Folosit în teste de stare și bucle. Are doar două semnificații:

  • adevărat;
  • minciună.

Valorile booleene pot fi convertite într-o valoare int. Adevărat este echivalent cu unu, fals este echivalent cu zero. Conversia tipului este posibilă numai între bool și int, altfel compilatorul va arunca o eroare.

if (x) ( //Eroare: „Nu se poate converti implicit tipul „int” în „bool””

if (x != 0) // Modul C#

Șiruri și matrice

Matricele sunt tipuri complexe de date în C. PL nu funcționează cu șiruri în același mod ca Javascript sau Ruby. În C, toate șirurile sunt matrice de elemente cu o valoare de caracter. Liniile se termină cu un octet nul „

Această foaie de cheat oferă informații despre principalele tipuri de date ale limbajului de programare C++ și caracteristicile implementării acestora. De asemenea, la sfârșitul înregistrării există un tabel cu intervalele de valori ale acestor tipuri.

Conceptul tipului de date

Scopul principal al oricărui program este prelucrarea datelor. Date diverse tipuri stocate și prelucrate diferit. În orice limbaj algoritmic Fiecare constantă, variabilă, expresie sau funcție trebuie să aibă un anumit tip.

Tipul de date definește:

  • Reprezentare internă a datelor în memoria computerului;
  • setul de valori pe care cantitățile de acest tip le pot lua;
  • operaţii şi funcţii care pot fi aplicate cantităţilor de acest tip.

Pe baza acestor caracteristici, programatorul selectează tipul fiecărei mărimi utilizate în program pentru a reprezenta obiecte reale. O declarație de tip obligatorie permite compilatorului să verifice validitatea diferitelor constructe de program. Tipul de valoare determină instrucțiunile mașinii care vor fi utilizate pentru prelucrarea datelor.

Toate tipurile de limbaj C++ pot fi împărțite în de bază Şi compozit . Limbajul C++ definește șase principal tipuri de date pentru a reprezenta întreg, real, caracter și valori logice. Pe baza acestor tipuri, programatorul poate introduce o descriere compozit tipuri. Acestea includ matrice, enumerari, functii, structuri, referinte, pointeri, uniuni si clase.

Tipuri de date de bază în C++

Tipurile de date de bază (standard) sunt adesea numite aritmetice deoarece pot fi utilizate în operatii aritmetice. Pentru a descrie principalele tipuri, sunt definite următoarele:

  1. int(int);
  2. char(char);
  3. wchar_t(widechar);
  4. bool(boolean);
  5. float(real);
  6. dublu (dublă precizie reală).

Primele patru tipuri sunt numite întregi ( întreg ), ultimele două - tipuri de virgulă mobilă . Codul pe care compilatorul îl generează pentru procesarea valorilor întregi este diferit de codul pentru valorile în virgulă mobilă.

Sunt patru specificator de tip , clarificând reprezentarea internă și intervalul de valori ale tipurilor standard:

  • scurt (scurt);
  • lung(lung);
  • semnat(semnat);
  • nesemnat.

Tip întreg (int)

Mărimea tipului int nu este definită de standard, dar depinde de computer și de compilator. Pentru un procesor pe 16 biți, 2 octeți sunt alocați pentru valori de acest tip, pentru un procesor pe 32 biți - 4 octeți.

Specificatorul scurt dinaintea numelui tipului indică compilatorului că trebuie alocați 2 octeți pentru număr, indiferent de capacitatea procesorului. Specificatorul lung înseamnă că valoarea întreagă va ocupa 4 octeți. Deci, pe un computer pe 16 biți, echivalentele sunt int și short int, iar pe un computer pe 32 de biți echivalentele sunt int și long int.

Reprezentarea internă valori de tip întreg - întreg în cod binar. Când se utilizează specificatorul cu semn, bitul cel mai semnificativ al numărului este interpretat ca fiind cu semn (0 este un număr pozitiv, 1 este un număr negativ). Specificatorul nesemnat permite reprezentarea numai a numerelor pozitive, deoarece bitul cel mai semnificativ este tratat ca parte a codului numărului. Astfel, intervalul de valori de tip int depinde de specificatori. Intervalele de valori ale valorilor de tip întreg cu diverși specificatori pentru computerele compatibile IBM PC sunt prezentate în tabelul „Intervalele de valori ale tipurilor de date simple” de la sfârșitul intrării.

În mod implicit, toate tipurile de numere întregi sunt considerate semnate, ceea ce înseamnă că specificatorul semnat poate fi omis.

Constantelor găsite într-un program li se atribuie un tip sau altul în funcție de tipul lor. Dacă din anumite motive programatorul nu este mulțumit de acest tip, el poate indica în mod explicit tipul necesar folosind sufixele L, l (lung) și U, u (fără semn). De exemplu, constanta 32L va fi de tip lung și va ocupa 4 octeți. Puteți utiliza sufixele L și U în același timp, de exemplu, 0x22UL sau 05Lu.

Nota

Tipurile short int, long int, signed int și unsigned int pot fi abreviate la short, long, signed și, respectiv, unsigned.

Tip de caracter (car)

O valoare a tipului de caracter i se alocă un număr de octeți suficient pentru a găzdui orice caracter din setul de caractere pentru a acestui calculator, care a determinat denumirea tipului. De obicei, acesta este de 1 octet. Tipul char, ca și alte tipuri de numere întregi, poate fi semnat sau nesemnat. Valorile semnate pot stoca valori în intervalul -128 la 127. Folosind specificatorul nesemnat, valorile pot varia de la 0 la 255. Acest lucru este suficient pentru a stoca orice caracter din setul de caractere ASCII de 256 de caractere. Valorile tipului char sunt, de asemenea, folosite pentru a stoca numere întregi care nu depășesc limitele intervalelor specificate.

Tip de caracter extins (wchar_t)

Tipul wchar_t este proiectat să funcționeze cu un set de caractere pentru care 1 octet nu este suficient pentru a codifica, de exemplu, Unicode. Mărimea acestui tip este dependentă de implementare; de regulă, corespunde tipului scurt. Constante de șir Tipurile wchar_t sunt scrise cu prefixul L, de exemplu, L „Porți”.

tip boolean (bool)

Valorile booleene pot lua numai valorile adevărate și false, care sunt cuvinte rezervate. Forma internă de reprezentare a valorii false este 0 (zero). Orice altă valoare este interpretată ca adevărată. Când este convertit într-un tip întreg, true are valoarea 1.

Tipuri în virgulă mobilă (float, double și long double)

Standardul C++ definește trei tipuri de date pentru stocarea valorilor reale: float, double și long double.

Tipurile de date în virgulă mobilă sunt stocate diferit în memoria computerului decât tipurile de date întregi. Reprezentarea internă a unui număr real constă din două părți - mantisa și exponentul. Pe computerele compatibile cu IBM PC, valorile float ocupă 4 octeți, dintre care o cifră binară este alocată pentru semnul mantisei, 8 biți pentru exponent și 23 pentru mantise. Mantisa este un număr mai mare de 1,0 dar mai mic de 2,0. Deoarece cifra principală a mantisei este întotdeauna 1, aceasta nu este stocată.

Pentru valorile duble care ocupă 8 octeți, 11 și 52 de biți sunt alocați pentru exponent și respectiv mantisă. Lungimea mantisei determină precizia numărului, iar lungimea exponentului determină intervalul acestuia. După cum puteți vedea din tabelul de la sfârșitul intrării, cu același număr de octeți alocați pentru valorile float și long int, intervalele valorilor lor permise diferă foarte mult datorită formei de reprezentare internă.

Specificatorul lung dinaintea unui nume de tip dublu indică faptul că sunt alocați 10 octeți pentru valoarea acestuia.

Constantele în virgulă mobilă sunt de tip dublu în mod implicit. Puteți specifica în mod explicit tipul unei constante folosind sufixele F, f (float) și L, l (lung). De exemplu, constanta 2E+6L va fi de tip long double, iar constanta 1.82f va fi de tip float.

Pentru a scrie portabil diverse platforme programele nu pot face presupuneri despre dimensiunea unui tip int. Pentru a-l obține, trebuie să utilizați dimensiunea operației, rezultatul căreia este dimensiunea tipului în octeți. De exemplu, pentru sistemul de operare MS-DOS, dimensiunea (int) va avea ca rezultat 2, dar pentru Windows 98 sau OS/2 rezultatul va fi 4.

Standardul ANSI nu specifică intervale de valori pentru tipurile de bază sunt definite doar relațiile dintre dimensiunile acestora, de exemplu:

sizeof(float) ≤ slzeof(double) ≤ sizeof(long double)
sizeof(char) ≤ slzeof(short) ≤ sizeof(int) ≤ sizeof(lung)

Nota

Valorile minime și maxime permise pentru tipurile întregi sunt dependente de implementare și sunt date în fișierul antet (), caracteristici ale tipurilor reale - în dosar (), precum și în șablonul de clasă numeric_limits

tip void

Pe lângă cele enumerate, principalele tipuri de limbaj includ tipul de gol, dar setul de valori de acest tip este gol. Este folosit pentru a defini funcții care nu returnează o valoare, pentru a specifica o listă goală de argumente ale funcției, ca tip de bază pentru pointeri și în operațiunile de turnare a tipului.

Intervalele de valori ale tipurilor de date simple în C++ pentru computerele IBM compatibile cu PC

Î: Ce înseamnă termenul computer compatibil IBM PC?
R: Un computer compatibil IBM PC este un computer care este aproape arhitectural de IBM PC, XT și AT. Calculatoarele IBM compatibile cu PC-uri sunt construite pe microprocesoare compatibile cu Intel 8086 (și, după cum știți, toate cele lansate mai târziu procesoare Intel au plin compatibil cu invers din 8086). De fapt, acestea sunt aproape toate computere moderne.

Au fost introduse diferite tipuri de tipuri întregi și reale, care diferă în intervalul și acuratețea reprezentării datelor, pentru a oferi programatorului posibilitatea de a utiliza cel mai eficient capacitățile echipamentelor specifice, deoarece viteza calculelor și cantitatea de memorie depind de alegerea tipului. Dar un program optimizat pentru orice tip de computer poate să nu fie portabil pe alte platforme, așadar caz general Ar trebui evitate dependențele de caracteristicile specifice ale tipurilor de date.

Tip Gama de valori Dimensiune (octet)
bool adevărat și fals 1
semnat char -128 … 127 1
nesemnat char 0 … 255 1
semnat scurt int -32 768 … 32 767 2
unsigned short int 0 … 65 535 2
semnat lung int -2 147 483 648 … 2 147 483 647 4
nesemnat lung int 0 … 4 294 967 295 4
plutire 3.4e-38 … 3.4e+38 4
dubla 1.7e-308 … 1.7C+308 8
dublu lung 3.4e-4932 … 3.4e+4932 10

Pentru tipurile reale, tabelul arată valorile absolute ale valorilor minime și maxime.