Ñ++ ÷àñò.2 (Òèïîâå äàííè)

C++ » C++

fix3d   òðóäíîñò:    âèäÿí: 8097

2.4. Ñúîòíàñÿùè òèïîâå (reference types)

Òîçè òèï ñå äåôèíèðà êàòî ñëåä ñïåöèôèêàòîðà íà òèï ñå äîáàâè àäðåñåí îïåðàòîð. Äåôèíèöèÿòà íà ñúîòíåñåí îáåêò òðÿáâà äà âêëþ÷âà è èíèöèàëèçàöèÿ. Íàïðèìåð,

int val = 10;
int &refal = val; // ok
int &refVal12; // error: uninitialized

Ñúîòâåòñòâàùèÿ òèï ïîíÿêîãà ñå íàðè÷à îùå ïñåâäîíèìåí è ïðåäëàãà àëòåðíàòèâíî èìå çà îáåêòà, ñ êîéòî å áèë èíèöèàëèçèðàí. Âñè÷êè îïåðàöèè, ïðèëîæåíè êúì ïñåâäîíèìà âúçäåéñòâóâàò è íà ñúîòíåñåíèÿ îáåêò. Íàïðèìåð,

refVal += 2;

äîáàâÿ 2 êúì val, êàòî òÿ ñòàâà 12.

int ii = refVal;

ïðèñâîÿâà íà ii ñòîéíîñòòà íà val, äîêàòî

int *pi = &refVal;

èíèöèàëèçèðà pi ÷ðåç àäðåñà íà val.

Çà ñúîòíàñÿíåòî ìîæå äà ñå ìèñëè êàòî çà ñïåöèàëåí âèä óêàçàòåë, êúì êîéòî ìîæå äà áúäå ïðèëàãàí ñèíòàêñèñà íà îáåêòè. Íàïðèìåð, ñòîéíîñòòà íà èçðàçà

( *pi == refVal && pi == &refVal )

âèíàãè å èñòèíà àêî pi è refVal àäðåñèðàò åäèí è ñúù îáåêò. Çà ðàçëèêà îò óêàçàòåëÿ, îáà÷å, ñúîòíîñèòåëíàòà ïðîìåíëèâà ìîæå äà áúäå èíèöèàëèçèðàíà è, âåäíúæ èíèöèàëèçèðàíà, íå ìîæå äà ñòàíå ïñåâäîíèì íà äðóã îáåêò.

 ñïèñúêà îò äåêëàðàöèè íà äâå èëè ïîâå÷å ïðîìåíëèâè -ïñåâäîíèìè å íåîáõîäèìî äà ñå äîáàâÿ àäðåñåí îïåðàòîð ïðåä âñåêè èäåíòèôèêàòîð. Íàïðèìåð,

int i;

int &f1 = i, r2 = i; // one reference, r1; one object, r2
int r1, &r2 = i; // one object, one reference, r2
int &r1 = i, &r2 = i; // two references, r1 and r2

Âñåêè ïñåâäîíèì ìîæå äà áúäå èíèöèàëèçèðàí êàòî ñå èçïîëçóâà íÿêàêâà ñòîéíîñò çà ÷åòåíå rvalue.  òîçè ñëó÷àé, ñå ãåíåðèðà è èíèöèàëèçèðà åäíà âúòðåøíà âðåìåííà ïðîìåíëèâà ñúñ ñòîéíîñò çà ÷åòåíå. Òîãàâà ïñåâäîíèìúò ñå èíèöèàëèçèðà ñ òàçè âðåìåííà ïðîìåíëèâà. Íàïðèìåð, èçðàçúò

int &ir = 1024;

ñå ïðåîáðàçóâà òàêà:

int T1 = 1024;
int &ir = T1;

Èíèöèàëèçàöèÿ íà ïñåâäîíèì êàòî ñå èçïîëçóâà îáåêò, êîéòî íå ñúîòâåòñòâóâà òî÷íî ïî òèï, ñúùî ïðåäèçâèêâà ãåíåðèðàíå íà âúòðåøíà ïðîìåíëèâà. Íàïðèìåð, äåôèíèöèÿòà

unsigned int ui = 20;
int &ir = ui;

ñå ïðåîáðàçóâà êàòî

int T2 = int(ui);
int &ir = T2;

Îñíîâíîòî èçïîëçóâàíå íà òîçè òèï å êàòî àðãóìåíò èëè êàòî òèï çà âðúùàíå, îñîáåíî êîãàòî ñå ïðèëàãà çà äåôèíèðàíè îò ïîòðåáèòåëÿ êëàñîâè òèïîâå.

2.5. Êîíñòàíòíè òèïîâå

Ñúùåñòâóâàò äâà ïðîáëåìà ñ îïåðàòîðà çà öèêúë for, îòíàñÿùè ñå äî èçïîëçóâàíåòî íà 512 êàòî ãîðíà ãðàíèöà.

for (int i = 0; i < 512; ++i );

Ïúðâèÿò ïðîáëåì å ñâúðçàí ñ ÷åòèìîñòòà íà òåêñòà. Êàêâî îçíà÷àâà äà ñå ñðàâíè i ñ 512? Êàêâî ïðàâè öèêúëà, ò.å., êàêâî çíà÷åíèå èìà 512? ( òîçè ïðèìåð, 512 ìîæå äà ñå íàðå÷å “âúëøåáíî ÷èñëî”, ÷èåòî çíà÷åíèå íå å î÷åâèäíî â êîíòåêñòà íà èçïîëçóâàíåòî ìó.  òîçè ñëó÷àé ìîæå äà ñå êàæå, ÷å ÷èñëîòî å îòêúñíàòî îò ñðåäàòà ñè).

Âòîðèÿò ïðîáëåì å ñâúðçàí ñ ïîääúðæàíåòî. Ïðåäñòàâåòå ñè, ÷å äàäåíà ïðîãðàìà ñå ñúñòîè îò 10,000 ðåäà. Öèêúë for îò ïîäîáåí âèä ñå ÿâÿâà â 4% îò òåêñòà. Ñòîéíîñòòà 512 òðÿáâà äà áúäå ïðîìåíåíà íà 1024. Âñè÷êèòå 400 ïîÿâÿâàíèÿ íà 512 òðÿáâà äà áúäàò îòêðèòè è ïðîìåíåíè. Ïðîïóñêàíåòî äîðè è íà åäèí åêçåìïëÿð ïðåêúñâà ïðîãðàìàòà.

Äâàòà ïðîáëåìà ìîãàò äà áúäàò ðåøåíè êàòî ñå èçïîëçóâà èäåíòèôèêàòîð, èíèöèàëèçèðàí ñ 512. ×ðåç èçáèðàíåòî íà ïîäõîäÿùî ìíåìîíè÷íî èìå, íàïð. bufSize, íèå ìîæåì äà íàïðàâèì ïðîãðàìàòà ïî-ëåñíà çà ÷åòåíå. Ïðîâåðêàòà ñåãà å ïî-ñêîðî ñïðÿìî èäåíòèôèêàòîð, îòêîëêîòî ñïðÿìî êîíñòàíòà:

i < bufSize

Âå÷å íå å íåîáõîäèìî äà áúäàò ïðîìåíÿíè 400 - òå ïîÿâè íà êîíñòàíòàòà çà ñëó÷àÿ, êîãàòî ñå ïðîìåíÿ bufSize. Ïî-ñêîðî ìîæå äà áúäå êîðèãèðàí ñàìî ðåäà, íà êîéòî ñå èíèöèàëèçèðà bufSize. Òîâà íå ñàìî çíà÷èòåëíî íàìàëÿâà ðàáîòàòà, íî è ñíèæàâà âåðîÿòíîñòòà çà äîïóñêàíå íà ãðåøêè. Öåíàòà íà ðåøåíèåòî å åäíà äîïúëíèòåëíà ïðîìåíëèâà. Çà ñòîéíîñòòà 512 ñåãà ìîæå äà ñå êàæå, ÷å å ëîêàëèçèðàíà.

int bufSize = 512; // input buffer size
// ...
for ( int i = 0; i < bufSize; ++i )
// ...

Ïðîáëåìúò ïðè òîâà ðåøåíèå å, ÷å bufSize å ñòîéíîñò çà çàïèñ - lvalue. Âúçìîæíî å ïðîìåíëèâàòà bufSize ñëó÷àéíî äà áúäå ïðîìåíåíà â ïðîãðàìàòà. Íàïðèìåð, åòî åäíà îáùà ãðåøêà, ïðàâåíà ÷åñòî îò ïðîãðàìèñòè ïðåìèíàâàùè îò ïàñêàëîïîäîáåí åçèê êúì Ñ++.

// accidentally changes the value of bufSize
if ( bufSize = 1 )
// ...

 Ñ++ “=” å îïåðàòîð çà ïðèñâîÿâàíå, à “==” å îïåðàòîð çà ïðîâåðêà íà ðàâåíñòâî. Ïàñêàë è ïðîèçëåçëèòå îò íåãî åçèöè èçïîëçóâàò “=” êàòî îïåðàòîð çà ïðîâåðêà íà ðàâåíñòâî. Òàêà ïðîãðàìèñòúò ìîæå ñëó÷àéíî äà ïðîìåíè ñòîéíîñòòà íà bufSize íà 1, êîåòî ùå ñå ïðåâúðíå â òðóäíà çà îòêðèâàíå ïðîãðàìíà ãðåøêà. (×åñòî òàêàâà ãðåøêà å òðóäíà çà îòêðèâàíå, çàùîòî ïðîãðàìèñòúò íå ìîæå äà ÿ “âèäè” â ïðîãðàìàòà - çàòîâà ìíîãî êîìïèëàòîðè ïðàâÿò ïðåäóïðåæäåíèå çà òîçè òèï ïðèñâîÿâàíå). Ìîäèôèêàòîðúò íà òèï const äàâà åäíî ðåøåíèå íà ïðîáëåìà. Òîé ïðåîáðàçóâà ïðîìåíëèâàòà â êîíñòàíòà. Íàïðèìåð,

const int bufSize = 512; // input buffer size

äåôèíèðà bufSize êàòî êîíñòàíòà, èíèöèàëèçèðàíà ñúñ ñòîéíîñò 512. Âñåêè îïèò çà ïðîìåíÿíå íà òàçè ñòîéíîñò íÿêúäå âúòðå â ïðîãðàìàòà ùå ïðè÷èíè ïîÿâàòà íà ãðåøêà ïî âðåìå íà êîìïèëàöèÿ. Èìåíóâàíàòà êîíñòàíòà ìîæå äà ñå íàðå÷å ïðîìåíëèâà ñàìî çà ÷åòåíå.

Ïîíåæå èìåíóâàíàòà êîíñòàíòà íå ìîæå äà áúäå ïðîìåíÿíà ñëåä êàòî å áèëà äåôèíèðàíà, òÿ òðÿáâà äà áúäå èíèöèàëèçèðàíà. Äåôèíèöèÿòà íà íåèíèöèàëèçèðàíà èìåíóâàíà êîíñòàíòà ùå ïðåäèçâèêà ãðåøêà ïî âðåìå íà êîìïèëàöèÿ. Íàïðèìåð,

const double PI; // error: uninitialized const

Ãðåøêà îò êîìïèëàöèÿ ñå ïîÿâÿâà è êîãàòî àäðåñ íà èìåíóâàíà êîíñòàíòà ñå ïðèñâîÿâà íà óêàçàòåë. Èíà÷å, ñòîéíîñòòà íà êîíñòàíòàòà áè ìîãëà äà áúäå ïðîìåíåíà ÷ðåç óêàçàòåëÿ. Íàïðèìåð,

const double minWage = 3.60;
double *p = &minWage; // error
*p += 1.40;

Ïðîãðàìèñòúò, îáà÷å, ìîæå äà äåêëàðèðà óêàçàòåë, êîéòî äà àäðåñèðà êîíñòàíòà. Íàïðèìåð,

const double *pc;

pc å óêàçàòåë êúì êîíñòàíòåí îáåêò îò òèï double. pc, ñàì ïî ñåáå ñè, îáà÷å, íå å êîíñòàíòà. Òîâà îçíà÷àâà ñëåäíîòî:

1. pc ìîæå äà áúäå ïðîìåíÿí äà àäðåñèðà äðóãà ïðîìåíëèâà îò òèï double ïî âñÿêî âðåìå âúòðå â ïðîãðàìàòà.
2. Ñòîéíîñòòà íà îáåêòà, àäðåñèðàí ÷ðåç pc, íå ìîæå äà áúäå ïðîìåíÿíà êàòî ñå èçïîëçóâà pc. Íàïðèìåð,

pc = &minWage; // ok
double d;
pc = &d; // ok
d = 3.14159; // ok
*pc = 3.14159; // error

Àäðåñúò íà èìåíóâàíà êîíñòàíòà ñúùî ìîæå äà áúäå ïðèñâîÿâàí íà óêàçàòåë êúì êîíñòàíòà, òàêúâ êàòî pc. Óêàçàòåë êúì êîíñòàíòà, îáà÷å, ìîæå ñúùî äà àäðåñèðà è îáèêíîâåíà ïðîìåíëèâà, êàêòî íàïðèìåð

pc = &d;

Âúïðåêè ÷å d íå å êîíñòàíòà, ïðîãðàìèñòúò å óáåäåí, ÷å ñòîéíîñòòà é íÿìà äà áúäå ïðîìåíÿíà ÷ðåç pc. Óêàçàòåëè êúì êîíñòàíòíè îáåêòè íàé-÷åñòî ñå äåôèíèðàò êàòî ôîðìàëíè ïàðàìåòðè íà ôóíêöèè. Ðàçäåë 4.6 ðàçãðåæäà èçïîëçóâàíåòî íà óêàçàòåëè êúì êîíñòàíòè. Ïðîãðàìèñòúò ìîæå ñúùî äà äåôèíèðà óêàçàòåë-êîíñòàíòà. Íàïðèìåð,

int errNumb; // possible error status of program
int *const curErr = &errNumb; // constant pointer
curErr êîíñòàíòåí óêàçàòåë êúì îáåêò îò òèï int. Ïðîãðàìèñòúò ìîæå äà ïðîìåíÿ ñòîéíîñòòà íà îáåêòà íà àäðåñ curErr:
if ( *curErr ){
errorHandler();
*curErr = 0;
}

íî íå ìîæå äà ïðîìåíÿ àäðåñà, êîéòî curErr ñúäúðæà:

curErr = &myErrNumb; // error

Ìîæå äà áúäå äåôèíèðàí è óêàçàòåë - êîíñòàíòà êúì êîíñòàíòåí îáåêò:

const int pass = 1;
const int *const true = &pass;

 òîçè ñëó÷àé íå ìîãàò äà áúäàò ïðîìåíÿíè, êàêòî ñòîéíîñòòà íà àäðåñèðàíèÿ ÷ðåç true îáåêò, òàêà è ñàìèÿ àäðåñ.

Óïðàæíåíèå 1-7. Îáÿñíåòå çíà÷åíèåòî íà ñëåäíèòå ïåò äåôèíèöèè. Îïðåäåëåòå êîè îò òÿõ ñà ïðàâèëíè.

(a) int i; (d) int *const cpi;
(b) const int ic; (e) const int *const cpic;
(c) const int *pic;

Óïðàæíåíèå 1-8. Êîè îò ñëåäíèòå èíèöèàëèçàöèè ñà êîðåêòíè? Îáÿñíåòå çàùî.

(a) int i = ‘a’;
(b) const int ic = i;
(c) const int *pic = &ic;
(d) int *const cpi = &ic;
(e) const int *const cpic = &ic;

Óïðàæíåíèå 1-9. Êàòî èìàòå ïðåäâèä äåôèíèöèèòå â ïðåäèøíèòå óïðàæíåíèÿ, êàæåòå êîè îò ñëåäíèòå îïåðàòîðè çà ïðèñâîÿâàíå ñà êîðåêòíè? Îáÿñíåòå çàùî.

(a) i = ic; (d) pic = cpic;
(b) pic = &ic; (e) cpic = &ic;
(c) cpi = pic; (f) ic = *cpic;


2.6. Èçáðîèìè òèïîâå

Âñåêè èçáðîèì òèï ïðåäñòàâÿ ìíîæåñòâî îò èìåíóâàíè íåäåëèìè êîíñòàíòè. Åëåìåíòèòå íà òàêúâ òèï ñå ðàçëè÷àâàò îò åêâèâàëåíòíèòå ñè êîíñòàíòíè äåêëàðàöèè ïî òîâà, ÷å çà òÿõ íå ñå ïîääúðæà äîñòúï ïî àäðåñ. Êàòî ãðåøêà ñå èíòåðïðåòåðà âñåêè îïèò çà äîñòúï äî åëåìåíò îò èçáðîèì òèï ïî àäðåñ.

Åäèí èçáðîèì òèï ìîæå äà áúäå äåêëàðèðàí êàòî ñå èçïîëçóâà êëþ÷îâàòà äóìà enum è ñïèñúê îò ðàçäåëåíè ñúñ çàïåòàÿ èäåíòèôèêàòîðè, çàòâîðåí âúâ ôèãóðíè ñêîáè. Ïî ïîäðàçáèðàíå íà ïúðâèÿ èäåíòèôèêàòîð ñå ïðèñâîÿâà ñòîéíîñò 0. Íà âñåêè ñëåäâàù èäåíòèôêàòîð ñå ïðèñâîÿâà ñòîéíîñò ñ åäíî ïî-ãîëÿìà îò òàçè íà ïðåäõîæäàùèÿ ãî. Íàïðèìåð, ñëåäíèòå äåêëàðàöèè ñâúðçâàò FALSE ñ 0, à TRUE - ñ 1.

enum { FALSE, TRUE }; // FALSE == 0, TRUE == 1

Äàäåíà ñòîéíîñò ìîæå ÿâíî äà áúäå ïðèñâîåíà íà åëåìåíò îò èçáðîèì òèï. Íå å íåîáõîäèìî òàçè ñòîéíîñò äà áúäå óíèêàëíà. Êàêòî è ïðåäè, êîãàòî íå áåøå äàäåíî ÿâíî ïðèñâîÿâàíåòî, ñòîéíîñòòà, ñâúðçâàíà ñ äàäåí åëåìåíò, å ñ åäíî ïî-ãîëÿìà îò òàçè íà ïðåäõîæäàùèÿ ãî åëåìåíò. Â ñëåäâàùèÿ ïðèìåð FALSE è FALL ñå ñâúðçâàò ñúñ ñòîéíîñòòà 0, à PASS è TRUE - ñ 1:

enum { FALSE, FALL = 0, PASS, TRUE = 1 };

Íà âñåêè èçáðîèì òèï ìîæå äà áúäå äàäåíî èìå. Âñåêè èìåíóâàí èç-áðîèì òèï äåôèíèðà óíèêàëåí òèï, êîéòî ìîæå äà áúäå èçïîëçóâàí êàòî ñïåöèôèêàòîð íà òèï çà äåêëàðèðàíå íà èäåíòèôèêàòîðè. Íàïðèìåð,

enum TestStatus { NOT_RUN = -1, FALL, PASS };
enum Boolean { FALSE, TRUE };
main() {
const testSize = 100;
TestStatus testSuite [ testSize ];
Boolean found = FALSE;
for ( int i = 0; i < testSize; ++i )
testSuite [ i ] = NOT_RUN;
}

Èìåíóâàíèÿò èçáðîèì òèï íå áåøå äåôèíèðàí âúâ âåðñèèòå íà åçèêà Ñ++, ïðåäè 2.0. Ñëåäîâàòåëíî çà îñèãóðÿâàíå íà ñúâìåñòèìîñò, íàðóøàâàíåòî íà òèïîâåòå ïðè èíèöèàëèçàöèÿ è ïðèñâîÿâàíå íà ñòîéíîñò íà èäåíòèôèêàòîð îò èçáðîèì òèï íå ñå îòáåëÿçâà êàòî ãðåøêà â íàñòîÿùàòà ðåàëèçàöèÿ íà åçèêà îò AT&T. Îáà÷å ñå èçäàâàò ïðåäóïðåæäåíèÿ, è òå íå òðÿáâà äà áúäàò èãíîðèðàíè. Íàïðèìåð,

main() {
TestStatus test = NOT_RUN;
Boolean found = FALSE;
test = -1; // error: TestStatus = int
test = 10; // error: TestStatus = int
test = found; // error: TestStatus = Boolean
test = FALSE; // error: TestStatus = const Boolean
int st = test; // ok: implicit conversion
}

Êàòî äåêëàðèðà ïðîìåíëèâàòà test îò èçáðîèìèÿ òèï TestStatus, ïðîãðàìèñòúò óêàçâà íà êîìïèëàòîðà äà ïðîâåðÿâà, äàëè íà test ñå ïðèñâîÿâà åäíà îò òðèòå âàëèäíè ñòîéíîñòè. È íàêðàÿ, èçïîëçóâàíåòî íà èìåíóâàí èçáðîèì òèï ïðåäëàãà åäíà óäîáíà ôîðìà çà äîêóìåíòèðàíå íà ïðîãðàìàòà.

2.7. Òèï ìàñèâ

Ìàñèâúò å ñúâêóïíîñò îò åëåìåíòè îò åäèí è ñúù äàííîâ òèï. Ñàìèòå îáåêòè íå ñà èìåíóâàíè, à ïî-ñêîðî ñà äîñòúïíè ÷ðåç èçïîëçóâàíåòî íà ìåñòîïîëîæåíèåòî èì â ìàñèâà. Òîçè ìåòîä íà äîñòúï ñå íàðè÷à îáèêíîâåíî èíäåêñåí èëè àáîíàòåí.

Íàïðèìåð,

int i;

äåêëàðèðà åäèíè÷åí îáåêò îò öÿë òèï, äîêàòî

int ia[ 10 ];

äåêëàðèðà ìàñèâ îò 10 òàêèâà îáåêòà. Âñåêè îáåêò ñå íàðè÷à åëåìåíò íà ìàñèâà ia. Òàêà

i = ia[ 7 ];

ïðèñâîÿâà íà i ñòîéíîñòòà íà åëåìåíòà ñ èíäåêñ 7. Ñúîòâåòíî, ia[ 7 ] = i;

ïðèñâîÿâà íà åëåìåíòà ñ èíäåêñ 7 ñòîéíîñòòà íà i.

Âñÿêà äåôèíèöèÿ íà ìàñèâ ñå ñúñòîè îò ñïåöèôèêàòîð íà òèï, èäåíòèôèêàòîð è ðàçìåðíîñò. Ðàçìåðíîñòòà, êîÿòî îïðåäåëÿ áðîÿ íàåëåìåíòèòå íà ìàñèâà, ñå çàòâàðÿ â ñêîáè îò âèäà “[ ]”. Ìàñèâúò ìîæå äà èìà ðàçìåðíîñò ïî-ãîëÿìà èëè ðàâíà íà åäèíèöà. Ñòîéíîñòòà, çàäàâàùà ðàçìåðíîñòòà, òðÿáâà äà áúäå êîíñòàíòåí èçðàç; ò.å. íåîáõîäèìî å òàçè ñòîéíîñò äà ìîæå äà áúäå èç÷èñëåíà ïî âðåìå íà êîìïèëàöèÿ. Òîâà îçíà÷àâà, ÷å íå ìîæå äà ñå èçïîëçóâà ïðîìåíëèâà çà çàäàâàíå íà ðàçìåðíîñò íà ìàñèâ. Ñëåäâàò íÿêîëêî ïðèìåðà çà êîðåêòíè äåôèíèöèè íà ìàñèâè:

const bufSize = 512,
stackSize = 25, maxFiles = 20, staffSize = 27;
char inputBuffer [ bufSize ];
int tokenStack [ stackSize ];
char *fileTable [ maxFiles - 3 ];
double salaries [ staffSize ];

Çàáåëåæåòå, ÷å åëåìåíòèòå íà åäèí ìàñèâ ñå íîìåðèðàò, êàòî ñå çàïî÷âà îò 0. Çà ìàñèâ îò 10 åëåìåíòà ïðàâèëíèòå èíäåêñíè ñòîéíîñòè ñà îò 0 äî 9, à íå îò 1 äî 10. Òîâà ÷åñòî ñå ÿâÿâà ïðè÷èíà çà ïðîãðàìíè ãðåøêè. Íàïðèìåð, ñëåäíèÿò öèêúë for ïðåãëåæäà äåñåòòå åëåìåíòà íà åäèí ìàñèâ, êàòî âñåêè îò òÿõ ñå èíèöèàëèçèðà ñúñ ñòîéíîñòòà íà èíäåêñà ñè:

const SIZE = 10;
int ia[ SIZE ];
main () {
for ( int i = 0; i < SIZE; ++i )
ia[ i ] = i;
}

Äàäåí ìàñèâ ìîæå äà áúäå äà áúäå èíèöèàëèçèðàí ÿâíî êàòî ñå èçïîëçóâà çàòâîðåí â ñêîáè ñïèñúê îò ñòîéíîñòè, ðàçäåëåíè ñúñ çàïåòàè.( Òàêàâà èíèöèàëèçàöèÿ å âúçìîæíà ñàìî çà ìàñèâè, äåôèíèðàíè âúí îò ôóíêöèè. Ðàçëèêàòà ìåæäó äåôèíèöèèòå âúòðå è âúí îò ôóíêöèè ñå îáñúæäà â ãëàâà 3). Íàïðèìåð,

const SZ = 3;
int ia[] = { 0, 1, 2 };

Çà ÿâíî èíèöèàëèçèðàíèÿ ìàñèâ íå å íåîáõîäèìî äà ñå çàäàâà ðàçìåðíîñò. Êîìïèëàòîðúò ùå îïðäåëè ðàçìåðà íà ìàñèâà ïî áðîÿ íà çàïèñàíèòå åëåìåíòè:

int ia[] = { 0, 1, 2 }; // an array of dimension 3

Àêî ðàçìåðíîñòòà å îïðåäåëåíà, áðîÿò íà çàäàäåíèòå åëåìåíòè íå òðÿáâà äà íàäõâúðëÿ òîçè ðàçìåð.  ïðîòèâåí ñëó÷àé ùå ñå ïîÿâè ãðåøêà ïî âðåìå íà êîìïèëàöèÿ. Àêî ðàçìåðíîñòòà å ïî-ãîëÿìà îò áðîÿ íà çàäàäåíèòå åëåìåíòè, òî åëåìåíòèòå íà ìàñèâà, êîèòî íå ñà èíèöèàëèçèðàíè ÿâíî ùå ïîëó÷àò ñòîéíîñò 0.

const SZ = 5;
int ia[ SZ ] = { 0, 1, 2 }; // ia ==> { 0, 1, 2, 0, 0 }

Ìàñèâ îò ñèìâîëè ìîæå äà áúäå èíèöèàëèçèðàí èëè ÷ðåç çàòâîðåí âúâ ñêîáè ñïèñúê îò ðàçäåëåíè ñúñ çàïèòàÿ åëåìåíòè èëè ÷ðåç íèçîâà êîíñòàíòà. Çàáåëåæåòå îáà÷å, ÷å äâàòà íà÷èíà çà èíèöèàëèçàöèÿ íå äàâàò åäíàêúâ ðåçóëòàò. Íèçîâàòà êîíñòàíòà ñúäúðæà äîïúëíèòåëåí íóëåâ ñèìâîë â êðàÿ ñè. Íàïðèìåð,

char ca1[] = { ‘C’, ‘+’, ‘+’ };
char ca2[] = "C++";
ca1 èìà ðàçìåðíîñò 3, à ca2 èìà ðàçìåðíîñò 4. Ñëåäíèòå äåêëàðàöèè ùå áúäàò îòáåëÿçàíè êàòî ãðåøíè:
char ch3[6] = "Pascal";// error: "Pascal" is 7 elements

Íå å ðàçðåøåíî ìàñèâ äà áúäå èíèöèàëèçèðàí êàòî ñå èçïîëçóâà äðóã ìàñèâ, íèòî ïúê äàäåí ìàñèâ äà áúäå ïðèñâîÿâàí íà äðóã.

const int SZ = 3;
int ia[ SZ ] = { 0, 1, 2 };
int ia2[] = ia; // error
int ia3[ SZ ];
ia3 = ia; // error

Çà äà áúäå êîïèðàí åäèí ìàñèâ â äðóã ïîñëåäîâàòåëíî òðÿáâà äà áúäàò êîïèðàíè âñè÷êèòå ìó åëåìåíòè. Òàçè îïåðàöèÿ å äîñòàòú÷íî îáùà çà äà áúäå îðãàíèçèðàíà â îòäåëíà ôóíêöèÿ; íåêà ÿ íàðå÷åì copyArray().

copyArray() èçèñêâà äâà ìàñèâà, åäèíèÿò çà äà ïîëó÷è

ñòîéíîñòèòå, êîèòî ùå áúäàò êîïèðàíè, à äðóãèÿò äà ñúäúðæà òåçè ñòîéíîñòè. Ùå ãè íàðå÷åì ñúîòâåòíî íàçíà÷åíèå è èçòî÷íèê. Òîâà ùå áúäàò àðãóìåíòèòå íà òàçè ôóíêöèÿ.

Òðÿáâà äà ñå îòáåëåæè, ÷å ùå ñà íåîáõîäèìè ðàçëè÷íè ôóíêöèè çà âñåêè ðàçëè÷åí òèï ìàñèâ, êîéòî íèå æåëàåì äà êîïèðàìå, êàòî ìàñèâ îò öåëè èëè ðåàëíè ÷èñëà, íàïðèìåð, äîðè è àêî èñòèíñêèÿò êîä íà Ñ++, ðåàëèçèðàù òîâà å åäèí è ñúù. Çà öåëèòå íà íàøèÿ ïðèìåð íèå ùå äåôèíèðàìå ôóíêöèÿòà copyArraay() çà öåëè ÷èñëà. Ïúðâîíà÷àëíîòî çàãëàâèå íà íàøàòà ôóíêöèÿ ùå èìà âèäà:

void copyArray( int torget[], int source[] );

Êîãàòî äàäåí ìàñèâ ñå èçïðàùà êàòî ïàðàìåòúð íà ôóíêöèÿ, òîé ñå ïðåîáðàçóâà â óêàçàòåë êúì íóëåâèÿ ñè åëåìåíò; èíôîðìàöèÿòà çà ðàçìåðíîñòòà ñå çàãóáâà. Ôóíêöèÿòà, êúì êîÿòî ñå èçïðàùà ìàñèâ òðÿáâà íÿêàê äà óñòàíîâè ðàçìåðíîñòòà ìó. Åäèí âúçìîæåí íà÷èí äà ñå íàïðàâè òîâà å äà ñå äîáàâè âòîðè àðãóìåíò, ñúäúðæàù ðàçìåðà íà ìàñèâà. copyArray() ñå ðåàëèçèðà òàêà:

Ñ âúâåæäàíåòî íà ïàðàìåòðèçèðàí òèï òîâà îãðàíè÷åíèå ùå áúäå îòñòðàíåíî. Âæ. Ïðèëîæåíèå  çà ïîÿñíåíèÿ.

void copyArray( int target[], int source[],
int targetSize, int sourceSize ) {

/* copy source to target
set additional target elements to 0 */
ind upperBound = targetSize;
if ( targetSize > sourceSize )
upperBound = sourceSize;
for ( int i = 0; i < upperBound; ++i )
target[ i ] = source[ i ];
while ( i < targetSize )
target[ i++ ] = 0;
}

Çà èíäåêñ íà ìàñèâ ìîæå äà áúäå èçïîëçóâàí âñåêè èçðàç, êîéòî âðúùà öÿëî ÷èñëî. Åçèêúò, îáà÷å, íå ïðåäëàãà ïîääúðæàíå íà ïðîâåðêà íà èíäåêñà ïî âðåìå íà êîìïèëàöèÿ è èçïúëíåíèå. Íèùî íÿìà äà ïîïðå÷è íà ïðîãðàìèñòà äà íàäõâúðëè ãðàíèöàòà íà ìàñèâà, îñâåí âíèìàòåëíèÿò ïðåãëåä íà âñè÷êè äåòàèëè è òåñòâàíåòî íà ïðîãðàìàòà. Íå å íåâúçìîæíî åäíà ïðîãðàìà äà áúäå êîìïèëèðàíà è èçïúëíåíà äàæå è ïðè íàëè÷èåòî íà ãðåøêè.

Óïðàæíåíèå 1-10. Êîè îò ñëåäíèòå äåôèíèöèè íà ìàñèâè ñà ïðàâèëíè? Îáÿñíåòå çàùî.

int getSize();
int bufSize = 1024;

(a) int ia[ bufSize ]; (c) int ia[ 4 * 7 - 14 ];
(b) int ia[ getSize() ]; (d) int ia[ 2 * 7 - 14 ];

Óïðàæíåíèå 1-11. Çàùî ñëåäíàòà èíèöèàëèçàöÿ å ãðåøíà?

char st[ 11 ] = "fundamental";

Óïðàæíåíèå 1-12. Â ñëåäâàùèÿ êîäîâ ôðàãìåíò èìà äâå ãðåøêè, ñâúðçàíè ñ èíäåêñèðàíåòî íà ìàñèâà ia. Íàìåðåòå ãè.

main() {
const max = 10;
int ia[ max ];
for ( int index = 1; index <= max; ++index )
ia[ index ] = index;
// ...
}

Ñòðàíèöè: «2 3 4 5 6 7 8 »