Heltalsdatatypen c för funktionen. Variabler. Postfix typbeteckning

Till data hänvisar till all information som presenteras i en form som gör att du kan automatisera dess insamling, lagring och bearbetning i en dator (siffror, symboler, bitar, etc.).
Data i programmet kan vara första(anges vid programingången) eller bearbetningsresultat(mellan eller helg).
All data - variabler och konstanter - tillhör en viss typ.
Varje datatyp har sin egen associerade värdeintervall(antal byte för ett värde) och tillåtna operationer.

Datatyper i C/C++ är indelade i huvud och derivat.
Huvudtyperna inkluderar:

1. tomhet(tom typ),
2. int(heltalstyp),
3. flyta(riktiga flyttal),
4. dubbel(reella flyttal med dubbel precision),
5. röding(teckentyp),
6. bool- logiskt.

Komposittyper

För att bilda andra typer av data, använd huvud typer + sk specifikationer. Datatyper skapade från standardtyper med hjälp av specifikationer kallas sammansatta datatyper. C++ definierar fyra datatypsspecifikationer:

1. kort - kort;
2. lång lång;
3. signerad-signerad;
4. osignerad

Härledda typer är:

• arrayer,
• funktioner,
• klasser,
• pekare,
• länkar,
• strukturer,
• föreningar.

Karaktärstyp

Skriv data röding i datorns minne upptar alltid 1 byte. Detta beror på det faktum att ett teckentypsvärde vanligtvis ges så mycket minne som behövs för att lagra något av de 256 tangentbordstecken.
Teckentypen kan vara signerad eller osignerad.
I signerade mängder signerad röding du kan lagra värden i intervallet från -128 till 127. Följaktligen värdena för variabler av typen osignerad röding kan variera från 0 till 255.

Data typ	Värdeintervall	Storleken
röding	-128...+127	1 byte
osignerad röding	0...255	1 byte
signerad röding	-128...127	1 byte

När du arbetar med teckendata, kom ihåg att om ett uttryck innehåller enda symbol, den måste vara innesluten i enstaka citat. En sekvens av tecken, d.v.s. en sträng, när den används i uttryck är inom dubbla citattecken. Till exempel: 'F' , '3' , "Ivan", "235"

heltalstyp

Skriv data int i datorns minne kan uppta antingen 2, 4 eller 8 byte. Det beror på processorns bithet.
Som standard anses alla heltalstyper som signerade, det vill säga specificatorn signerad(undertecknad) kan utelämnas.
specificator osignerad(osignerad) tillåter endast positiva tal att representeras.

Värdeintervall för heltalstyper

Data typ	Värdeintervall	Storlek (byte)
int undertecknad int undertecknad long int	-2147483648 ... 2147483647	4
osignerad int osignerad lång int	0 ... 4294967295	4
kort int undertecknad kort int	-32768 ... 32767	2
osignerad kort int	0... 65535	2
lång lång int	\(-(2^{63}-1)...(2^{63}-1)\)	8
osignerad lång lång int	\(0...(2^{64}-1)\)	8

Riktig typ

Den interna representationen av ett reellt tal i datorns minne skiljer sig från representationen av ett heltal. Ett flyttalstal representeras i exponentiell form. $$\pm mE\pm p$$ var m- mantissa (heltal eller bråktal med en decimalkomma), R- ordning (heltal). För att konvertera ett tal i exponentiell form till den vanliga fastpunktsrepresentationen är det nödvändigt att multiplicera mantissan med tio till exponenten. Till exempel: \(-6.42E+2=-6.42*10^(2)\)

Värdeintervall av verkliga typer

Data typ	Värdeintervall	Storlek (byte)
flyta	3.4E-38 ... 3.4E+38	4
dubbel	1.7E-308... 1.7E+308	8
lång dubbel	3.4E-4932 ... 3.4E+4932	10

Längden på mantissan bestämmer numrets precision, medan exponentens längd bestämmer dess räckvidd.
Data av flyttyp upptar 4 byte, varav 1 bit tilldelas för tecknet, 8 bitar för exponenten och 23 bitar för mantissan. Eftersom den högsta siffran i mantissan alltid är 1, lagras den inte.
Dubbeltypsdata upptar 8 byte, de har -11 bitar för ordningen respektive -52 bitar för mantissan.
Den långa typspecifikationen före det dubbla typnamnet indikerar att 10 byte tilldelas för värdet.

boolesk typ

typ variabel bool kan bara ta två värden Sann(sant) eller falsk(Falsk). Varje värde som inte är noll tolkas som sant och, när det konverteras till en heltalstyp, får det värdet 1. Falskt representeras i minnet som 0.

Skriv ogiltig (tom)

Uppsättningen av värden av denna typ är tom.
Void-typen används för:

• definitioner av funktioner som inte returnerar ett värde;
• att ange en tom lista med funktionsargument;
• som bastyp för pekare;
• i en gjutoperation.

Deklarera variabler

Variabelär ett namngivet minne som lagrar ett värde av en viss typ.
Variabeln har namn(identifierare) och menande.
namn används för att komma åt minnesområdet där värdet lagras.
namn(identifierare) är en kombination av bokstäver, siffror och understreck som anger namnet på en variabel, namnet på en funktion eller ett nyckelord i ett program. C/C++-språket är skiftlägeskänsligt (dvs summa och summa kommer att behandlas som två olika variabler).
var, sorts– ett nyckelord som definierar mängden minne (antal byte) som allokeras för att lagra värdet på en variabel (som ett programobjekt), (int – heltal, float, double – real, char – character, bool – logical);
namn– en unik variabelidentifierare som anger den symboliska adressen för programobjektet i datorns minne;
initiativtagare– variabelns initiala värde, som kanske inte finns i beskrivningen.
Till exempel: Variabler av samma typ kan grupperas genom att separera ",". Beskrivningen av variabler av olika typer separeras med "; ".
Beroende på platsen för deklarationen kan variabler i C/C++-språket delas in i tre klasser:

1. lokal - deklareras inuti funktionen och är endast tillgängliga i den;
2. global - beskrivs före alla funktioner och är tillgängliga från var som helst i programmet;
3. formella parametrar för funktioner beskrivs i listan över funktionsparametrar.

Exempel:

Heltalstyp (int)

Typstorlek int definieras inte av standarden, utan beror på datorn och kompilatorn.

För en 16-bitars processor tilldelas 2 byte för värden av denna typ,

för 32-bitars - 4 byte.

specificator kort framför typnamnet indikerar för kompilatorn att 2 byte krävs för numret, oavsett processorkapacitet.

specificator lång betyder att heltalsvärdet tar 4 byte.

Således, på en 16-bitars dator, motsvarigheten till int och kort int,

och på 32-bitars, int och long int.

Intern representation värden av heltalstyp - ett heltal i binär kod. När du använder specifikationen signerad den mest signifikanta biten av talet tolkas som tecken (0 - positivt tal, 1 - negativt). specificator osignerad tillåter endast positiva tal att representeras, eftersom den mest signifikanta siffran anses vara en del av nummerkoden. Således beror intervallet för värden av typen int på specifikationerna. Värdeintervall för heltalstypvärden med olika specifikationer för IBM PC-kompatibla datorer anges i tabellen "Värdeintervall för enkla datatyper".

Som standard anses alla heltalstyper som signerade, vilket innebär att den signerade specifikationen kan utelämnas.

Konstanterna som påträffas i programmet tilldelas en eller annan typ i enlighet med deras typ. Om det av någon anledning inte passar programmeraren kan du uttryckligen ange den önskade typen med suffixen L, l (lång) och U, u (osignerad). Till exempel kommer konstanten 32L att vara av typen lång och uppta 4 byte. Du kan använda suffixen L och U samtidigt, till exempel 0x22UL eller 05Lu.

Notera. Typerna kort int, lång int, signerad int och osignerad int kan förkortas till kort, lång, signerad respektive osignerad.

Teckentyp (char)

Värdet på teckentypen är antalet byte som är tillräckligt för att rymma alla tecken från teckenuppsättningen för en given dator, vilket ledde till namnet på typen. Vanligtvis är detta 1 byte. Teckningstypen, liksom andra heltalstyper, kan vara signerad eller osignerad. Signerade värden kan lagra värden från -128 till 127. När du använder den osignerade specifikationen kan värden variera från 0 till 255. Detta räcker för att lagra vilket tecken som helst i ASCII-teckenuppsättningen med 256 tecken. char-värden används också för att lagra heltal.

Utökad teckentyp (wchar_t)

Sorts wchar_t designad för att fungera med en uppsättning tecken för kodning som inte räcker till 1 byte. Till exempel Unicode. Storleken på denna typ är implementeringsberoende; det brukar matcha typen kort. Strängkonstanter av typen wchar_t skrivs med ett L-prefix, till exempel L"Gates".

boolesk typ (bool)

Booleska värden kan bara ta värden Sann och falsk, som är reserverade ord. Den interna representationen av falskt är 0 (noll). Alla andra värden tolkas som sanna. När du konverterar till en heltalstyp Sann har värdet 1.

Flyttalstyper (flytande, dubbel och lång dubbel)

C++-standarden definierar tre datatyper för lagring av verkliga värden: float, double och long double.

Flyttalsdatatyper lagras annorlunda i minnet än heltalsdatatyper. Den interna representationen av ett reellt tal består av två delar - mantissor och ordning.

På IBM PC-kompatibla datorer, värden som flyta upptar 4 byte, varav en bit är allokerad under mantissans tecken, 8 siffror under beställning och 23 under mantissan. Mantissan är ett tal större än 1,0 men mindre än 2,0. Eftersom den högsta siffran i mantissan alltid är 1, lagras den inte.

För värden av typ dubbel, som upptar 8 byte, tilldelas 11 och 52 bitar för ordningen respektive mantissan. Längden på mantissan bestämmer numrets precision, medan exponentens längd bestämmer dess räckvidd. Som du kan se från tabellen i slutet av posten, med samma antal byte tilldelade för float- och long int-värden, skiljer sig intervallen för deras giltiga värden mycket på grund av den interna representationsformen.

specificator lång före typnamnet dubbel indikerar att 10 byte tilldelas för dess värde.

Flyttalskonstanter är av typen dubbel som standard. Du kan uttryckligen ange typen av en konstant med suffixen F, f (float) och L, l (lång).

Till exempel skulle konstanten 2E+6L vara av typen lång dubbel, och konstanten 1,82f skulle vara av typen float.

När man skriver program som är universella för olika plattformar kan man inte göra antaganden om storleken på typen int. För att få det måste du använda operatorn sizeof, som returnerar storleken på typen i byte.

Till exempel, på ett MS-DOS-operativsystem kommer sizeof(int) att resultera i 2, och på Windows 98 eller OS/2 blir resultatet 4.

ANSI-standarden specificerar inte värdeintervall för huvudtyperna, endast förhållanden mellan deras storlekar definieras, till exempel:

sizeof(float) ≤ slzeof(dubbel) ≤ sizeof(lång dubbel)
sizeof(char) ≤ slzeof(short) ≤ sizeof(int) ≤ sizeof(long)

Notera. De lägsta och högsta tillåtna värdena för heltalstyper är implementeringsberoende och ges i rubrikfilen (), egenskaper hos riktiga typer - i filen (), samt i klassmallen numeric_limits

tomrumstyp

Utöver de listade är tomrumstypen en av huvudtyperna av språket, men uppsättningen värden av denna typ är tom. Den används för att definiera funktioner som inte returnerar ett värde, för att ange en tom lista med funktionsargument, som bastyp för pekare och i cast-operationer.

Olika typer av heltals- och reella typer, som skiljer sig åt i datarepresentationens omfång och precision, introduceras för att göra det möjligt för programmeraren att använda kapaciteten hos en viss hårdvara mest effektivt, eftersom beräkningshastigheten och mängden minne beror på val av typ. Men ett program som är optimerat för en typ av dator kan bli icke-portabelt till andra plattformar, så i allmänhet bör beroenden av specifika egenskaper hos datatyper undvikas.

Sorts	Värdeintervall	Storlek (byte)
bool	sant och falskt
signerad röding	-128 … 127
osignerad röding	0 … 255
undertecknad kort int	-32 768 … 32 767
osignerad kort int	0 … 65 535
undertecknad long int	-2 147 483 648 … 2 147 483 647
osignerad lång int	0 … 4 294 967 295
flyta	3.4e-38 … 3.4e+38
dubbel	1,7e-308 … 1,7C+308
lång dubbel	3.4e-4932 … 3.4e+4932

Programstruktur

Ett C++-program består av funktioner, beskrivningar och förbearbetningsdirektiv. En av funktionerna måste namnges huvud. Programexekveringen börjar med den första satsen för denna funktion. Den enklaste funktionsdefinitionen har följande format:

Som regel används en funktion för att beräkna ett värde, så dess typ anges före funktionsnamnet. Nedan följer den viktigaste informationen om funktionerna:

• om funktionen inte ska returnera ett värde anges void-typen:
• funktionskroppen är ett block och är därför innesluten i lockiga hängslen;
• funktioner kan inte kapslas;
• varje påstående slutar med semikolon (förutom ett sammansatt påstående).

Ett exempel på en programstruktur som innehåller funktionerna main, fl och f2:

Programmet kan bestå av flera moduler(källfiler).

Anmärkningar om I/O i C++

C++-språket har inga inbyggda I/O-faciliteter - det görs med hjälp av funktioner, typer och objekt som finns i standardbiblioteken.

Två metoder används: funktioner som ärvts från C-språket och C++-objekt.

Grundläggande C-style I/O-funktioner:

int scanf (const char* format, ...) // input
int printf(const char* format, ...) // output

De utför formaterad inmatning och utmatning av ett godtyckligt antal värden enligt formatsträngen. Formatsträngen innehåller tecken som kopieras till strömmen (till skärmen) vid utmatning eller begärs från strömmen (från tangentbordet) vid inmatning, och konverteringsspecifikationer som börjar med ett %-tecken, som ersätts av specifika värden på ingång och utgång.

Ett exempelprogram som använder C-style I/O-funktioner:

#omfatta
int main() (
int i;
printf("Ange ett heltal\n");
scanf("%d", &i);
printf("Du skrev in numret %d, tack!", i);
returnera 0;
}

Den första raden i detta program är ett förbehandlardirektiv, enligt vilket en rubrikfil som innehåller en beskrivning av inmatnings-/utgångsfunktionerna som används i programmet infogas i programtexten (i detta fall är vinkelparenteser en del av språket) . Alla förprocessordirektiv börjar med ett #-tecken.

Den tredje raden är en beskrivning av en heltalsvariabel med namnet i.

Printf-funktionen på den fjärde raden skriver ut prompten "Ange ett heltal" och hoppar till en ny rad enligt \n escape-sekvensen. Scanf-funktionen lagrar heltal som matas in från tangentbordet i variabeln i (tecknet & betyder operationen att hämta adressen), och följande sats visar strängen som anges i den, och ersätter konverteringsspecifikationen med värdet på detta nummer.

Program som använder C++ klassbibliotek:

#omfatta
int main() (
int i;
cout<< "Введите целое число\n"; cin >> i;
cout<< "Вы ввели число " << i << ", спасибо!";
returnera 0;
}

Rubrikfilen innehåller en beskrivning av en uppsättning klasser för hantering av input/output. Den definierar standardströmobjekt cin för tangentbordsinmatning och cout för visning på skärmen, såväl som streamingoperationer< < и чтения из потока >>.

Du kan använda båda metoderna för att organisera input/output, men det rekommenderas inte att blanda dem i ett program.

En datatyp i programmering är en samling av två uppsättningar: en uppsättning värden och en uppsättning operationer som kan tillämpas på dem. Till exempel kan datatypen för icke-negativa heltal, som består av en ändlig uppsättning naturliga tal, tillämpas på operationerna addition (+), multiplikation (*), heltalsdivision (/), resterande (%), och subtraktion (−).

Ett programmeringsspråk har vanligtvis en uppsättning primitiva datatyper - typer som tillhandahålls av programmeringsspråket som en grundläggande inbyggd enhet. I C++ kallar skaparen av språket sådana typer för fundamentala typer. De grundläggande typerna i C++ är:

• boolean (bool);
• tecken (t.ex. char);
• heltal (t.ex. int);
• flytande punkt (t.ex. flytande);
• enums (definierade av programmeraren);
• tomhet.

Utöver ovanstående byggs följande typer:

• pekare (t.ex. int*);
• matriser (t.ex. char);
• referens (t.ex. dubbel&);
• andra strukturer.

Låt oss gå vidare till begreppet en bokstavlig (t.ex. 1, 2.4F, 25e-4, 'a', etc.): en bokstavlig är en post i källkoden för ett program som representerar ett fast värde. Med andra ord är en bokstavlig helt enkelt en representation av ett objekt (värde) av någon typ i programkoden. C++ har förmågan att skriva heltalsvärden, flyttalsvärden, tecken, booleska, strängvärden.

En bokstavlig heltalstyp kan skrivas som:

• 10:e nummersystemet. Till exempel, 1205;
• 8:e siffersystemet i formatet 0 + nummer. Till exempel, 0142 ;
• 16:e talsystemet i formatet 0x + nummer. Till exempel 0x2F .

24, 030, 0x18 är alla poster med samma nummer i olika nummersystem.
För att skriva flyttalsnummer används punktnotation: 0.1, .5, 4. - antingen i
exponentiell notation - 25e-100. Det bör inte finnas några mellanslag i en sådan post.

Namnet som vi kan associera värdena skrivna med bokstaver kallas en variabel. En variabel är en namngiven eller på annat sätt adresserbar plats i minnet vars adress kan användas för att komma åt data. Dessa data skrivs, skrivs över och raderas i minnet på ett visst sätt under programmets körning. Variabeln låter dig komma åt data när som helst och vid behov ändra dem. Data som kan hämtas från ett variabelnamn kallas variabelns värde.
För att kunna använda en variabel i ett program måste den deklareras och vid behov kan den definieras (= initieras). En variabeldeklaration i programtexten innehåller nödvändigtvis 2 delar: bastypen och deklaratorn. Specifieraren och initialiseraren är valfria delar:

const int exempel = 3; // här const - specificator // int - bastyp // exempel - variabelnamn // = 3 - initialiserare.

Variabelnamnet är en sekvens av tecken från bokstäver i det latinska alfabetet (gemener och versaler), siffror och/eller understreck, men det första tecknet kan inte vara en siffra. Variabelnamnet bör väljas på ett sådant sätt att det alltid är lätt att gissa vad den lagrar, till exempel "monthPayment". I det abstrakta och i praktiken kommer vi att använda CamelCase-notationen för reglerna för att skriva variabler. Namnet på en variabel kan inte sammanfalla med ord som är reserverade i språket, exempel på sådana ord: if, while, function, goto, switch, etc.

Deklaratorn, förutom variabelnamnet, kan innehålla ytterligare tecken:

• * - pekare; före namnet
• *const - konstant pekare; före namnet
• & - länk; före namnet
• - array; efter namnet;
• () - funktion; efter namnet.

En initialiserare låter dig definiera en variabels värde omedelbart efter deklarationen. Initialisatorn börjar med en lika bokstavlig (=) och sedan sker processen att ställa in variabelns värde. Generellt sett betecknar likhetstecknet i C++ en tilldelningsoperation; den kan användas för att ställa in och ändra värdet på en variabel. Det kan vara olika för olika typer.

Specifieraren anger ytterligare attribut än typen. Const-specifikationen i exemplet låter dig förbjuda efterföljande ändringar av variabelns värde. Sådana oföränderliga variabler kallas konstant eller konstant.

Att deklarera en konstant utan initiering fungerar inte av logiska skäl:

Const int EMPTY_CONST; // fel, konstant variabel inte initierad const int EXEMPEL = 2; // konstant med värde 2 EXEMPEL = 3; // fel, försök att tilldela ett värde till en konstant variabel

För att namnge konstanter är det vanligt att endast använda versaler, som skiljer ord med ett understreck.

Grundläggande datatyper i C++

Vid dissekering av varje typ måste läsaren komma ihåg att definiera datatypen.

1. Heltalstyp (char, short(int), int, long(int), long long)

Från namnet är det lätt att förstå att uppsättningen värden består av heltal. Dessutom kan uppsättningen värden för var och en av de listade typerna vara signerad (signerad) eller osignerad (osignerad). Antalet element i en uppsättning beror på storleken på minnet som används för att lagra värdet av den typen. Till exempel, för en variabel av typen char, tilldelas 1 byte minne, så det totala antalet element blir:

• 2 8N = 2 8 * 1 = 256, där N är mängden minne i byte för att lagra värdet

I ett sådant fall är intervallen för tillgängliga heltal följande:

• - för osignerad röding
• [-128..127] - för signerad röding

Som standard anses en variabel av heltalstyp vara signerad. För att i koden ange att en variabel ska vara osignerad tilldelas bastypen till vänster ett tecken med tecken, d.v.s. osignerad:

osignerade långa värden; // definierar en heltalstyp (lång) utan tecken.

De listade typerna skiljer sig bara åt i mängden minne som krävs för lagring. Eftersom C++-språket är en ganska maskinspecifik språkstandard, garanterar det bara följande villkor:

• 1 = kolstorlek ≤ kort storlek ≤ int storlek ≤ lång storlek.

Typstorlekarna är vanligtvis följande: char - 1, kort - 2, int - 4, lång - 8, lång lång - 8 byte.

Du kan utföra aritmetiska operationer med heltalstypvärden: +, -, *, /, %; jämförelseoperationer: ==, !=,<=, <, >, >=; bitoperationer: &, |, xor,<<, >>.
De flesta operationer som addition, multiplikation, subtraktion och jämförelse är lätta att förstå. Ibland, efter att ha utfört aritmetiska operationer, kan resultatet ligga utanför värdeintervallet; i detta fall kommer programmet att ge ett fel.
Heltalsdivision (/) hittar heltalsdelen av att dividera ett heltal med ett annat. Till exempel:

• 6 / 4 = 1;
• 2 / 5 = 0;
• 8 / 2 = 4.

Procentsymbolen (%) betecknar operationen att bestämma resten av divisionen av två heltal:

• 6 % 4 = 2;
• 10 % 3 = 1.

Svårare att förstå operationer är bitvis: & (AND), | (ELLER), xor (exklusivt ELLER),<< (побитовый сдвиг влево), >> (bitvis högerförskjutning).

Bitoperationer AND, OR och XOR tillämpar motsvarande logiska operation på varje informationsbit:

• 1 10 = 01 2
• 3 10 = 11 2
• 1 10 & 3 10 = 01 2 & 11 2 = 01 2
• 1 10 | 3 10 = 01 2 | 11 2 = 11 2
• 1 10 xor 3 10 = 01 2 xor 11 2 = 10 2

Vid bildbehandling används 3 kanaler för färg: röd, blå och grön - plus transparens, som lagras i en variabel av typen int, eftersom varje kanal har ett värdeintervall från 0 till 255. I hexadecimalt skrivs ett värde enligt följande: 0x180013FF; då motsvarar värdet 18 16 den röda kanalen, 00 16 - blå, 13 16 - grön, FF - alfakanal (transparens). För att välja en viss kanal från ett sådant heltal, använd den så kallade. mask, där positionerna av intresse för oss är F 16 eller 1 2 . Det vill säga, för att markera värdet på den blå kanalen måste du använda en mask, d.v.s. bitvis OCH:

int blue_channel = 0x180013FF & 0x00FF0000;

Därefter förskjuts det mottagna värdet åt höger med det erforderliga antalet bitar.

En bitvis förskjutning skiftar åt vänster eller höger så många bitar av ett nummer som anges på höger sida av operationen. Till exempel skrivs siffran 39 för char-typen i binär form på följande sätt: 00100111. Sedan:

Char binaryExample = 39; // 00100111 char resultat = binärtExempel<< 2; // сдвигаем 2 бита влево, результат: 10011100

Om variabeln är av osignerad typ blir resultatet talet 156, för en signerad är det lika med -100. Observera att för heltalstyper med tecken är enheten i den högre ordningen för bitrepresentationen ett tecken på att talet är negativt. I detta fall motsvarar ett värde i binär form som består av alla enheter -1; om 1 bara är i den mest signifikanta siffran och de återstående siffrorna är nollor, så har ett sådant tal minimivärdet för en viss typ av värde: för char är det -128.

2. Flyttalstyp (flytande, dubbel (flytande))

Uppsättningen av flyttalsvärden är en delmängd av reella tal, men inte alla reella tal kan representeras binärt, vilket ibland leder till dumma misstag:

flytvärde = 0,2; värde == 0,2; // fel, värdet kommer inte att vara lika med 0,2 här.

När man arbetar med flyttalsvariabler bör programmeraren inte använda likhets- eller ojämlikhetsoperationen, istället använder de vanligtvis ett test för att träffa ett visst intervall:

Värde - 0,2< 1e-6; // ok, подбирать интервал тоже нужно осторожно

Förutom jämförelseoperationer stöder flyttalstypen 4 aritmetiska operationer, som är helt överensstämmande med matematiska operationer med reella tal.

3. Boolesk (logisk) typ (bool)

Består av endast två värden: sant (sant) och falskt (falskt). För att arbeta med variabler av denna typ används logiska operationer: ! (INTE), == (jämlikhet), != (ojämlikhet), && (logisk OCH), || (logiskt ELLER). Resultatet av varje operation kan hittas i motsvarande sanningstabell. till exempel:

X Y XOR0 0 0 0 1 1 1 0 1 1 1 0

4. Teckentyp (char, wchar_t)

Teckentypen är inte bara en heltalstyp (vanligtvis kallas en sådan typ byte), utan också en teckentyp, som lagrar teckennumret från tabellen som ett ASCII-tecken. Till exempel motsvarar koden 0x41 tecknet 'A' och 0x71 - 't'.

Ibland blir det nödvändigt att använda tecken som inte är fixerade i ASCII-tabellen och därför kräver mer än 1 byte för att lagras. Det finns en bred karaktär (wchar_t) för dem.

5.1. Matriser

Matriser låter dig lagra en sekventiell uppsättning element av samma typ. En array lagras i minnet i ett sammanhängande block, så du kan inte deklarera en array utan att specificera dess storlek. För att deklarera en array, efter variabelnamnet skriv hakparenteser () som anger dess storlek. Till exempel:

int myArray; // Array med 5 element av heltalstyp

För att initiera en array listas värdena med hängslen. Du kan bara initiera på detta sätt vid tidpunkten för variabeldeklarationen. Förresten, i det här fallet är det inte nödvändigt att ange storleken på arrayen:

int odds = (1, 3, 7, 9, 11); // Arrayen initieras med 5 värden

För att komma åt ett specifikt värde i en matris (matriselement), använd indexåtkomstoperationen () med elementnumret (siffror börjar från 0). Till exempel:

odds; // tillgång till det första elementet i arrayen. Returnerar värdet 1 odds; // tillgång till det tredje elementet. Returnerar värdet 7 odds = 13; // Tilldela ett nytt värde till det 5:e elementet i arrayoddsen; // åtkomstfel

5.3. Strängar

För att skriva en sträng använder programmerare tanken att en sträng är en på varandra följande serie (array) av tecken. För att identifiera slutet på en rad används ett speciellt radsluttecken: '\0'. Dessa specialtecken, som består av ett omvänt snedstreck och ett identifierande tecken, kallas kontroll- eller escape-tecken. Det finns fortfarande till exempel '\n' - början på en ny rad, '\t' - tabulering. För att spela in ett omvänt snedstreck på en rad, används escape - ytterligare ett snedstreck sätts före själva tecknet: '\'. Escape används också för att skriva citattecken.

Låt oss skapa en strängvariabel:

Char textExample = ('T', 'e', ​​'s', 't', '\0'); // strängen "Test" skrivs

Det finns en förenklad notation för stränginitiering:

Char textExample = "Test"; // Det sista tecknet är inte skrivet, men storleken är fortfarande 5

Utan att gå in på detaljer, här är en annan användbar datatyp - sträng. Strängar
av den här typen kan du till exempel lägga till:

String hej = "Hej,"; stringname = "Max!"; sträng hello_name = hej + namn; // Få strängen "Hej, Max!"

6. Länk

Int a = 2; // variabel "a" pekar på värde 2 int &b = a; // variabel "b" pekar på samma plats som "a" b = 4; // genom att ändra värdet på b, ändrar programmeraren värdet på a. Nu är a = 4 int &c = 4; // fel, du kan inte göra detta, eftersom referens kan inte tilldelas ett värde

7. Pekare

För att hantera denna typ av data är det nödvändigt att komma ihåg att uppsättningen av värden av denna typ är adresserna till minnesceller där data börjar. Pekaren stöder även operationer för addition (+), subtraktion (-) och därifrån (*).

Adresser 0x0 betyder att pekaren är tom, d.v.s. pekar inte på några uppgifter. Den här adressen har sin egen bokstavliga - NULL:

Int *nullPtr = NULL; // nollpekare

Att lägga till och subtrahera en adress med ett heltal eller en annan adress tillåter
flytta runt det minne som är tillgängligt för programmet.

Åtgärden att hämta data från adressen som är lagrad i en pekare kallas dereferencing (*). Programmet läser det nödvändiga antalet minnesceller och returnerar värdet som är lagrat i minnet.

Int valueInMemory = 2; // ställ in en variabel av heltalstyp int *somePtr = // kopiera adressen till variabeln, här & - returnerar adressen till variabeln somePtr; // adress för minnescellen, till exempel, 0x2F *somePtr; // värdet lagras i 4 celler: 0x2F, 0x30, 0x31 och 0x32

För pekare är tilldelningsoperationen, som syntaktiskt sett är densamma som kopieringsoperationen, inte tillgänglig. Du kan med andra ord kopiera adressen till en annan pekare eller adressen till en variabel, men du kan inte bestämma värdet på adressen själv.

Själva pekaren lagras i minnet, liksom värden för variabler av andra typer, och tar 4 byte, så du kan skapa en pekare till en pekare.

8. Överföringar

Uppräkningar är den enda grundläggande typen som definieras av programmeraren. I stort sett är en uppräkning en ordnad uppsättning namngivna heltalskonstanter, där uppräkningsnamnet är bastypen.

Enumcolor (RÖD, BLÅ, GRÖN);

Som standard är RÖD = 0, BLÅ = 1, GRÖN = 2. Därför kan värdena jämföras med varandra, d.v.s. RÖD< BLUE < GREEN. Программист при объявлении перечисления может самостоятельно задать значения каждой из констант:

Enum access(READ=1, WRITE=2, EXEC=4);

Det är ofta bekvämt att använda uppräkningar vars värden är en potens av två, eftersom i binär representation kommer ett tal som är en potens av 2 att bestå av den 1:a enheten och nollor. Till exempel:

8 10 = 00001000 2

Resultatet av att addera dessa siffror visar alltid tydligt vilka siffror som lagts till:

37 10 = 00100101 2 = 00000001 2 + 00000100 2 + 00100000 2 = 1 10 + 4 10 + 32 10

Tomhet

Syntaktisk är tomrumstypen en av de grundläggande typerna, men den kan endast användas som en del av mer komplexa typer, eftersom objekt av typen void existerar inte. Vanligtvis används denna typ för att informera om att en funktion inte har något returvärde, eller som bastyp för en pekare till objekt av odefinierade typer:

tomt föremål; // error, det finns inga objekt av typen void void // error, det finns inga referenser till void void *ptr; // ok, lagra en pekare till en okänd typ

Ofta använder vi void specifikt för att indikera att en funktion inte returnerar något värde. En pekare av voidtyp hanteras när programmeraren tar fullt ansvar för minnesintegritet och korrekt typcasting.

Kasta

Det är ofta nödvändigt att kasta värdet av en variabel av en typ till en annan. I det fall där uppsättningen av värden av den ursprungliga typen är en delmängd av en större typ (till exempel är int en delmängd av lång och lång är en dubbel), kan kompilatorn implicit ( implicit) ändra värdetypen.

int heltal = 2; flytande flytande = heltal; // flytande = 2,0

Typomvandlingen kommer att utföras med förlust av information, så bara heltalsdelen av flyttalstalet kommer att finnas kvar, bråkdelen kommer att gå förlorad.

Det finns möjlighet till explicit (explicit) typkonvertering, för detta, till vänster om variabeln eller valfritt värde på originaltypen, inom parentes, skriv typen till vilken rollbesättningen kommer att göras:

int värde = (int) 2,5;

Unära och binära operationer

De operationer som vi utförde tidigare kallas binära: till vänster och höger om operationssymbolen finns värden eller variabler, till exempel 2 + 3. I programmeringsspråk använder de förutom binära operationer även unära operationer som gäller variabler. De kan vara antingen till vänster eller till höger om en variabel, flera sådana operationer har påträffats tidigare - däreferensoperationen (*) och att ta adressen till en variabel (&) är unära. Operatörerna "++" och "-" ökar och minskar värdet på en heltalsvariabel med 1, respektive, och kan skrivas antingen till vänster eller till höger om variabeln.

C++ använder också en förkortning för binära operationer när vänster och höger sida av ett uttryck innehåller samma variabel, dvs. någon operation utförs med variabelns värde och resultatet av operationen lagras i samma variabel:

A+=2; // samma som a = a + 2; b/= 5; // samma som b = b / 5; c &= 3; // samma som c = c & 3;

Taggar: C-variabler. char, int, unsigned, long, long long, float, double, long double, long float, lexical scoping. Deklarera variabler. Synlighetsområde. Variabel initiering. Variabelnamn. exponentiell form.

Variabler

Variabler används för att lagra värden (sic!). En variabel kännetecknas av en typ och ett namn. Låt oss börja med namnet. I C kan en variabel börja med ett understreck eller en bokstav, men inte med en siffra. Variabeln kan innehålla engelska tecken, siffror och understreck. Variabeln får inte matcha nyckelord (detta är speciella ord som används som kontrollstrukturer, för att definiera typer, etc.)

bil	dubbel	int	struktur
ha sönder	annan	lång	växla
Registrera	typdef	röding	extern
lämna tillbaka	tomhet	fall	flyta
osignerad	standard	för	signerad
union	do	om	storlek av
flyktig	Fortsätta	uppräkning	kort
medan	i kö

Samt ett antal andra ord specifika för denna version av kompilatorn, till exempel långt, nära, mycket liten, enorm, asm, asm_ etc.

Till exempel korrekta identifierare
a, _, _1_, Sarkasm, a_long_variable, aLongVariable, var19, defaultX, char_type
otrogen
1a, $värde, a-långt värde, kort

C är ett skiftlägeskänsligt språk. Variabler som heter a och A, eller end och END, eller perfectDark och PerfectDarK är olika variabler.

Varierande typer

Variabeltypen avgör

• 1) Storleken på variabeln i byte (hur många byte minne som datorn kommer att allokera för att lagra värdet)
• 2) Representation av en variabel i minnet (hur bitar kommer att lokaliseras i binär form i det allokerade minnesområdet).

Det finns flera grundläggande typer i C. Låt oss dela upp dem i två grupper - heltal och flyttal.

hela

• röding- storlek 1 byte. Är alltid! Detta måste komma ihåg.
• kort- storlek 2 byte
• int- storlek 4 byte
• lång- storlek 4 byte
• lång lång- storlek 8 byte.

Här bör en anmärkning göras. Storleken på variabler i C definieras inte explicit som storleken i byte. Standarden säger bara det

röding<= short <= int <= long <= long long

Ovanstående värden är specifika för VC2012-kompilatorn på en 32-bitarsmaskin. Så om ditt program beror på storleken på en variabel, var inte för lat för att ta reda på dess storlek.

Låt oss nu definiera det högsta och lägsta antalet som en variabel av varje typ kan lagra. Siffror kan vara både positiva och negativa. Negativa tal använder en bit för att lagra tecknet. Ibland är skylten nödvändig (till exempel lagrar vi ett bankkonto, temperatur, koordinater etc.), och ibland är det inte nödvändigt (vikt, arraystorlek, personens ålder etc.). För att göra detta använder C typmodifieraren signerad och osignerad. unsigned char - alla 8 bitar under numret, totalt har vi en uppsättning nummer från 00000000 till 11111111 i binär form, det vill säga från 0 till 255 tecken med tecken från -128 till 128. Som standard är variabler signerade. Därför är att skriva char och signerad char likvärdiga.

Flik. 1 Storlek på heltalstyper i C.

Sorts	Storlek, byte	Minsta värde	Maximalt värde
osignerad röding	1	0	255
signerad röding (röding)	1	-128	127
osignerad kort	2	0	65535
undertecknad kort (kort)	2	-32768	32767
osignerad int (osignerad)	4	0	4294967296
undertecknad int (int)	4	-2147483648	2147483647
osignerad lång	4	0	4294967296
lång undertecknad (lång)	4	-2147483648	2147483647
osignerad lång lång	8	0	18446744073709551615
undertecknad lång lång (lång lång)	8	-9223372036854775808	9223372036854775807

storlek av

Det finns en operator i C som låter dig få storleken på en variabel i byte. sizeof är en variabel, eller sizeof(variabel) eller sizeof(typ). Det är en operatör, eftersom funktionen inte har något sätt att få information om storleken på typer vid körning. Låt oss skriva ett litet program för att kontrollera storleken på variablerna.

#omfatta #omfatta int main() ( char c; kort s; int i; long l; long long L; //Anropar sizeof som en "funktion" 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)); //Call as operator printf("sizeof(char) = %d\n", storlek på c); printf("storlek på(kort) = %d\n", storlek på s); printf("storlek på(int) = %d\n", storlek på i); printf("storlek på(lång) = %d \ n", storlek på l); printf("storlek på (lång lång) = %d\n", storlek på L); _getch(); )

(Jag tycker att det är klart att variabler kan ha vilket giltigt namn som helst). Detta program kunde ha skrivits på ett enklare sätt.

#omfatta #omfatta 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)); //kan inte anropa sizeof som operator på typnamn //sizeof int - kompileringsfel _getch(); )

I C kan samma typ ha mer än ett namn.
kort === kort int
lång === lång int
lång lång === lång lång int
osignerad int === osignerad

flyttalstyper

• flyta- 4 bytes,
• lång flyt- 8 byte
• dubbel- 8 byte
• lång dubbel- 8 byte.

Här finns också värdena för VC2012, enligt standarden, storleken på flyttyper<= long float <= double <= long double все числа с плавающей точкой - со знаком.

Variabelt överflöde

C bryr sig inte om variabelt spill. Detta innebär att genom att ständigt öka värdet på, säg, en int-variabel, kommer vi så småningom att "återställa värdet"

#omfatta #omfatta void main() (osignerad a = 4294967295; int b = 2147483647; //Osignerad typ overflow printf("%u\n", a); a += 1; printf("%u", a); //Overflow signerad typ printf("%d\n", b); b += 1; printf("%d", b); getch(); )

I allmänhet definieras variabelt spillbeteende endast för typen osignerad: Ett heltal utan tecken återställer värdet. För andra typer kan vad som helst hända, och om du behöver se efter spill, gör det manuellt genom att kontrollera argument, eller använd andra metoder beroende på kompilatorn och processorarkitekturen.

Postfix typbeteckning

När du arbetar med siffror kan du använda tecknen i slutet av numret för att uttryckligen ange dess typ, till exempel

• 11 - antal typ int
• 10u - osignerad
• 22l eller 22L - lång
• 3890ll eller 3890LL - lång lång (även lL eller Ll)
• 80.0f eller 80.f eller 80.0F - flytande (nödvändigt för att ha en decimalkomma i posten)
• 3.0 - dubbelt nummer

Exponentiell notation anger också ett antal dubbeltyp som standard. #omfatta #omfatta int main() ( printf("sizeof(int) = %d\n", sizeof(10)); printf("sizeof(unigned) = %d\n", sizeof(10u)); printf("sizeof( long) = %d\n", sizeof(10l)); printf("sizeof(long long) = %d\n", sizeof(10ll)); printf("sizeof(float) = %d\n", sizeof(10.f)); printf("sizeof(dubbel) = %d\n", sizeof(10.)); printf("sizeof(dubbel) = %d\n", sizeof(10e2)); getch (); )

Följande kod kommer dock inte att ge fel eftersom det finns en implicit typkonvertering

Int a = 10u; dubbel g = 3.f;

Hexadecimalt och oktalt format

När du arbetar med tal kan du använda hexadecimala och oktala representationer. Tal i hexadecimal börjar med 0x, i oktal börjar med noll. Följaktligen, om numret börjar från noll, bör det inte innehålla högre siffror än 7:

#omfatta #omfatta void main() ( int x = 0xFF; int y = 077; printf("hex x = %x\n", x); printf("dec x = %d\n", x); printf("okt x = %o\n", x); printf("okt y = %o\n", y); printf("dec y = %d\n", y); printf("hex y = %x", y); getch(); )

Exponentiell representation av tal

Den exponentiella formen för att representera ett tal är representationen av ett tal i formen M e ± p , där M- mantis av numret, sid- tiopotens. I det här fallet måste mantissan ha ett tecken som inte är noll före decimalkomma.
Till exempel 1,25 === 1,25e0, 123,5 === 1,235e2, 0,0002341 === 2,341e-4 etc.
Visningar 3.2435e7 motsvarar 3.2435e+7
Det finns en annan representation ("teknik"), där graden måste vara en multipel av tre. Till exempel 1,25 === 1,25e0, 123,5 === 123,5e0, 0,0002341 === 234,1e-6, 0,25873256 === 258,73256e-3 etc.

Deklarera variabler

I C deklareras variabler alltid i början av ett block (ett block är en kod som avgränsas av klammerparenteser)

<возвращаемый тип> <имя функции> (<тип> <аргумент>[, <тип> <аргумент>]) ( variabel deklaration allt annat )

När en variabel deklareras skrivs dess typ och namn.

int a; dubbel parameter;

Du kan deklarera flera variabler av samma typ genom att separera namnen med ett kommatecken

Lång lång arg1, arg2, arg3;

Till exempel

#omfatta #omfatta int main() ( int a = 10; int b; medan (a>0)( int z = a*a; b += z; ) )

Variabler deklareras här a och b inuti en funktion huvud och variabel z inuti öglekroppen. Följande kod kommer att orsaka ett kompileringsfel

int main() ( int i; i = 10; int j; )

Det beror på att variabeldeklarationen kommer efter tilldelningssatsen. När du deklarerar variabler kan du omedelbart initiera dem.
int i = 0;
Samtidigt betraktas inte initiering vid deklarering av en variabel som en separat sats, så följande kod kommer att fungera

int main() ( int i = 10; int j; )

Variabelns initiala värde

Det är mycket viktigt att komma ihåg att variabler i C inte initialiseras till noll som standard, som i många andra programmeringsspråk. Efter att variabeln har deklarerats lagrar den "skräp" - ett slumpmässigt värde som finns kvar i minnesområdet som tilldelades variabeln. Detta beror främst på optimeringen av programmet: om det inte finns något behov av initiering, så finns det inget behov av att spendera resurser för att skriva nollor (notera: globala variabler initieras med nollor, varför så, läs den här artikeln).

#omfatta #omfatta int main() ( int i; printf("%d", i); getch(); )

Om du kör det här programmet på VC kommer en varning att flyga ut under körningen
Run-Time Check Failure #3 - Variabeln "i" används utan att initieras.
Om du klickar på "Fortsätt" kommer programmet att visa "skräp". I många andra kompilatorer kommer det inte att finnas någon varning när programmet körs.

Variabel omfattning

Variabler kan vara lokala (deklarerade i någon funktion) och globala. Den globala variabeln är synlig för alla funktioner som deklareras i den här filen. En lokal variabel är begränsad av sin omfattning. När jag säger att en variabel är "synlig på någon plats" betyder det att den på denna plats är definierad och kan användas. Tänk till exempel på ett program som har en global variabel

#omfatta #omfatta int global = 100; void foo() ( printf("foo: %d\n", global); ) void bar(int global) ( printf("bar: %d\n", global); ) int main() ( foo() ; bar(333); getch(); )

Kommer att visas
foo:100
takt: 333
Här är en global variabel global synlig för alla funktioner. Men funktionsargumentet skriver över den globala variabeln, så genom att skicka argumentet 333 skrivs det lokala värdet 333 ut.
Här är ett annat exempel

#omfatta #omfatta int global = 100; int main() ( int global = 555; printf("%d\n", global); getch(); )

Programmet kommer att skriva ut 555. Precis som i föregående fall är den lokala variabeln "viktigare". En variabel som deklareras i ett visst omfång är till exempel inte synlig utanför den

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

Detta exempel kommer inte att kompileras eftersom variabeln y existerar bara inom dess block.
Här är ett annat exempel där variabler som deklareras inuti ett block överlappar varandra

#omfatta #omfatta 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(); )

Programmet kommer att matas ut
30
20
10
Globala variabler bör undvikas. Du kan höra detta väldigt ofta. Låt oss försöka ta reda på varför. I dina enkla projekt ser globala variabler ganska normala ut. Men tänk dig att du har en applikation som

• 1) Utvecklad av flera personer och består av hundratusentals rader kod
• 2) Fungerar i flera trådar

För det första kan en global variabel, om den är synlig för alla, ändras av vilken del av programmet som helst. Du ändrade en global variabel, du vill skriva den, och en annan del av programmet har redan skrivit över ett annat värde i den (i själva verket är detta en hel klass av problem som uppstår i en flertrådig miljö). För det andra, med stora projektstorlekar är det omöjligt att hålla reda på vem och när som skapas globala variabler. Exemplen ovan visar hur variabler kan överlappa varandra, och samma sak kommer att hända i ett stort projekt.

Naturligtvis finns det situationer där globala variabler förenklar programmet, men sådana situationer händer inte ofta och inte i dina läxor, så SKAPA INTE GLOBALA VARIABLER!
Variabler kan inte bara vara heltal och flyttal. Det finns många andra typer som vi kommer att studera vidare.

Detta avsnitt kommer att täcka de viktigaste datatyperna i C++, dessa datatyper kallas även inbyggda datatyper. Programmeringsspråket C++ är ett utbyggbart programmeringsspråk. Begreppet extensible innebär att man förutom inbyggda datatyper kan skapa sina egna datatyper. Därför finns det ett stort antal datatyper i C++. Vi kommer endast att studera de viktigaste.

Tabell 1 - C++-datatyper

Sorts	byte	Omfång av accepterade värden
heltalsdatatyp (boolesk).
bool	1	0 / 255
heltalsdatatyp (tecken).
röding	1	0 / 255
heltalsdatatyper
kort int	2	-32 768 / 32 767
osignerad kort int	2	0 / 65 535
int	4
osignerad int	4	0 / 4 294 967 295
lång int	4	-2 147 483 648 / 2 147 483 647
osignerad lång int	4	0 / 4 294 967 295
flyttalsdatatyper
flyta	4	-2 147 483 648.0 / 2 147 483 647.0
lång flyt	8
dubbel	8	-9 223 372 036 854 775 808 .0 / 9 223 372 036 854 775 807.0

Tabell 1 visar huvuddatatyperna i C++. Hela tabellen är uppdelad i tre kolumner. Den första kolumnen innehåller ett reserverat ord som kommer att definiera varje datatyp. Den andra kolumnen anger antalet byte som är allokerat för en variabel med motsvarande datatyp. Den tredje kolumnen visar intervallet av giltiga värden. Observera att i tabellen är alla datatyper ordnade från minsta till största.

bool datatyp

Den första i tabellen är bool-datatypen — heltalsdatatyp, eftersom intervallet för giltiga värden är heltal från 0 till 255. Men som du redan har märkt är det skrivet inom parentes - boolesk datatyp, och detta är också sant. Därför att bool används endast för att lagra resultaten av booleska uttryck. Ett booleskt uttryck kan ha ett av två resultat sant eller falskt. sant om det booleska uttrycket är sant, falskt om det booleska uttrycket är falskt.

Men eftersom intervallet för giltiga värden för bool-datatypen är från 0 till 255, var det nödvändigt att på något sätt jämföra detta intervall med de logiska konstanterna sant och falskt som definieras i programmeringsspråket. Konstanten sant är alltså ekvivalent med alla tal från 1 till och med 255, medan konstanten false motsvarar endast ett heltal - 0. Tänk på ett program som använder datatypen bool.

// data_type.cpp: definierar startpunkten för konsolapplikationen. #inkludera "stdafx.h" #inkludera använder namnutrymme std; int main(int argc, char* argv) ( bool boolean = 25; // bool typvariabel med namnet boolean if (boolean) // if statement condition cout<< "true = " << boolean << endl; // выполнится в случае истинности условия else cout << "false = " << boolean << endl; // выполнится в случае, если условие ложно system("pause"); return 0; }

PÅ rad 9typvariabel deklarerad bool , som initieras till 25. Teoretiskt sett efterrad 9, i en boolesk variabel bör innehålla talet 25, men i själva verket innehåller denna variabel talet 1. Som sagt, siffran 0 är ett falskt värde, siffran 1 är ett sant värde. Summan av kardemumman är att i en variabel av typ bool kan innehålla två värden - 0 (falskt) eller 1 (sant). Medan under datatyp bool en hel byte tilldelas, vilket innebär att en variabel av typen bool kan innehålla tal från 0 till 255. Endast två värden 0 och 1 behövs för att bestämma falska och sanna värden. Frågan uppstår: "Vad är de andra 253 värdena för?".

Baserat på denna situation kom vi överens om att använda siffrorna från 2 till 255 som likvärdiga med siffran 1, det vill säga sant. Det är precis därför den booleska variabeln innehåller talet 25 och inte 1. In rad 10-13 deklareras, vilket överför kontrollen till utlåtandet i rad 11 om villkoret är sant och operatören in rad 13 om villkoret är falskt. Se resultatet av programmet i figur 1.

Sant = 1 Tryck på valfri tangent för att fortsätta. . .

Figur 1 - bool datatyp

char datatyp

Teckningsdatatypen är en heltalsdatatyp som används för att representera tecken. Det vill säga att varje tecken motsvarar ett visst nummer från intervallet. char-datatypen kallas också för en teckendatatyp, eftersom den grafiska representationen av tecken i C++ är möjlig tack vare char . För att representera tecken i C ++ tilldelas char-datatypen en byte, i en byte - 8 bitar, sedan höjer vi två till 8 och får värdet 256 - antalet tecken som kan kodas. Med hjälp av char-datatypen kan alltså vilket som helst av de 256 tecknen visas. Alla kodade tecken representeras i .

ASCII (från den engelska American Standard Code for Information Interchange) är den amerikanska standardkoden för informationsutbyte.

Överväg ett program som använder datatypen char.

// symbols.cpp: definierar startpunkten för konsolapplikationen. #inkludera "stdafx.h" #inkludera använder namnutrymme std; int main(int argc, char* argv) ( char symbol = "a"; // deklarerar en variabel av typen char och initierar den med symbolen "a" cout<< "symbol = " << symbol << endl; // печать символа, содержащегося в переменной symbol char string = "сайт"; // объявление символьного массива (строки) cout << "string = " << string << endl; // печать строки system("pause"); return 0; }

Så in rad 9en variabel som heter symboler , den tilldelas symbolvärdet"a" ( ASCII-kod). PÅ rad 10 cout operatör skriver ut tecknet i variabeln symbol. PÅ rad 11en strängarray som heter sträng , och storleken på arrayen ställs in implicit. En sträng lagras i en strängarray"hemsida" . Observera att när vi sparade symbolen i en variabel som röding , sedan efter likhetstecknet sätter vi enstaka citattecken, där vi skrev tecknet. När du initierar en strängarray med någon sträng placeras dubbla citattecken efter likhetstecknet, där någon sträng skrivs. Liksom ett vanligt tecken matas strängar ut med operatorn cout, rad 12. Resultatet av programmet visas i figur 2.

Symbol = en sträng = webbplats Tryck på valfri tangent för att fortsätta. . .

Figur 2 - Datatyp char

Heltalsdatatyper

Heltalsdatatyper används för att representera tal. Det finns redan sex av dem i tabell 1: short int , unsigned short int , int , unsigned int , long int , unsigned long int . Alla av dem har sin egen minnesstorlek och intervall av accepterade värden. Beroende på kompilatorn kan mängden minne som används och intervallet av accepterade värden variera. I tabell 1 tas alla intervall av accepterade värden och storlekar av upptaget minne för MVS2010-kompilatorn. Dessutom är alla datatyper i tabell 1 arrangerade i stigande ordning efter storleken på det upptagna minnet och intervallet av accepterade värden. Omfånget av accepterade värden, på ett eller annat sätt, beror på storleken på det upptagna minnet. Följaktligen, ju större storleken på det upptagna minnet är, desto större intervall av accepterade värden. Dessutom ändras intervallet för accepterade värden om datatypen deklareras med prefixet osignerad - utan tecken. Prefixet unsigned betyder att datatypen inte kan lagra signerade värden, och då fördubblas utbudet av positiva värden, till exempel datatyperna short int och unsigned short int .

Prefix för heltalsdatatyper:

kort — prefixet förkortar datatypen på vilken det appliceras, genom att minska storleken på det upptagna minnet;

lång — prefix förlänger datatypen som den appliceras på genom att öka mängden minne som den upptar;

osignerad - Prefixet fördubblar intervallet av positiva värden, medan intervallet av negativa värden inte kan lagras i denna datatyp.

Så i själva verket har vi en heltalstyp för att representera heltal - det här är int-datatypen. Prefixen kort , lång , osignerad ger upphov till en mängd olika int-datatyper som skiljer sig åt i mängden upptaget minne och (eller) intervallet för accepterade värden.

Flyttalsdatatyper

Det finns två flyttalsdatatyper i C++: flytande och dubbel . Flyttalsdatatyper är utformade för att lagra flyttalsnummer. Flyt- och dubbeldatatyperna kan lagra både positiva och negativa flyttal. Flytdatatypen har hälften så mycket minne som upptas av den dubbla datatypen, vilket innebär att intervallet av accepterade värden också är mindre. Om flytdatatypen deklareras med ett långt prefix, kommer intervallet av accepterade värden att bli lika med intervallet av accepterade värden av dubbeldatatypen. I grund och botten behövs flyttalsdatatyper för att lösa problem med hög beräkningsprecision, till exempel pengatransaktioner.

Så vi har övervägt huvudpunkterna angående de grundläggande datatyperna i C ++. Det återstår bara att visa var alla dessa intervall av accepterade värden och storlekarna på det ockuperade minnet kommer ifrån. Och för detta kommer vi att utveckla ett program som kommer att beräkna huvudegenskaperna för alla datatyper som diskuteras ovan.

// data_types.cpp: definierar startpunkten för konsolapplikationen. #inkludera "stdafx.h" #inkludera // I/O-manipulationsbibliotek #include // rubrikfil med matematiska funktioner #include använder namnutrymme std; int main(int argc, char* argv) ( cout<< " data type " << "byte" << " " << " max value "<< endl // kolumnrubriker <<"bool = " << sizeof(bool) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных bool*/ << (pow(2,sizeof(bool) * 8.0) - 1) << endl << "char = " << sizeof(char) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных char*/ << (pow(2,sizeof(char) * 8.0) - 1) << endl << "short int = " << sizeof(short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных short int*/ << (pow(2,sizeof(short int) * 8.0 - 1) - 1) << endl << "unsigned short int = " << sizeof(unsigned short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned short int*/ << (pow(2,sizeof(unsigned short int) * 8.0) - 1) << endl << "int = " << sizeof(int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных int*/ << (pow(2,sizeof(int) * 8.0 - 1) - 1) << endl << "unsigned int = " << sizeof(unsigned int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned int*/ << (pow(2,sizeof(unsigned int) * 8.0) - 1) << endl << "long int = " << sizeof(long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long int*/ << (pow(2,sizeof(long int) * 8.0 - 1) - 1) << endl << "unsigned long int = " << sizeof(unsigned long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных undigned long int*/ << (pow(2,sizeof(unsigned long int) * 8.0) - 1) << endl << "float = " << sizeof(float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных float*/ << (pow(2,sizeof(float) * 8.0 - 1) - 1) << endl << "double = " << sizeof(double) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных double*/ << (pow(2,sizeof(double) * 8.0 - 1) - 1) << endl; system("pause"); return 0; }

Detta program publiceras så att du kan se egenskaperna hos datatyper i ditt system. Du bör inte förstå koden, eftersom programmet använder kontrollsatser som du troligen inte är bekant med ännu. För en ytlig bekantskap med programkoden kommer jag att förklara några punkter nedan. Operatör storlek av() beräknar antalet byte som tilldelats för en datatyp eller variabel. Fungera pow(x,y) höjer värdet x till makten y , den här funktionen är tillgänglig från rubrikfilen . fixerade och setprecision() manipulatorer tillgänglig från header-filen . Den första är fixad , skickar värden i en fast form till utgångsströmmen. Manipulator setprecision(n) visar n decimaler. Det maximala värdet för någon datatyp beräknas med följande formel:

Max_val_type = 2^(b * 8 - 1) - 1; // för datatyper med negativa och positiva tal // där b är antalet byte som allokerats i minnet för en variabel med denna datatyp // multiplicera med 8, eftersom det finns 8 bitar i en byte // subtrahera 1 inom parentes , eftersom intervalltalen måste halveras för positiva och negativa värden // subtrahera 1 i slutet eftersom intervallet av siffror börjar från noll // osignerade datatyper max_val_type = 2^(b * 8) - 1; // för datatyper med endast positiva tal // förklaringar till formeln är likartade, endast en subtraheras inte från parentesen

Ett exempel på hur programmet fungerar kan ses i figur 3. Den första kolumnen visar huvuddatatyperna i C++, den andra kolumnen visar mängden minne som allokerats för varje datatyp och den tredje kolumnen visar det maximala värdet som motsvarande datatyp kan innehålla. Minimivärdet hittas på samma sätt som maximum. I datatyper med prefixet osignerad är minimivärdet 0.

Datatyp byte max värde bool = 1 255,00 char = 1 255,00 kort int = 2 32767,00 osignerad kort int = 2 65535,00 int = 4 2147483647,00 unsigned int = 4 4294967295,00 long int = 4 2147483647,00 unt = 4 4294967295,00 long int = 4 2147483647,00 unt = 4 4294967295,00 long int = 4 2147483647,00 unt = 4 4294967295,00 long int = 4 2147483647,00 OSELT = 4 4294967295,00 långa int = 4 2147483647.00 8 9223372036854775808.00 Tryck på valfri tangent för att fortsätta. . .

Figur 3 - C++-datatyper

Om till exempel en variabel av typen short int tilldelas värdet 33000, så kommer bitrutnätet att svämma över, eftersom maxvärdet i en variabel av typen short int är 32767. Det vill säga något annat värde kommer att lagras i en variabel av typen kort int, troligen blir det negativt. Eftersom vi har berört int-datatypen är det värt att notera att du kan utelämna nyckelordet int och skriva till exempel bara kort . Kompilatorn kommer att tolka en sådan notation som kort int . Detsamma gäller långa och osignerade prefix. Till exempel:

// kort för datatyp int kort a1; // samma som kort int lång a1; // samma som long int unsigned a1; // samma som unsigned int unsigned short a1; // samma som osignerad kort int