Почетнички водич

  • Креатор на темата Креатор на темата back_rest
  • Време на започнување Време на започнување
Програмски јазик C++

Низи (Arrays)​

Во многу проблеми, структурите на податоци имаат многу компоненти кои е тешко да се процесираат, ако секоја од компонентите има различно име. Ние ќе разгледуваме типови на податоци – низи.

Еднодимензионални низи

Ако сакаме да внесеме 1000 целобројни вредности кои сакаме да ги печатиме во обратен редослед од редоследот на внесувањето, можеме да ја напишеме следнава програма:
Код: 
#include <iostream>
  using namespace std;
   
  int main( )
  {
              int br0;
              int br1;
              int br2;
              .
              .
              int br999;
   
              cin >> br0;
              cin >> br1;
              cin >> br2;
              .
              .           
              cin >> br999;
   
              cout << br999 << endl;
              cout << br998 << endl;
              cout << br997 << endl;
              .
              .
              cout << br0 << endl;
              return 0;
  }
Оваа програма има преку 3000 линии (1000 за декларации + 1000 за внос + 1000 за излез) и во него се користат 1000 променливи. Очигледно е дека имињата на променливите се слични и тие се од ист тип. Би било практично ако ставиме број во променлива-бројач и користиме For циклуси кои одат од 0 до 999 и потоа од 999 назад до 0. На пример, ако името на бројачот е number, можеме да замениме горните 2000 I/O инструкции со следните 4 линии од код:
Код: 
  for (number = 0; number < 1000; number++)
              cin >> value[number];
  for (number = 999; number >= 0; number--)
              cout << value[number] << endl;
Овие четири линии од код се коректни во C++, ако гo декларираме value да биде еднодимензионална низа која е множество од променливи од ист тип, при што првиот дел од името на променливата е ист, по што следува индекс затворен во средни загради. Декларацијата на еднодимензионална низа е слична со декларацијата на проста променлива, со еден исклучок: мора да се декларира должината на низата. За горниот пример:
int value[1000];
Оваа декларација креира низа од 1000 компоненти, сите од тип int. Првата компонента има вредност на индексот 0, втората компонента 1 и така натаму сè до последната компонента која има индексна вредност 999.

Следува комплетниот код на ReverseNumbers програмата кој користи низа.
Код: 
 #include <iostream>
  using namespace std;
   
  int main( )
  {
              int value[1000];
              int number;
   
              for (number = 0; number < 1000; number++)
                          cin >> value[number];
              for (number = 999; number >= 0; number--)
                          cout >> value[number] << endl;
              return 0;
  }
Како структура на податоци, низата се разликува од struct во две суштински карактеристики:

  • низата е хомогена структура на податоци (сите компоненти се од ист тип на податоци), додека struct е хетерогена структура (нејзините компоненти може да бидат од различни типови на податоци);
  • на компонента на низата се пристапува преку позицијата на компонентата во низата, додека на компонента во struct се пристапува со dot нотација преку името на членот.

Декларирање на низи

Еднодимензионална низа е структуирано множество од компоненти (елементи на низата) на кои може да им се пристапи индивидуално со специфицирање на позицијата на компонентата преку индексот. Синтактичкиот шаблон за декларирање на еднодимензионална низа е:
Тип на податок- Име на низа [ConstIntIzraz]
Компонентите на низата може да бидат од каков било тип на податок, но овде ние разгледуваме само компоненти од прости типови на податоци. ConstIntIzraz е целоброен (интегер) израз составен само од литерали или именувани константи. Тој мора да има вредност поголема од 0. Ако вредноста на ConstIntIzraz е n рангот на вредности на индексот е 0 до n-1, а не од 1 до n. На пример, декларациите:
Код: 
 float angle[4]; 
  int testScore[10];
Низата angle има четири компоненти, секоја од нив со можност да чува една float вредност. Низата testScore има вкупно десет компоненти, сите од тип int.

Пристап на индивидуални компоненти


За да пристапиме на компонента од низа, го пишуваме името на низата по кое следи израз во средни загради. Вредноста на изразот специфицира на која компонента сакаме да [FONT=&quot]&[/FONT] пристапиме. Синтактичкиот шаблон за пристап кон компонента на низа е:
Име на низа [IndexIzraz]
IndexIzraz може да биде константа, променлива, аритметички израз или повик на функција. Изразот мора да резултира со целобројна вредност, инаку настанува имплицитна конверзија (коерција) во интегер. Наједноставна вредност на IndexIzraz е константа. Користејќи ја angle низата, секвенцата на инструкции за доделување:
Код: 
angle[0] = 4.93;
  angle[1] = -15.2;
  angle[2] = 0.5;
  angle[3] = 1.67;
Секоја компонента на низата, на пример angle[2], може да биде третирана на ист начин како која било проста променлива од тип float. На пример:
Код: 
  angle[2] = 9.6;                                     доделување на вредност                    
  cin >> angle[2];                                                вчитување вредност во неа
  cout << angle[2];                                  печатење на нејзината вредност
  y = sqrt(angle[2]);                                аргумент на функција
  x = 6.8 * angle[2] + 7.5;                                  користење во аритметички израз
Да ги погледнеме индексните изрази кои се покомплицирани од константите. Да претпоставиме дека сме декларирале низа од 1000 елементи од int вредности со инструкцијата
int value[1000];
и ги извршуваме следниве две инструкции:
Код: 
  value[counter] = 5;
  if (value[number + 1] % 10 != 0)
.
Во првата инструкција на компонентана низата е доделен бројот 5. Ако counter е 0, бројот 5 е доделен на првата компонента од низата. Ако counter е 1, бројот 5 се доделува на втората компонента од низата итн.
Во втората инструкција, изразот number + 1 селектира компонента од низата. Компонентата на која [FONT=&quot]&[/FONT] е пристапено се дели со 10 и се проверува дали остатокот е ненулти. Ако number + 1 е 0, ја тестираме првата компонента од низата, ако number + 1 е 1 ја тестираме втората компонента итн.
String класата дозволува пристап на индивидуални карактери во стрингот:
Код: 
string aString; 
    aString = “Hello”;
  cout << aString[1];     // Pecati ‘e’
Иако личи на низа, типот на податок string е класа. Користејќи ја C++ техниката operator overloading, на операторот [ ] му дава друго значење – селектирање на компонента на стринг, покрај неговото стандардно значење – селектирање на елемент на низа.

Индекси надвор од границите на низата


Нека е дадена декларацијата
float alpha[100];
Рангот на вредности на индексот е 0 до 99. Ако извршиме инструкција
alpha = 62.4;
кога i е помало од 0 или i е поголемо од 99, тогаш пристапуваме кoн мемориска локација надвор од низата. C++ не проверува дали индексот на низата е во декларираните граници. На пример, ако i = 100 во горната инструкција, компјутерот доделува 62.4 во мемориската локација која следува по крајот на низата и со тоа ја уништува вредноста која била содржана на таа локација.
Индекс на низата надвор од граници е вредност на индексот во C++ кој е или помал од 0 или поголем од должината на низата – 1.
Алгоритмите кои процесираат низи често користат For циклуси за процесирање на елементите еден по еден. Следувa алгоритам кој ги сетира на 0 стоте елементи од низата alpha (i е int променлива):
Код: 
  for (i = 0; i < 100; i++)
              alpha[i] = 0.0;
Иницијализирање на низа во декларација


Видовме дека C++ дозволува иницијализирање на променлива во декларација:
int delta = 25;
Вредноста 25 се нарекува иницијализатор. Исто така, може да се иницијализира низа во декларација, користејќи специјална синтакса за иницијализаторот. Се специфицира листа на иницијални вредности за елементите на низата, елементите се разделуваат со , и листата се затвора во големи загради:
int age[5] = {23, 10, 16, 37, 12};
Во оваа декларација, age[0] се иницијализира на 23, age[1] на 10 итн. Ако во горниот пример се специфицираат повеќе од пет вредности, компајлерот ќе сигнализира синтактичка грешка. Ако се специфицираат помалку од пет вредности, останатите елементи се иницијализираат на 0. Статичка низа (било да е глобална или декларирана како static во блок) се иницијализира само еднаш. Автоматска низа (локална недекларирана како static) се реиницијализира секојпат кога контролата минува низ декларацијата.
Интересна карактеристика на C++ e дека е дозволено да се изостави должината на низата кога таа се иницијализира во декларација:
float temperature[ ] = {0.0, 112.37, 98.6};
Компајлерот ја открива должината според бројот на иницијални вредности во листата.


Агрегатни операции на низи

Во претходната глава дефиниравме агрегатни операции како операции на структури на податоци како целина. C++ не дозволува агрегатни операции на низи. За декларациите:
Код: 
  int x[50];
  int y[50];
не е дозволено агрегатно доделување:
Код: 
x = y;      // Nedozvoleno
Доделувањето се врши компонента по компонента:
Код: 
  for (index = 0; index < 50; index++) 
              x[index] = y[index];
Не е дозволено агрегатно споредување:
Код: 
  if (x == y)          // Nedozvoleno
Ниту извршување на агрегатни I/O на низи:
Код: 
  cout << x;           // Nedozvoleno
Не се дозволени никакви агрегатни аритметички операции:
Код: 
  x = x + y;            // Nedozvoleno
Конечно, не е дозволено да се врати цела низа како вредност од функција која враќа вредност:
Код: 
  return x;           // Nedozvoleno
Единствена агрегатна операција што може да се изврши врз низа е да се предаде низата како аргумент на функција. Тогаш функцијата добива пристап на целата низа.

Примери на декларирање и пристапување на низи


Како прв пример, разгледуваме број на жители во една зграда која има 100 станови.
Код: 
  const int BUILDING_SIZE = 100;       // Broj na stanovi
  int occupants[BUILDING_SIZE];        // occupants[i] e broj na stanari vo stan i-1
  int totalOccupants;                               // Vkupen broj na stanari vo zgradata
  int counter;                                          // brojac na ciklusot i indeksna promenliva
На пример, ако occupants[0] = 3 кажува дека во првиот стан има 3 станари, occupants[1] = 5 кажува дека во вториот стан живеат 5 станари итн. Ако овие вредности се чуваат во низа, тогаш следниот сегмент го пресметува вкупниот број на станари во зградата:
Код: 
  totalOccupants = 0;
  for (counter = 0; counter < BUILDING_SIZE; counter++)
              totalOccupants = totalOccupants + occupants[counter];
Може да се забележи дека интервалот на counter е од 0 до 99, при што се кумулира бројот на станарите од првиот стан (counter = 0) до последниот (стоти) стан (counter = 99).
Најчесто индексот во низата е од тип int. Меѓутоа C++ дозволува користење и на enumeration тип на податок. Следниот пример прикажува низа во која индексите се вредности од enumeration тип.
Код: 
  enum Drink {ORANGE, COLA, BEER, APPLE, CHERRY, LEMON};
  float salesAmt[6];        // Niza od 6 float broevi koja se indeksira so tip Drink
  Drink flavor;                // Promenliva za indeks
Енумераторите ORANGE, COLA,…, LEMON имаат интерна интегер репрезентација од 0 до 5, salesAmt е низа од 6 float вредности кои означуваат цена на секој вид на пијалак. Следниот код ги печати цените кои се содржат во низата.
Код: 
  for (flavor = ORANGE; flavor <= LEMON; flavor = Drink( flavor + 1 ))
              cout << salesAmt[flavor] << endl;
Во последниот пример разгледуваме низа од описни оценки (A, B, C, D, F) на 10 студенти.
Код: 
  const int  NUM_STUDENTS = 10;
  char grade [NUM_STUDENTS];          // Niza od 10 oceni
  int idNumber;
Следуваат неколку примери кои покажуваат како низата може да се користи.

Продолжува...
 
Код: 
  cin >> grade[2];           // Go cita sledniot printabilen karakter i go smestuva vo element od //nizata so indeks 2.
   
  grade[3] = ‘A’;             // Dodeluva karakter ‘A’ na element od nizata so indeks 3.
  IdNumber = 5;             // Dodeluva 5 na indeksnata promenliva idNumber.
  Grade[idNumber] = ‘C’           // Dodeluva karakter ‘C’ na komponenta od nizata indeksirana so // idNumber (vo ovoj slucaj 5)
   
  for (idNumber = 0; idNumber < 10;                 // Za ovoj ciklus izlezot moze da bide
         idNumber++)                                            // FBCAFCAACB
         cout << grade[idNumber];                         
   
  for (idNumber = 0; idNumber < 10;                 // Za ovoj ciklus izlezot e pocitliv
         idNumber++)                                            
         cout << “Student “ << idNumber
    << “ Grade “ << grade[idNumber]
    << endl;
Во последниот пример излезот би бил:
Код: 
  Student 0 Grade F
  Student 1 Grade B
    .
  Student 9 Grade B
Предавање на низи како аргументи


По default (ако не е наведено со &) променливите од прости типови се пренесуваат по вредност. Ако сакаме во функцијата да ја промениме вредноста на променливата, ја пренесуваме по референца (прикачуваме & на типот на податок на променливата во листата на параметри на функцијата).
Низите како аргументи секогаш се пренесуваат по референца и притоа не се користи знакот & за да реферира дека низата се пренесува по референца. Кога низата се пренесува како аргумент, нејзината базна адреса (baseaddress),која е мемориска адреса на првиот елемент од низата, се испраќа на функцијата. Тогаш функцијата „знае“ каде е лоцирана актуелната низа која ја испраќа повикувачот и може да пристапи на секој елемент од низата. Следната е C++ функција која сетира на нула float низа со произволна должина:
Код: 
 Void ZeroOut( /*out*/ float arr[],
                          /*in*/ int numElements)
  {
              int i;
  
              for (i = 0; i < numElements; i++)
                          arr[i] = 0.0;
  }
Во листата на параметри, декларацијата на arr не вклучува должина на низата. Дури и да се вклучи должина, компајлерот ја игнорира. Компајлерот го интересира само дали arr е низа, а не и нејзината должина. За да работи циклусот во функцијата, мора како аргумент да се пренесе уште еден аргумент кој го означува бројот на елементи во низата – numElements. Повикувачкиот код може да ја повика ZeroOut за float низа со која било должина. Следниот код ја повикува функцијата да сетира на 0 две низи со различни должини.
Код: 
  void ZeroOut (float[ ], int);                  // Prototip na funkcijata
    .
  int main( )
  {
              float velocity[30];
              float refractionAngle[9000];
                .
              ZeroOut(velocity, 30);
                ZeroOut(refractionAngle, 9000);          
              .
  }
Со прости променливи, пренесувањето на аргумент по вредност ја штити вредноста на променливата во повикувачот од несакана промена во функцијата. Низите мора да се пренесуваат по референца. За да се заштити низата во повикувачот од несакани промени, во функцијата таа се декларира како константа. На пример, следната функција копира една низа во друга.
Код: 
 void Copy( /*out*/                  int destination[],
                          /*in*/    const   int source[],
                          /*in*/               int size)
  {
              int i;
              for (i = 0; i < size; i++)
                          destination[i] = source[i];
  }
Зборот const гарантира дека кој било обид да се промени содржината на source низата ќе резултира со грешка при компилација.

Низи од слогови


Како пример, да дефинираме книга за оценки, која претставува множество од слогови (записи) на студенти како што следува:
Код: 
  const int MAX_STUDENTS = 150;
  enum GradeType {A, B, C, D, F};
  struct StudentRec
  {
              string    stuName;
              float     gpa;
              int        examScore[4];
              GradeType courseGrade;
  };
  StudentRec gradeBook[MAX_STUDENTS];
Елемент од gradeBook е селектиран со индекс. На пример, gradeBook[2] е третата компонента од низата gradeBook. Секоја компонента од gradeBook е слог (struct) од тип StudentRec. За да пристапиме на courseGrade на третиот студент го користиме следниов израз:
GradeBook[2].courseGrade
Компонентата на слогот gradeBook[2].examScore е низа. За да пристапиме на првата компонента од низата, пишуваме:
GradeBook[2].examScore[0]
Следниот код ги печати имињата на секој студент:
Код: 
  for (count = 0; count < MAX_STUDENTS; count++)
              cout << gradeBook[count].stuName << endl;
Дводимензионални низи


Дводимензионалните низи се користат за претставување елементи во табели со редови и колони. На компонента во дводимензионалните низи може да се пристапи со специфицирање на индексите на редот и на колоната во кои се наоѓа елементот.
Дводимензионална низа е множество од компоненти, сите од ист тип структуирани во две димензии. На секоја компонента & се пристапува со пар на индекси кои ја претставуваат локацијата на елементот.
Синтактичкиот шаблон за декларирање на дводимензионална низа е:

Тип на податок Име на низа [ConstIntExpression] [ConstIntExpression]

На пример:
Код: 
  const int NUM_ROWS = 100;
  const int NUM_COLS = 9;
    .
  float alpha [NUM_ROWS] [NUM_COLS];
Овој пример ја декларира alpha како дводимензионална низа (матрица) на која сите компоненти се од тип float. Инструкцијата
alpha[0] [5] = 36.4;
доделува вредност 36.4 на елементот во ред 0 и колона 5.
Да погледнеме неколку примери.
int hiTemp [52] [7];
е декларација за матрица со 52 реда и 7 колони. Нека редовите ги претставуваат неделите во годината, а колоните деновите во неделата. Во секое поле од матрицата се чува највисоката температура во соодветниот ден. Ако сакаме да ги печатиме највисоките температури во деновите од третата недела од годината, тоа го постигнуваме со следниов код:
Код: 
  int hiTemp [52] [7];
  int day;
  for (day = 0; day < 7; day++)
              cout << ‘ ‘ << hiTemp[2] [day];
Како следен пример разгледуваме матрица чии индекси се енумератори.

Код: 
 enum Colors {RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, VIOLET};
  enum Makes {FORD, TOYOTA, HYUNDAI, JAGUAR, CITROEN, BMW, FIAT, SAAB};
  const int NUM_COLORS = 7;
  const int NUM_MAKES = 8;
  float crashRating[NUM_COLORS] [NUM_MAKES];  //Verojatnost na sudir vo funkcija od
  .                                                                                 //boja i model


  crashRating [BLUE] [JAGUAR] = 0.83;
  crashRating [RED] [FORD] = 0.19;
Процесирање на дводимензионални низи

Процесирање или пристапување на податоци во матрица може да се врши на еден од следниве четири начина:
-случаен (random) пристап;
-пристап по редови;
-пристап по колони;
-пристап по цела матрица.
Случаен пристап имаме кога пристапуваме на случаен елемент од матрицата со давање произволни вредности на индексите. Разгледуваме четири примери на процесирање на матрица:

* сумирање на редови;
* сумирање на колони;
* иницијализација на матрицата со нули;
* печатење на матрица.

Пред да ги разгледаме овие програмски сегменти, декларираме некои заеднички константи
и променливи:

Код: 
  const int NUM_ROWS = 50;
  const int NUM_COLS = 50;
  
  int arr[NUM_ROWS] [NUM_COLS];    // Dvodimenzionalna niza
  int row;                                                // indeks za red
  int col;                                                 // indeks za kolona
  int total;                                               // promenliva za sumata
Сумирање редови


Ако сакаме да направиме сума од елементите во четвртиот ред од матрицата, тоа го правиме со следниот сегмент:
Код: 
  total = 0;
  for (col = 0; col < NUM_COLS; col++)
              total = total + arr[3] [col];
  cout << “Row sum “ << total << endl;
Ако сакаме да направиме суми за два реда, третиот и четвртиот, тоа го правиме со вгнезден циклус:
Код: 
 for (row = 2; row < 4; row++)
  {
              total = 0;
              for (col = 0; col < NUM_COLS; col++)
                          total = total + arr[row] [col];
              cout << “Row sum: “ << total << endl;
  }
На ваков начин може да се сумираат сите редови од матрицата.
Ако сакаме да сумираме елементи во редови од блок матрица со димензии (rowsFilled, colsFilled), тоа го изведуваме на следниов начин:

Код: 
 for (row = 0; row < rowsFilled; row++)
  {
              total = 0;
              for (col = 0; col < colsFilled; col++)
                          total = total + arr[row] [col];
              cout << “Row sum: “ << total << endl;
  }
Сумирање на колони


Ако сакаме да ги сумираме колоните од една блок матрица со димензии (rowsFilled, colsFilled), тоа го вршиме на следниов начин:
Код: 
  for (col = 0; col < colsFilled; col++)
  {
              total = 0;
              for(row = 0; row < rowsFilled; row++)
                          total = total + arr[row] [col];
              cout << “Column sum: “ << total << endl;
  }
Во овој случај, обратно од претходниот, надворешниот циклус ги контролира колоните, а внатрешниот редовите.

Иницијализирање на матрица


Ако матрицата е со мали димензии, наједноставно е таа да се иницијализира во декларацијата. За да иницијализираме матрица од два реда и три колони да изгледа вака:
14 3 -5
0 46 7
можеме да ја користиме следнава декларација:
Код: 
  int arr[2] [3] =
  {
              {14, 3, -5},
              {0, 46, 7}
  }
Во оваа декларација иницијализаторската листа се состои од два елемента, од кои секој е иницијализаторска листа. Првата внатрешна иницијализаторска листа го иницијализира првиот ред, а втората листа го иницијализира вториот ред.
Ако матрицате е голема, непрактично е да се иницијализира во декларација. На пример, ако матрицата е 100 реда со 100 колони, и вредностите се различни, најзгодно е да се внесат во датотека од каде ќе се отчитуваат во run-time. Ако вредностите се исти, вообичаен пристап е да се користи вгнезден циклус. Ако сакаме да ги сетираме на 0 сите елементи од (NUM_ROWS, NUM_COLS) матрица, постапуваме на следниов начин:
Код: 
  for (row = 0; row < NUM_ROWS; row++)
              for (col = 0; col < NUM_COLS; col++)  
                          arr[row] [col] = 0;
Печатење на матрица


Ако сакаме да отпечатиме матрица по еден ред во линија имаме:
Код: 
  #include <iomanip>     // Za setw( )
    .
  for (row = 0; row < NUM_ROWS; row++)
  {
              for (col = 0; col < NUM_COLS; col++)
                          cout << setw(15) << arr[row] [col];
              cout << endl;
  }
Пренесување на матрица како аргумент


Кога дводимензионална низа (матрица) се пренесува како аргумент, повторно базната адреса на матрицата на повикувачот се испраќа на функцијата, но не може да не се наведе должината на двете димензии. Може да не се наведе должината на првата димензија (број на редови), но мора да се наведе должината на втората димензија (број на колони). Ова е така, затоа што матрицата во меморијата се чува во еднодимензионална низа. На пример, ако имаме матрица beta за да го лоцира beta[1] [0], функцијата мора да го знае бројот на колони. Така ако бројот на колони е 4, beta[1] [0] ќе дојде на на петтата локација сметајќи ја базната адреса како прва локација. Значи во декларацијата на параметарот за матрица, секогаш треба да биде наведена втората димензија. На пример:
Код: 
  void AnotherFunc (/* inout */ int beta[ ] [4])
  {
                  .
  }
Понатаму, бројот на колони на матрицата која повикувачот ја праќа на функцијата, мора да биде еднаков со бројот на колони на параметарот во функцијата.
За да се избегнат проблемите со несогласување на должините на аргументите и параметрите, се користи инструкцијата typedef, која дефинира тип дводимензионална низа и потоа да ги декларира и аргументот и параметарот да бидат од тој тип.
На пример:
Код: 
  const int NUM_ROWS = 10;
  const int NUM_COLS = 20;
  typedef int ArrayType[NUM_ROWS] [NUM_COLS];
typedef инструкцијата наложува каде да се појави податокот ArrayType да биде заменет со int.
Следната функција доделува иницијална вредност на сите елементи од матрица со број на колони еднаков со NUM_COLS.
Код: 
  void Initialize (/*out*/ArrayType arr,              // Matrica koja treba da se inicijalizira
                          /*in*/ int initVal)                     // Inicijalna vrednost
  {
              int row;
              int col;
  
              for (row = 0; row < NUM_ROWS; row++)
              {
                          for (col = 0; col < NUM_COLS; row++)
                                      arr[row] [col] = initVal;
  }
 
Јас имам книга за Ц++ и за Паскал...Сеа со кој програмски јазик да почнам????А сакам и да научам нешто напредно во ХТМЛ зошто имам прочитано две-три книги за почетници.Ако има некој книга за ХТМЛ но да не е за почетници.
 
Некој има асален Turbo Pascal 7.0, што работи на Vista ? Ај ако има некој таков нека ми пише на профил или ПП.
 
Бумеранг, земи си Free Pascal и бркај работа. Тоа е бесплатен 32 и 64 битен Паскал компајлер за Windows, Linux и OS X. (Turbo Pascal 7.0 е 16 битен, за DOS)
 
bubi4ko напиша:
Јас имам книга за Ц++ и за Паскал...Сеа со кој програмски јазик да почнам????А сакам и да научам нешто напредно во ХТМЛ зошто имам прочитано две-три книги за почетници.Ако има некој книга за ХТМЛ но да не е за почетници.
Кликни за повеќе...

Немој со Паскал, боље ти е C++. И вториов е веќе стар, али Паскал е праисториски. Јас почнав со C++.
 
Паланчански напиша:
А кој го препорачувате како најдобар???
Кликни за повеќе...

Не е важно со помош на кој програмски јазик ќе почниш да учиш програмирање, важно е да ги разбериш основите, да развиеш логика и најмногу од се вежбање вежбање вежбање, а да и немој премногу да се оптеретуваш со теорија туку со решавање на задачи.
 
Паланчански напиша:
А кој го препорачувате како најдобар???
Кликни за повеќе...

Aбе горе-доле суштината е иста во сите. Финтата е ти да ја научиш логиката на програмите, па за јазикот лесно е, треба да научиш само неколку наредби. И како што кажа некој погоре, не се оптеретувај многу со теорија, да не речам џабе е. Вежбај код.
 
Праам муабет за Free Pascal IDE:

Ја праев вежбата со срцето и откако напраив Compile пробувам RUN..нејќе. Видов негде на нет дека на Free Pascal требало да се напише
fpc именапрограма.pas ама мене ни така не ми успева. Помош ?
 
Само едно прашање.
Дали за програмирање ви треба големо знаење на математика?
 
You must log in or register to reply here.

Kajgana Shop

Back
На врв Bottom