Scrigroup - Documente si articole

Username / Parola inexistente      

Home Documente Upload Resurse Alte limbi doc  

CATEGORII DOCUMENTE





BulgaraCeha slovacaCroataEnglezaEstonaFinlandezaFranceza
GermanaItalianaLetonaLituanianaMaghiaraOlandezaPoloneza
SarbaSlovenaSpaniolaSuedezaTurcaUcraineana

BiologieBudovaChemieEkologieEkonomieElektřinaFinanceFyzikální
GramatikaHistorieHudbaJídloKnihyKomunikaceKosmetikaLékařství
LiteraturaManagementMarketingMatematikaObchodPočítačůPolitikaPrávo
PsychologieRůznéReceptySociologieSportSprávaTechnikaúčetní
VzděláníZemědělstvíZeměpisžurnalistika

Softwareová laboratoř - zdrojovÝ text programu

počítačů

+ Font mai mare | - Font mai mic






DOCUMENTE SIMILARE

Trimite pe Messenger

TERMENI importanti pentru acest document

1.   Zdrojový text programu

Překlad programu probíhá podle schématu:



Přeložený program

 


Zdrojový text programu se skládá:

#jméno direktivy parametry

Direktiva #include

Tato direktiva se používá k začlenění knihoven s procedurami do programu.

Zápis:

#include <název souboru>

Standardní knihovna má příponu .h. Kromě toho můžeme vytvářet vlastní knihovny. Potom se zápis změní:

#include “název souboru“

Příklad:

#include <string.h>

#include “deklar.h”

Direktiva #define

Direktiva se používá k definování makra. Platí od místa, kde je zapsána. Platnost lze ukončit pomocí direktivy #undef. Zápis makra:

#define ident tělo_makra

Příklad:

#define Pocet 20

Potom preprocesor změní výpočet:

a= Pocet *10

na

a=20*10

Lze také definovat makro s parametry:

#define ident(ident1,ident2,…identk) tělo_makra

Příklad:

#define Obsah(x,y) x*y

Potom preprocessor změní výpočet:

a= Obsah(b+c,d)

na

a=(b+c)*d

1.2.        Základní datové typy

Datové typy dělíme do tři kategorií:

1.      Základní

2.      Odvozené

3.      Nové

Celočíselné typy

TypDélka datMinMaxRozsah

char1 byteSCHAR_MINSCHAR_MAX-128127

unsigned char1 byte0UCHAR_MAX0…255

short2 byteSHRT_MINSHRT_MAX-32768…32767

unsigned short2 byte0UINT_MAX0…65536

int2 nebo 4INT_MININT_MAXjako short nebo long

unsigned int2 nebo 40UINT_MAXjako unsigned short(long)

long4 byteLONG_MINLONG_MAX-2147483648…2147483647

unsigned long4 byte0ULONG_MAX0…4294967295

Celočíselné typy lze zapisovat ve třech číselných soustavách:

  • desítkové,
  • oktálové,
  • hexadecimální.

Znaky

Používá se char nebo unsigned char. Znaky se zapisují s apostrofy. Např. ‘c’, ‘+’.

Logické hodnoty

Logická hodnotačíselná hodnotabool

Není pravda0false

Je pradva1, libovolná jinátrue

Řetězce

Řetězce se zapisují uzavřené v uvozovkách.

Za poslední znak se ukládá binární 0.

Délka řetězce není omezena.

Příklad:

Řetězec “Jazyk C++” s délkou 9 je v paměti uložen na 10 bytech.

Řídící a některé další znaky s v řetězci zapisují ve formě dvojice znaků:

ZnakVýznam

azvukové znamení

bposun kurzoru o jednu pozici vlevo

fnová stránka

nnový řádek

rnávrat kurzoru na začátek řádku

thorizontální tabulátor

vvertikální tabulátor

obrácené lomítko

apostrof

uvozovka

?Otazník

Čísla v pohyblivé řádové čárce

TypDélkaPřesnostRozsah exponentu

Float4 byte7 míst-37…+38

Double8 byte15 míst-307…+308

long double10 byte17 míst-4931…+4932

1.3.        Identifikátory a deklarace

Identifikátor začíná písmenem nebo znakem _.

Na dalších místech písmena, číslice, _.

Délka není omezená, ale bere se jen prvních 31 znaků.

Dva účely identifikátorů:

  • Pro jména proměnných, konstant, funkcí, …
  • Pro označení cílového návěští příkazu skoku goto.

Schematický tvar deklarace proměnných:

spec typ dekl1 ident1=výraz1, dekl2 ident2=výraz2,…;

Vynecháme-li volitelné specifikace a volitelné deklarační údaje:

typ ident1=výraz1, ident2=výraz2,…;

Příklad:

char ZnakA=‘A‘, ZnakB=ZnakA+1, zn

Pro definování konstanty používáme klíčové slovo const a zápis:

const typ ident1=výraz1, ident2=výraz2,…;

Příklad:

const char ZnakA=‘A‘, ZnakB=ZnakA+1, zn

1.4.        Operátory

Základní vlastnosti:

-          priorita,

-          asociativita.

() slouží k definici, deklaraci a volání funkce.

[] je použit pro deklaraci a zápis prvku pole.

. a -> zajišťují přístup ke členům strukturovaných typů a tříd.

.* a ->*zajišťují přístup ke členům třídy s použitím pointeru na členy třídy.

:: pro vymezení rozsahu platnosti.

Unární operátory

! negace.

~ negace celočíselného operandu ve všech bitech.

- unární operátor pro výpočet opačné hodnoty.

+unární operátor, který nechává hodnotu výrazu beze změny.

+ +inkrementace, zvyšuje hodnotu operandu o 1.

- -dekrementace, snižuje hodnotu operandu o 1.

*dereference, zajišťuje přístup k hodnotě přes pointer.

&operátor adresy.

sizeofdélka datového objektu.

deleteuvolní alokovanou paměť.

Binární operátory

-          aritmetické: + , - , * , / , % (zbytek celočíselného dělení)

-          bitového posuvu: << , >>

-          srovnání: < , <= , > , >= , = = , !=

-          logické: && (součin), || (součet), & (bitový součin), | (bitový součet), ^ (b. nonekvivalence)

-          podmíněný výraz:?: (podmínkový_výraz ? výraz_true : výraz_false)

-          přiřazení: = , *= , /= , %= , += , -= , <<= , >>= , &= , ^= , |= (zkrácení zápisu levá_strana = levá_strana op výraz)

Konverze hodnot

Konverze v operaci přiřazení lvalue=rvalue

1.Celočíselné typy mezi sebou.

2.Celočíselné typy a typy s pohyblivou řádkou.

3.Typy s pohyblivou řádkou a celočíselné typy.

4.Typy v pohyblivé řádce mezi sebou.

2.   Pointery

Pointery jsou proměnné, do kterých se ukládají adresy.

spec typ *dekl ident=výraz, … ;

Lze deklarovat pointer, který není vztažen k žádnému datovému typu:

void *ident;

Příklad:

int *p1, **p2, ***p3;

2.1. Operace s pointery

Pointery reprezentují adresy. Lze s nimi sestavovat různé výrazy:

pointer +- celočíselný výraz

pointer2 – pointer1

Příklad:

long L=3, *pl=&L;

03

00

00

00

pLpL+1

Příklad:

short *pI=adresa; //short (délka 2 byte)

?

?

?

?

?

?

?

?

pI

*pI=1000;

E8

03

?

?

?

?

?

?

pI

*(pI+2)=10;

E8

03

?

?

0A

00

?

?

pI

*++pI=5;

E8

03

05

00

0A

00

?

?

pI

++*pI;

E8

03

06

00

0A

00

?

?

pI

*pI++=2;

E8

03

02

00

0A

00

?

?

pI

(*pI)--;

E8

03

02

00

09

00

?

?

pI

const typ *ident1, *ident2,…;

Příklad:

int i;

const int *pi;

pi=&I;

pi++;

*pi=1 // nelze měnit hodnotu

Konstantní pointery – lze měnit hodnoty, na které pointer ukazuje, ale nelze změnit jeho hodnotu.

typ *const ident1=výraz1, *const ident2=výraz2,…;

Příklad:

int i;

int *const pi=&i;

*pi=2;

pi++; // nelze měnit hodnotu pointeru

Konstantní pointer na konstantní hodnotu – nelze měnit ani hodnotu pointeru ani hodnotu, na níž pointer ukazuje.

const typ *const ident1=výraz1, *const ident2=výraz2,…;

Příklad:

const i=1;

const *const pi=&i;

*pi=2; //nelze měnit hodnotu, na níž pointer ukazuje

pi++; // nelze měnit hodnotu pointeru

3.   Příkazy jazyka

3.1.        Příkaz, složený příkaz

Obdobné příkazy jako v ostatních procedurálních jazycích.

  • Zápis příkazu je vždy ukončen středníkem.
  • Středník je součástí příkazu.

Příklad:

short q;

A=1;

Složený příkaz (Blok)

Je uzavřen složenými závorkami a může obsahovat:

  • příkazy,
  • složené příkazy,
  • deklarace (platnost je pouze ve složeném příkazu).

Příklad:

int j;

j=1;

}

3.2.        Podmíněný příkaz

Dva formáty podmíněného příkazu.

if (podmínkový_výraz) příkaz1

if (podmínkový_výraz) příkaz1 else příkaz2

Příklad:

if (k>0) j=k; else j=-k;

Lze také použít operátor podmíněného výrazu:

j= (k>0) ? k : -k;

Jeli vnořeno více příkazů if, pak část else se vztahuje k nejbližšímu if.

3.3.        Příkazy cyklu

Jsou celkem tři formáty příkazů cyklu:

1. while

while (podmínkový_výraz) příkaz

Je-li hodnota podmínkového výrazu false (0), je cyklus ukončen.

2. do – while

do příkaz while (podmínkový_výraz)

Je-li hodnota podmínkového výrazu false (0), je cyklus ukončen. Cyklus vždy proběhne alespoň 1.

2. for

do (výraz1; podmínkový_výraz; výraz3) příkaz

výraz1 – je vypočítán je jednou před zahájením cyklu.

podmínkový_výraz – podmínka cyklu.

výraz3 – je vypočítán vždy na konci každého průchodu cyklem.

3.4.         Prázdný příkaz

Prázdný příkaz obsahujejen středník.

3.5.        Příkazy continue, break

Continue

Je-li v těle cyklu proveden příkaz

continue;

je daný průchod cyklu ukončen, zbývající příkazy těla cyklu jsou vynechány. U cyklu for je přitom výraz3 vypočítán. Cyklu po continue pokračuje dalším průchodem.

Break

Je-li v těle cyklu proveden příkaz

break;

je cyklus ukončen. Program pokračuje příkazem, který následuje za cyklem.

3.6.        Přepínač switch

Slouží ke větvení programu. Zápis:

switch (celočíselný_výraz)

Na začátku je vypočítán celočíselný_výraz a jeho hodnota je postupně srovnávána s konst_výraz1 konst_výrazm. Jestliže je hodnota shodná, jsou provedeny všechny příkazy až do konce přepínače (tedy i ty, které jsou uvedeny za dalšími hodontami case, včetně default). Proto je obvyklé použít na konci každé části příkaz break. Jestliže nejsou hodnoty shodné, jsou vykonány příkazy v části default .

3.7.        Návěští

Pravidla pro návěští:

  • návěští je identifikátor ukončený dvojtečkou,
  • je v programu uvedeno v cílovém místě skoku,
  • návěští se nikde nedeklaruje,
  • platí pro celou funkci, ve které je uvedeno.

Zápis:

goto návěští;

Příklad:

int i, m, n, licha, suda;

n=1;

m=100;

for (i=m, licha=suda=0; i<=n; i++)

4.   Pole, struktutovaný a výčtový typ

4.1.        Odvozený datový typ

typedef zápis_ve_tvaru_deklarace;

Příklad

Deklarujeme odvozený datový typ pointeru na int:

typedef int *pInt;

Deklarace pointerů

pInt pi,pi1=0;

je ekvivalentní s deklarací

int *pi,*pi1=0;

4.2.        Pole

Pole s jedním rozměrem

Deklarace:

dekl ident[počet_prvků],…;

Zápis prvku pole:

ident[index]

Příklad

int Pole[10];

Prvky pole jsou

Pole[0], Pole[1],… Pole[9]

Deklarace s iniciací:

dekl ident[počet_prvků]=;

Příklad

char Pole[10]=;

Řetězce

Pro uložení řetězců se používají znaková pole (typu char).

Pointery a jednorozměrná pole

Máme-li pole:

dekl ident[počet_prvků];

pak jsou ekvivaletní zápisy:

*identident[0]

*(ident+index)ident[index]

Vícerozměrná pole

Deklarace:

dekl ident[počet_prvků1] [počet_prvků2]… [počet_prvkům];

Zápis prvku pole:

ident[index1][index2]… [indexm]

Příklad

int Pole[2][2];

Prvky pole jsou

Pole[0][0], Pole[0][1], Pole[1][0], Pole[1][1]

Pole lze v deklaraci inicializovat. Platí, že lze vynechat počet prvků pouze u prvního indexu.

Pointery a vícerozměrná pole

Máme-li pole:

dekl ident[počet_prvků1] [počet_prvků2];;

pak jsou ekvivaletní zápisy:

*(ident+ix1)ident[ix1]

a jsou to pointery na řádek pole – jednorozměrné pole.

Všechny tyto čtyři zápisy jsou ekvivalentní:

ident[ix1][ix2]*(ident[ix1]+)

(*(ident+))[ix2]*(*(ident+ix1)+ix2)

4.3.        Strukturované datové typy

Datový typ struct

struct ident dekl1 ident1=inic1,…,dekln identn=inicn;

Příklad

struct Dat1, Dat2, *pDat

Příklad

struct Datum

Datum Dat1, Dat2, *pDat

Přístup ke členům:

proměnná.člen

Operátor -> je pro přístup ke členům při zadaném pointeru:

pointer->člen

Přes pointer lze přistupovat dvěma způsoby:

  • (*pointer).člen
  • pointer->člen

Nedefinovaná deklarace strukturovaného typu

struct ident;

Použijeme ji pro deklaraci pointeru tehdy, kdy není k dispozici úplná deklarace strukturovaného typu (je uvedena v jiné části programu nebo následuje až a deklarací pointeru).

Příklad

struct S2;

struct S1 ;

struct S2 ;

Datový typ union

Všechny členy strukturovaného typu union jsou uloženy na stejné adrese – překrývají se. Délka je rovna délce největšího členu.

union ident dekl1 ident1=inic1,…,dekln identn=inicn;

Příklad

union U

i

c[0]

c[1]

c[2]

c[3]

c[4]

l

4.4.        Bitová pole

U strukturovaných typů lze definovat přesnou velikost členů v bitech. Ty jsou pak uloženy těsně za sebou.

typ ident: počet_bitu;

Příklad

struct Tepl

4.5.        Výčtový typ enum

Používá se pro deklaraci většího počtu celočíselných konstant.

enum ident dekl1 ident1=výraz1,…,dekln identn=výrazn;

Příklad

enum Tyden

Potom jednotlivé konstanty mají hodnoty:

Pondeli=0, Utery=1, Streda=2, Ctvrtek=3, Patek=4, Sobota=10, Nedele=11

5.   Funkce a reference

5.1.        Reference

spec typ &dekl ident=výraz, … ;

Základní vlastnosti:

  • deklarace reference musí obsahovat inicializaci,
  • jiným způsobem než deklarací nelze stanovit referenci na datový objekt,
  • v zápisu reference se na rozdíl od pointerů neuvádí operátor *.

Příklad:

int prom;

int &rprom=I;

rprom = 10;

Princip přístupu je stejný jako u pointeru, ale pointer má širší použití. Hodnotu pointeru lze měnit, s pointery lze provádět aritmetické operace.

Reference na konstantní hodnotu:

const typ &dekl ident=výraz, … ;

5.2.        Funkce

Deklarace:

dekl ident(dekl1 par1, dekl2 par2,… , deklk park)

Jestliže nemá parametry, nechají se závorky prázdné nebo se napíše klíčové slovo void:

dekl ident(void)

Volání:

S parametry:

dekl ident(parv1, parv2,… , parvk)

dekl ident()

Každý program musí obsahovat funkci main. Tuto funkci nelze samostatně volat.

Příklad:

int i=1;

void F()

Uvažujme příkazy:

F( ); // zvýší hodnotu i o 1

F// formálně správně, ale nemá žádný efekt

Funkční hodnota

Návrat z funkce typu void (funkce nevracející hodnotu) je:

return;

U funkce, která vrací hodnotu, je návrat příkazem:

return výraz;

Formální parametry funkce

Jsou tři druhy formálních parametrů:

Parametry dělíme na:

Parametry funkce volané hodnotou

Příklad:

int F(int p1, int p2)

Parametry funkce volané odkazem

Používají se pro:

Příklad:

void Rotace(int *p1, int *p2, int *p3)

Volání:

int i=3, j=-2, k=7;

Rotace (&i, &j, &k);

Jednorozměrná pole lze zapsat jako formální parametr několika způsoby:

Příklad:

#include <limits.h>

long Maxim(long *Cisla, unsigned Pocet)

U vícerozměrných polí můžeme také použít tři způsoby zápisu:

Parametry funkce volané referencí

Příklad:

void Rotace(int &p1, int &p2, int &p3)

Volání:

int i=3, j=-2, k=7;

Rotace (i, j, k);

Typ výsledku funkce

Pro předání výsledku funkce lze použít jeden ze tří způsobů:

Funkce vracející hodnotu

Výsledek funkce vracíme hodnotou pro stejné datové typy, pro jaké používáme volání hodnotou ve formálních parametrech.

Funkce vracející pointer

Prototyp funkce vracející pointer:

spec typ *dekl ident(.. parametry ..)

Příklad:

struct Obdelnik ;

Obdelnik *Vetsi(Obdelnik *o1, Obdelnik *o2)

Volání:

Obdelnik obd1={2.5,4), obd2={3,2), *pobd;

pobd = Vetsi(&obd1, &obd2);

Funkce vracející referenci

Prototyp funkce vracející pointer:

spec typ &dekl ident(.. parametry ..)

Příklad:

struct Obdelnik ;

Obdelnik &Vetsi(Obdelnik &o1, Obdelnik &o2)

Volání:

Obdelnik obd1={2.5,4), obd2={3,2), pobd;

pobd = Vetsi(obd1, obd2);

Implicitní hodnoty parametrů funkce

dekl ident(dekl1 par1, dekl2 par2,… deklk-1 park-1, deklk park= výrazk ,…, dekln parn= výrazn )

Příklad:

int Soucet(int a, int b=2, int c=4)

Funkci lze volat s 1, 2, nebo 3 parametry:

Soucet(1)

Soucet(1,3)

Soucet(1,3,8)

Polymorfní funkce

V programu lze uvést více funkcí se stejným jménem. Musí se však lišit buď počtem nebo typem parametrů.

Příklad:

#include <math.h>

float Obsah(float r)

float Obsah(float a, float b)

Funkci voláme:

Obsah(5)

Obsah(6,2)

Prototyp funkce, deklarace funkce

Prototyp je deklarace funkce s jejími parametry, zatímco funkce samotná je definována v jiném místě programu.

spec typ dekl ident(.. parametry ..);

V deklaraci funkce lze vynechat konkrétní jména formálních parametrů nebo je změnit..

Příklad:

Následující deklarace funkce jsou ekvivalentní:

void Kop(const int *Cis1, int Cis2[], int Počet);

void Kop(const int *C1, int C2[], int P);

void Kop(const int *, int [], int);

Funkce jako datový typ

Deklarace funkce:

typedef dekl ident(dekl1, dekl2,… , deklk);

Příklad:

Následující deklarace funkce jsou ekvivalentní:

typedef double Fun(double);

typedef Fun *pFun;

#include <math.h>

pFun F[3]=;

F[0](.5)

F[1](.5)

F[2](.5)

Deklarace typu pointer na funkci: typedef dekl (*ident)(dekl1,dekl2,…,deklk);

Deklarace typu reference na funkci: typedef dekl (&ident)(dekl1,dekl2,…,deklk);

Funkce jako formální parametr

Lze využít datový typ funkce. Parametr je volán odkazem.

Příklad:

typedef float Fun(float);

float Koren (float x1, float x2, funkce F)

dekl ident(dekl1 par1, dekl2 par2,… , deklk park . . . )

Funkce inline

Slouží pro velice krátké funkce.

Vkládá se do programu jako makro.

inline dekl ident(.. parametry ..)

6.   Vstupy a výstupy

6.1.        Vstupy a výstupy na standardní zařízení

stdout – označení pro standardní výstup - monitor,

stdin – označení pro standardní vstup - klávesnice,

stderr – označení pro standardní zařízení, na které vystupují informační a chybové zprávy – monitor.

Výstup na standardní zařízení

Základní funkce:

int printf(const char *format, …);

parametr format je řetězec, ve kterém jsou obsaženy:

Příklad:

printf(“Jazyk C++“);

Výstup:

Jazyk C++

printf(“nnJazyk C++nje rozšířením jazyka Cna“);

Výstup:

Jazyk C++

je rozšířením jazyka C

Výstup pro hodnoty výrazů:

% příznakypočet_znak;.deset_místF|N|h|I|Ltyp

povinný je jen % a typ.

Typ stanovíme, v jakém tvaru je výstup hodnoty:

Příklad

char Zn=’+’;

printf(“Hodnota znaku ‘%c’ je dekadicky %i a hexadecimálně %X“,Zn,Zn,Zn);

Výstup:

Hodnota znaku ‘+’ je dekadicky 43 a hexadecimálně 2B

Příklad

printf(“n%.3f“,10.12345);

Výstup:

10.123

Příklad

printf(“%05u“,10);

Výstup:

00010

V části příznaky lze uvést znaky:

Příklad

printf(“%+-4i|% i|% i“,1,2,-3);

Výstup:

+1| 2|-3

Další parametry:

Příklad

cislo=123456;

printf(“%li %i“,cislo,cislo);

Výstup:

123456 -7616


Vstup ze standartního zařízení

Základní funkce:

int scanf(const char *format, adresa1,adresa2…);

-          format stejný jako u printf jen neobsahuje texty a řídící znaky,

-          adresa1,adresa2 udávají adresy, na které se uloží přečtené hodnoty.

Příklad

int i,j,k;

scanf(“%i%i%i“,&i,&j,&k);

Příklad

unsigned i,j,k;

scanf(“%2u%5u%3u“,&i,&j,&k);

printf(“%u%u%u”,i,j,k);

Vstup:

1234567890

Výstup:

1234567890

Další funkce a makra výstupu na stand. zař.

int putchar(int ch);

int puts(const char *s);

int getchar(void);


int *gets(char *s);

FILE *fopen(const char *filename, const char * mode);

int fprint(FILE *stream, const char *format, …);

Příklad

FILE *Soubor;

Soubor=fopen(“Test”,”w”);

char S[]=”Jazyk C++”,C=’$’;

fprint(Soubor,“%s%c”,S,C);

Neformátový výstup

unsigned fwrite(const void *ptr,size_t size, size_t count,FILE *stream);

int fputc(int c,FILE *stream);

int putc(int c,FILE *stream);

int fputs(const char *c,FILE *stream);

int putw(int w,FILE *stream);

int fprint(FILE *stream, const char *format, adresa1,adresa2…);

Příklad

FILE *Soubor;

int i,j;

char Str[100];

Soubor=fopen(“Test”,”r”);

fscan(Soubor,“%i%i%s”,&I,&j,Str);

Neformátový vstup

unsigned fread(void *ptr,size_t size, size_t count,FILE *stream);

Další funkce a makra pro vstup

int fgetc(FILE *stream);

int getc(FILE *stream);

int *fgets(char *s, int n, FILE *stream);

int getw(FILE *stream);

int feof(FILE *stream);

int fclose(FILE *stream);

int ferror(FILE *stream);

void clearerr (FILE *stream);

void perror (const char *s);

long ftell (FILE *stream);

int fseek (FILE *stream,long offset, int whence);

int rename (const char *oldname,const char *newname);

int remove (const char *filename);

int sprintf (char *buffer,const char *format);

int sscanf (const char *buffer,const char *format, adresa1,adresa2…);

-          pro formátový vstup řetězce,

-          buffer adresa vstupního pole.

7.   Základní struktura programu

Typické uspořádání programu:

direktivy preprocesoru

deklarace

definice funkcí

definice hlavní funkce - main

Jiné uspořádání programu:

direktivy preprocesoru

deklarace datových typů

prototypy funkcí

deklarace konstant a proměnných

definice hlavní funkce - main

definice ostatních funkcí

7.1.        Specifikace uložení v paměti

V deklaraci lze použít jedno z klíčových slov auto, extern, static a register. Specifikuje se jimi, kde hodnota bude uložena.

Specifikace auto

(typ)výraz

typ(výraz)

Příklad:

Místo zápisu:

l=(long)i+(long)j;

můžeme použít:

l=long(i)+long(j);

8.   Standardní funkce, pole pointerů

8.1.        Alokace a uvolnění paměti

Operátory new a delete

Zápis alokace paměti:

pointer = new name

Operace new vrací:

Zápis uvolnění alokované paměti:

delete pointer

Zápis alokace pole:

pointer = new dekl[počet_prvků1] [počet_prvků2]… [počet_prvkům];

Uvolnění alokované paměti pro pole:

delete [] pointer

Alokace a uvolnění paměti

Funkce jsou v souborech <ALLOC.H> a <MALLOC.H>.

void *malloc(size_t size);

void *calloc(size_t nitems,size_t size);

free(pointer)

Realokace paměti

Pro změnu rozsahu alokovaného bloku paměti použijeme funkci:

void *realloc(void *oldblock,size_t size);

unsigned coreleft();

Pro velké datové modely:

unsigned long coreleft();

Test paměti

Funkce pro test správného přidělování paměti.

int heapcheck();

char *strcpy(char *dest, const char * src);

Příklad:

char Jaz[]=“Jazyk C++“, Ret[20];

strcpy(Ret,Jaz);

char *strncpy(char *dest, const char * src, size_t maxlen);

char *strcat(char *dest, const char * src);


Příklad:

char Ret=“Jazyk“;

strcat(Ret,“ C++“);

char *strncat(char *dest, const char * src, size_t maxlen);

size_t strlen(const char * s);

Kopírování řetězce

char *stcpy(char *dest, const char * src);

char *strdup(const char * src);

int *strcmp(const char *s1, const char * s2);

int *strncmp(const char *s1, const char * s2, size_t maxlen);

int *stricmp(const char *s1, const char * s2);

int *strnicmp(const char *s1, const char * s2, size_t maxlen);


Vyhledávání zanku v řetězci

const char *strchr(const char *s, int c);

const char *strrchr(const char *s, int c);

const char *strrchr(char *s, int c);

const char *strpbrk(const char *s1, const char *s2);

char *strpbrk(char *s1, const char *s2);

const char *strstr(const char *s1, const char *s2);

char *strstr(char *s1, const char *s2);

char *strupr(char *s);

char *strlwr(char *s);

char *strset(char *s, int c);

char *strnset(char *s, int c, size_t n);

void *memcpy(void *dest, const void *src, size_t n);

void *memmove(void *dest, const void *src, size_t n);

int memcmp(const void *s1, const void * s2, , size_t n);

int memicmp(const void *s1, const void * s2, size_t n);

void *memchr(const void *s, int c, size_t n);

char *memset(char *s, int c, size_t n);

Prototyp makra:Makro testuje, zda parametr c je

int isalnum(int c); písmeno nebo číslice

int isalpha(int c); písmeno

int isdigit(int c); číslice

int islower(int c); malé písmeno

int isupper(int c); velké písmeno

int isxdigit(int c); hexadecimální číslice

int isprint(int c); tisknutelný znak

int isgraph(int c); tisknutelný znak mimo mezeru

int isascii(int c); znak v základní části ASCII tabulky

int iscntrl(int c); řídíci znak

int isspace(int c); mezera nebo znaky 9-0xD

int tolower(int c);

int _tolower(int c);

int tolupper(int c);

int _toupper(int c);


8.5.        Pole pointerů

spec typ *dekl ident[počet prvk;]=seznam;

Příklad:

#include <stdio.h>

const char *Mesice[]=;

void main()

9.   Třídy, objekty

struct identt deklx1,…, deklxm;




class identt deklx1,…, deklxm;

identt ident(..parametry..);

identt *identp = new identt(..parametry..);

identt ident;

identt *identp = new identt;

identt ident = parametr;

Příklad:

Retez r2(50);

Retez r2=50;

identt::~ident();

identt(..parametry..):i1(výraz1), i2(výraz2),…, ik(výrazk) ;

9.4.        Definice členských funkcí

dekl identt::ident(..parametry..) ;

dekl identt::ident;

dekl identt::ident=výraz;

o       jejich hodnota je společná pro všechny objekty třídy,

o       pro přístup k takovýmto datovým členům můžeme použít standardní přístup přes objekty nebo tvar zápisu, který není vztažen k žádnému objektu:

identt::ident

9.6.        Statické funkce

friend B;

friend class B;

9.8.        Spřátelené funkce

friend dekl B::F(..parametry..);

friend dekl ::F(..parametry..);

9.9.        Konstantní funkce

dekl identt::ident(..parametry..) const;

9.10.   Konstantní objekt

identt *pointer;

pointer=new identt [počet_objektů];

delete [] pointer;

identt (..parametry..): ident1 (..parametry..)… identj (..parametry..);

9.14.   Skrytí datových členů (encapsulation)

-          v objektově orientovaném programování se preferuje skrytí všech datových členů třídy , tj. žádný datový člen není přístupný mimo třídu (není public),

-          veškeré operace a manipulace s datovými členy jsou zajištěny prostřednictvím členských funkcí.

10.         Dědění tříd

10.1.   Dědění jedné třídy

-          dědičnost nám umožňuje deklarovat novou třídu, která přejímá (dědí) datové členy a funkce jiné nebo jiných tříd,

-          nejčastější je případ, kdy nová třída B dědí datové členy a funkce z jedné třídy A:


Přístupové vlastnosti členů při dědění třídy

class B : public A ;

-          specifikace public u výchozí třídy A stanoví toto:

o       Člen z třídy A:publicprotectedprivate

o       je vetřídě B jako:publicprotectednení přístupný

class B : protected A ;

-          specifikace protected u výchozí třídy A stanoví toto:

o       Člen z třídy A:publicprotectedprivate

o       je vetřídě B jako:protectedprotectednení přístupný

class B : private A ;

-          specifikace private u výchozí třídy A stanoví toto:

o       Člen z třídy A:publicprotectedprivate

o       je vetřídě B jako:privateprivatenení přístupný

-          toto je implicitní specifikace a je shodná s tím, když klíčové slovo private neuvedeme.

Konstruktory a destruktory

-          při vzniku a zániku objektu třídy, která vznikla děděním, se vedle konstruktoru a destruktoru volá automaticky i konstruktor a destruktor děděné třídy,

-          při vzniku objektu je nejdříve volán konstruktor děděné třídy a po něm vlastní konstruktor třídy,

-          při zániku objektu je naopak nejdříve volán vlastní destruktor třídy a po něm destruktor děděné třídy,

-          v případě, kdy konstruktor děděné třídy A má parametry, je nutné v definici konstruktoru třídy B uvést volání konstruktoru třídy A. Zápis konstruktoru třídy B, který dědí třídu A:

B(..parametryB..): A (..parametryA..);

Operátor rozlišení

::ident

identt::ident

Virtuální funkce

-          vezměme nyní tento případ:

Příklad:


#include <stdio.h>

#include <math.h>

class Valec

float Obsah()

float Objem() };

class Kvadr: public Valec

float Obsah() };

Valec Val(2,5);

Kvadr Kv(2,3,5);

void main()

Výstup: 125.664 125.664

-          pro tyto případy se zavádí virtuální funkce:

#include <stdio.h>

#include <math.h>

class Valec

virtual float Obsah()

float Objem() };

class Kvadr: public Valec

float Obsah() };

Valec Val(2,5);

Kvadr Kv(2,3,5);

void main()

Výstup: 125.664 30

-          funkce, která je zapsána v tomto tvaru:

virtual dekl identt (..parametry..)=NULL;

virtual dekl identt (..parametry..)=0;

A *p;

p -> člen_třídy_A

-          operace je korektní, jestliže pointer obsahuje adresu objektu třídy A nebo adresu objektu, která třídu A dědí.

Příklad:

class A;

class B: public A ;

A a, *pa;

B b, *pb;

a=b;

b=a; //chyba

pa=&a;

pa=&b;

pb=&a; //chyba

-          ve třídě lze definovat virtuální destruktor (konstruktor virtuální být nemůže).

10.2.   Dědění více tříd

-          dědičnost více tříd využíváme pro sestavení třídy, ve které používáme (dědíme), datové členy a funkce z více různých tříd:

Třída A1

 

Třída An

 



-          deklarace třídy B, která dědí třídy A1, A2, …, An:

class B : public A1, public A2,…, public An;

Konstruktory a destruktory

B(..parametry..) : A1(..parametry..), A2(..parametry..),…, An (..parametry..);

Vícenásobný přístup, virtuální dědění třídy

-          vezměme si tento případ:


-          v třídách B1 a B2 jsou stejné proměnné a funkce, které obě třídy podědily z třídy A. Třída C touto cestou dědí dvakrát,

-          pro tyto případy se používá virtuální dědění tříd. Třída, která je při dědění označená klíčovým slovem virtual, je děděná vždy jen jedenkrát bez ohledu na to, kolika cestami je děděná,

-          předchozí příklad by vypadal takto:

class A ;

class B1: public virtual A ;

class B2: public virtual A ;

class C: public B1, public B2;

-          konstruktory virtuálně děděných tříd jsou volány před konstruktory nevirtuálně děděných tříd,

-          destruktory virtuálně děděných tříd jsou volány až po destruktorech nevirtuálně děděných tříd,

-          lze dědit stejné datové členy a funkce i bez virtuálních tříd, pak při jejich použití je operátorem :: nutné stanovit, z které třídy jsou zděděné.

11.         Streamy

-          stream je termín pro datový tok,

-          používají se pro vstup a výstup,


11.1.   Streamy pro standardní zařízení

-          všechny třídy se nacházejí v knihovně iostream.h

Výstup na standardní zařízení

-          výstup přes stream cout je obdobou funkce printf,

-          pro výstup se používá překrytý operátor <<:

cout << výstup

-          hodnoty výstupuv pořadí, v jakém jsou v příkazu výstupu zapsány zleva doprava,

-          do příkazu výstupu lze uvést výrazy datových typů:

o       char, int, long,

o       char *(výstup řetězce),

o       float, double, long double,

o       void * (výstup pointeru).

Příklad:

char c= ‘A’;

int I= -5;

cout<<”nZnak: “<< c << “ vyraz: “<< i+2;

Výstup: Znak: A vyraz: -3

Formátování výstupu – manipulátory

-          manipulátory jsou definovány v souboru iomanip.h,

-          hlavní manipulátory jsou tyto:

Manipulátor:Hodnota:Význam:

skipws1přeskočí nevýznamné mezery při vstupu

left2zarovná vstup vlevo

right4zarovnává výstup vpravo

internal6vložení mezery po znaménku nebo označení číselné soustavy

dec0x10desítková soustava

oct0x20oktálová soustava

hex0x40hexadecimální soustava

showbase0x80zobrazení číselné soustavy u výstupní hodnoty

showpoint0x100zobrazení desetinné tečky

uppercase0x200výstup hexadecimálních čísel velkými písmeny

showpos0x400výstup kladných čísel se znaménkem +

scientific0x800výstup čísel v pohyblivé řádové čárce s exponentem

fixed0x1000výstup čísel v pohyblivé řádové čárce v desetinném tvaru

unitbuf0x2000vyprázdnění vyrovnávacích pamětí všech streamů

stdio0x4000vyprázdnění vyrovnávacích pamětí vstupů na stdout, stderr

Příklad:

cout<< oct << 100 << “ “;

cout<< dec << 100 << “ “ << hex << 100;

-          pro nastavení dalších manipulátorů , které jsou definovány ve třídě ios, se používá funkce:

setioflags(long);

resetioflags(long);

-          další manipulátory:

o       endl – přechod na nový řádek,

o       ws – vynechá nevýznamné mezery (je určen pro vstup),

o       ends – při výstupu ukládá ukončující nulu na konec řetězce,

o       setw(šířka) – nastavení šířky výstupu ve znacích,

o       setprecision(počet míst) – pro nastavení počtu míst výpisu čísla v pohyblivé řádové čárce,

o       setfill(znak) – definuje znak pro vyplnění výstupu s pevnou délkou.

-          některé manipulátory se dají nahradit funkcemi, definovanými ve třídě ios:

Manipulátorlze nahradit funkcí

setw(n)width(n)

precision(n)precision(n)

setfill(c)setf(l)

setiosflags(l)setf(l)

resetiosflags(l)unsetf(l)

Vstup ze standardního zařízení

-          výstup přes stream cin je obdobou funkce scanf,

-          pro výstup se používá překrytý operátor >>:

cout >> výstup

-          hodnoty výstupuv pořadí, v jakém jsou v příkazu výstupu zapsány zleva doprava,

-          pro ověření, zda vstup hodnot proběhl bez chyb, lze použít překrytí operátoru ! nebo konverze na typ void *,

-          lze také použít funkci good, kterávrací nenulovou hodnotu, jestliže je vstup úspěšný,

-          jestliže pokračujeme nebo opakujeme čtení, je nutné příznak vynulovat funkcí:

void clear(int=0);

istream &ignore(int n=1, int delim=EOF);

int peek();

istream &putback(char);

ifstream (const char far *, int=ios::in, int=filebuf::openprot);

ofstream (const char far *, int=ios::out, int=filebuf::openprot);

fstream (const char far *, int, int=filebuf::open prot);

void open(const char far *, int=ios::in, int=filebuf::openprot);

void open(const char far *, int=ios::out, int=filebuf::openprot);

void open(const char far *, int, int=filebuf::openprot);

void close();

Formátový vstup/výstup

ostream &write(const signed char *, int n);

ostream &write(const unsigned char *, int n);

ostream put(char);

Funkce read

istream &read(signed char *, int);

istream &read(unsigned char *, int);

istream &get(signed char *, int len, char=’n’);

istream &get(unsigned char *, int len, char=’n’);

istream &get(signed char &);

istream &get(unsigned char &);

Funkce getline

istream &getline(signed char *, int len, char=’n’);

istream &getline(unsigned char *, int len, char=’n’);

Test konce souboru

int eof();

int gcount();

Příznaky chyb při zpracování

int good();

int fail();

int bad();

void clear();

Přímý přístup k souboru

long tellg();

long tellp();

istream& seekg(long);

istream& seekg(long,seek_dir);

istream& seekp(long);

istream& seekp(long,seek_dir);

istrstream (const char *);

istrstream (const char *, int n);

ostrstream (char *, int, int=ios::out);

strstream (char *, int, int);

-          v 1. parametru zadáme adresu výstupního pole,

-          v 2. parametru je délka výstupního pole,

-          3. parametr má běžné hodnoty - ios::out, ios::ate, ios::app, ios::binary (binární zápis nebo čtení).

12.         Překrytí (overloading) operátorů

-          překrytí operátorů umožňuje některé členské funkce nahradit operátory,

-          překrýt lze všechny operátory kromě:

o       .výběr členu

o       .*pointer na člen

o       ::vymezení rozsahu platnosti

o       ?:podmíněný výraz

-          při překrytí zůstávají zachovány základní vlastnosti operátorů:

o       arita – unární operace při překrytí zůstává unární, binární binární,

o       priorita – ve výrazu, který obsahuje překryté operátory, je pořadí vykonání operace určeno standardními prioritami operátorů.

-          překrytí operátoru lze definovat jen pro třídy (až na některé speciální případy),

-          jsou dva způsoby, jak definovat překrytí operátorů:

o       členskou funkcí třídy,

o       funkcí, která není členská.

-          u překrytí členské funkcí se používá tvar:

Třída

 

operace

 

libovolný datový typ

 


binární

operace

 

Třída

 


unární

-          u překrytí nečlenskou funkcí se používá stejný tvar, ale může se použít i:

libovolný datový typ

 

operace

 

Třída

 


dekl operator op (dekl2);

o       dekl je deklarace typu výsledku operace,

o       op je překrytý operátor,

o       dekl2je deklarace pravého operandu operace.

Příklad:

short operator + (short j)

-          překrytí běžných (prefixových) unárních operátorů je definováno členskou funkcí tvaru:

-         

dekl operator op ();

dekl operator [] (operand_indexu) ;

12.2.   Překrytí operátoru volání funkce ( )

dekl operator ( ) (seznam formálních parametrů) ;

12.3.   Překrytí operátorů ++ a - -

dekl operator ++ ();

dekl operator - - ();

dekl operator ++ (int);

dekl operator - - (int);

12.4.   Pointer na objekt

return this;

return *this;

12.5.   Konverze typu ( )

operator dekl ();

-          dekl je deklarace datového typu, na který má být třída konvertována.

Příklad:

class Int

operator int () }

void main()

12.6.   Překrytí operátorů << a >>

-          oba operátory lze jsou z hlediska překrytí binární operátory:

třída &operator << (operand);

třída &operator >> (operand);

12.7.   Překrytí operátoru funkcemi, které nejsou členské

dekl operator op (ident &);

dekl operator op (ident &, dekl2); dekl operator op (dekl1,ident &);

istream &operator >> istream &,ident &);

ostream &operator << ostream &,ident &);

template<class T> class ident ;

template<typename T> class ident ;

ident<dekl> objekt;

template<typ ident> class ident ;

template<arg1,…, argk> class ident ;

template<arg1,…, argk> dekl ident (..parametry..);

1.      U standardních funkcí a operátorů výjimky nahrazují původní příznaky chyb.

2.      Při psaní programu můžeme při sestavování tříd výjimky využít pro ošetření chyb a jiných nežádoucích stavů, ke kterým může dojít v objektech třídy při výpočtu.

class identt {..deklarace dat.členů a definice funkcí

class ident1 ;

class ident2 ;

class identm ; };

throw identj ( );

try

catch (identt:: identi)

catch (identt:: identj)

catch (identt:: identk)

try

catch (…)

Příklad:

class Int

operator / (int j) }

class Deleni_Nulou ; };

void main()

catch (Int::Deleni_Nulou)

}

void ident ( );

set_terminate (ident);

throw;

try

catch (identt:: identi)

}

catch (identt:: identj)

dekl ident(..parametry..) throw (ident1,…,identk);

dekl ident(..parametry..) throw ();

void ident ( );

set_unexpected (ident);

14.1.   Výjimky při alokaci paměti operátorem new

void ident ( );

set_new_handler (ident);

#if podmínka

Část programu začleněna do překladu v případě, že podmínka je splněna (různá od nuly).

#endif

#if podmínka

Část programu začleněna do překladu v případě, že podmínka je splněna (různá od nuly).

#else

Část programu začleněna do překladu v případě, že podmínka není splněna (je rovna nuly).

#endif

#ifdef ident

#ifndef ident

#define ident

#define ident

#undef ident

15.2.   Rozdělení programu na dvě části – project

-          velké programy je účelné rozdělit do více zdrojových částí:

zdrojový soubor 1

 


překlad

 

zdrojový soubor k

 

překlad

 

modul 1

 

modul k

 

knihovny

 


sestavení

 


-          pro vzájemné propojení jednotlivých zdrojových souborů máme prostředky:

1.      Hlavičkové soubory, ve kterých uvádíme:

o       prototypy (deklarace ) funkcí,

o       deklarace odvozených a nových datových typů,

o       deklarace konstant,

o       vzory tříd a funkcí.

2.      Deklarace typu extern.

void main(int argc, char *argv[]);

void exit(int status);

void abort( );

asm(instrukce_asembleru);

15.7.   Standardně definovaná makra

-          seznam předdefinovaných maker:

Jméno markaVýznam

_LINE_číslo řádku zdrojového souboru

_FILE_název zdrojového souboru

_DATE_datum kompilace programu

_TIME_čas kompilace programu

_LINE_číslo řádku zdrojového souboru

16.         Nové prvky jazyka

   Třída pro uložení řetězců – string

Pro uložení a práci s řetězci byla vytvořena třída string, která je deklarována v souboru cstring.h. Ve třídě je definována řada funkcí a překrytých operátorů, které poskytují obdobné možnosti práce s řetězci jako standardní funkce ze souboru string.h.

Deklarace implicitního konstruktoru:

string();

string(const string far &s);

string(const string far *cp);

string(char c);

string(char c, size_t n);

Do objektu je uložen řetězec délky n, který má na všech pozicích znak c.

Operace konkatencae

Pro operaci konkatenace (připojení dalšího řetězce k řetězci uloženému v objektu) lze použít funkci append nebo operátor +=.

string far &append(const string far &s);

string far &append(const char far *cp);

string far &operator += (const string far &s);

string far &operator += (const char far *cp);

Operace srovnání

Pro srovnání je funkce compare a operátory = =, !=, <, >, <= a >=. Umožňují vzájemně srovnat dva řetězce v objektech nebo srovnat řetězec v objektu s běžným řetězcem. Funkce compare vrací stejné hodnoty jako funkce strcmp.

Operace vstupu a výstupu

Ve třídě jsou také překryté operátory >> a <<. Výsledkem operátoru<< respektive >> je reference na třídu istream respektive ostream.

Ostatní funkce

-          délku řetězce vrací funkce length

-          zda je řetězec prázdný, lze zjistit pomocí funkce is_null. Výsledek funkce je 1 pro prázdný řetězec, jinak 0,

-          pro přístup k libovolnému znaku řetězce jsou operátory indexu [] a funkce (). Jejich použití je shodné:

char operator [] (size_t);

char far &operator [] (size_t);

První překrytí vrací znak, což je rvalue. Druhé překrytí je reference na znak. U reference jde o lvalue a lze mu tedy přiřadit hodnotu.








Politica de confidentialitate

DISTRIBUIE DOCUMENTUL

Comentarii


Vizualizari: 943
Importanta: rank

Comenteaza documentul:

Te rugam sa te autentifici sau sa iti faci cont pentru a putea comenta

Creaza cont nou

Termeni si conditii de utilizare | Contact
© SCRIGROUP 2019 . All rights reserved

Distribuie URL

Adauga cod HTML in site