Pamācības

C++ pamati

C++ pamati

kaszu, 12.01.2010

Komentāri: 4

Kas ir C++ kompilātori

Ir daudzas programmēšanas valodas Pascal, Basic, C, C++ (daudz advancētāks C) un daudzas citas. Katrai no ām ir sava programmēšanas vide (vides).

Piem. Visual Studio ir izstrāžu vižu kopums, kas sevī ietver Visual Basic, Visual C++ un citas, katra no tām ir paredzēta programmu izstrādei noteiktā programmēšanas valodā. C++ prorammas var veidot iekš Visual C++, DevC++, kā arī jebkurā teksta editorā, taču tas būs tikai pliks programmas kods ar ko nevarēsiet neko izdarīt, izņemot lasīt un mainīt, taču tā nav programma.

Lai kodu pārvēstu par programmu ir nepieciešams kompilātors, kas koda failu pārvēš exe failā, tam var izmantot iepriekšminētos Visual C++, DevC++ un citus (teksta redaktors nav kompilātors).

Šīs divas izstrādes vides ļauj netikai rakstīt kodu un to kompilēt, bet arī debug-ot (atrast vietu kodā, kur ir radusies kļūda), protams eksistē arī citas. 

DevC++ atšķirībā no Visual C++ ir bezmaksas programma, dabūt var ŠEIT.

Mainīgie, datu tipi 

int a;

Mainīgais šajā kodā ir a.

Tam var tikt piešķirta vērtība atkarībā no tā kāds tips ir šim mainīgajam (šajā gadījumā integer). 
void -netiek piesaistīts nevienam datu tipam.
int -apzīmē integer ("vesels skaitlis"), kura vērtības bar būt no -2147483648 līdz +2147483648, jo interger sastāv no 4-riem baitiem (32 bitiem), no 4-viem baitiem var izveidot skaitli, kam max vērtība ir 256*256*256*256 = 4294967296, taču vajag arī negatīvās vērtības, tāpēc tas tiek dalīts uz pusi (1 bits + vai - zīmei), 1bits zīmes saglabāšanai.
float -peldošā punkta skaitlis, var saturēt skaitļus ar punktu (piem. 3.141592), taču patiesībā tiek saglabāts skaitlis 3141592 un punkta atrašanās vieta šajā skaitlī. Sastāv arī no 4baitiem (32bitiem).
double -dubulti precīzs peldošā punkta skaitlis, tāpēc protams arī  aizņem 2x vairāk vietas. 8baitiem (64bitiem).
char -character, satur kaut kādu simbolu (piem. 'a','/'), viens char mainīgais aizņem 1 baitu(8biti).
bool -boolean, viņa vērtības var būt tikai 0 un jebkurš nenulles skaitlis (jeb true un false), kaut arī saglabāšanai būtu nepieciešams tikai 1bits, atmiņā tas aizņem 8bitus.
wchar_t -wide char, laikam spēj saglabāt arī dīvainos simbolus (netipiskos, laikam domāts piem. chinese valodai), neko tiešām es nezinu par šo (ja kāds zin pasakiet).

Šie ir visi c++ pamata datu tipi, taču ir iespējamas pāris modifikācijas izmantojot signed, unsigned, short un long
Piemēram:

unsigned int a;

unsigned - netiek tērēta atmiņa +- zīmes saglabāšanais, tāpēc unsigned int max. vērtība = 2 * int max. vērtība (tas nozīmē, ka nevar būt negatīvas vērtības). 
signed - jau defaultā
short - aizņem 2 reiz mazāk vietas un attiecīgi nespēj saglabāt tik lielu skaitli
long - aizņem 2 reiz vairāk vietas un spēj saglabāt lielāku skaitli.

Ja par mainīgā tipu tiek izmantoti šie apzīmējumi vieni paši ,tad par parasto tipu tiek uzskatīts int.

long a;

būtu tas pats, kas

long int a;

Kodā mainīgais tiek definēts šādi

[datu tips] [izvēlētais apzīmējums];

";" simbols beigās ir obligāts, tas apzīmē līnijas beigas.

Izvēlētais apzīmējums

Apzīmējums var sastāvēt gandrīz no neierobežoti lielas virknes. Apzīmējumam obligāti ir jāsākas ar burtu, pēc kā var sekot burti,skatļi un _ zīme.

Mainīgo definēšana

Kad mainīgais  tiek definēts tam piesaista kādu noteiktu datu tipu, kas nemainās visu šī mainīgā dzīves laiku.

Vērtību piešķiršana

Vērtības piešķiršana c++ notiek izmantojot = operatoru.

Skaitlisko vērtību piešķiršana

int skint;
skint = 5;
float skfloat;
skfloat = 3.141592;

Simbolu piešķiršanā ir svarīgi, ka simbols atrodas iekš ' ' nevis " ", jo, ja tas atrodas iekš " " tad tas tiek uzskatīts par string (simbolu virkne) un rodas kļūda.

Daži simboli:

'\n' -jaunas līnijas simbols

'\0' -virknes (string) beigu simbols.

char ch;
ch = 'k';

Mainīgajam var piešķirt vērtību netikai pēc incializēšanas, bet arī pašas inicializēšanas laikā.

int a = 4;

Vērtības var tikt piešķirtas no mainīgā mainīgajam.

int a = 4;
int b = a;

Pēc šī izpildes b vērtību būs 4.

Vienkāršākās operācijas

Ar to, ka varam piešķirt mainīgajiem vērtības ir daudz par maz, lai kaut ko izveidotu, tāpēc apskatīsim šādas operācijas + - * / un to pielietojumus.

Saskaitīšana

int a = 4;
int b = 5;
int c;

c = a + b;

Pēc izpildes c vērtība ir 9.

Tas pats būs arī pēc

int a = 4;
int b = 5;
int c = a + b;

 

int a = 4;
int b = 3;
b = b+3;

ir tas pats, kas

int a = 4;
int b = 3;
b += 3;

+= operācija pieskaita labajai pusei kreisās puses vērtību

int b = 4;
b++;

++ operācija pieskaits 1 pie b;

int b = 4;
b+4;

+4 operācija pieskaits 4 pie b; Protams, ka 4 vietā var būt jebkurš cits skaitlis, bet ne cits mainīgais (kļūda neradīsies, taču nebūs nekādas jēgas, jo a+b atrgiež vērtību, taču nepiešķir nekam un tā pazūd).

Tā pat ir ar -, * un /, taču * un / operācijām nevar izmantot a**; vai a//;.

Vienkārša programma

Dators spēj tikai izpildīt secīgas kommandas un no kaut kurienes viņam ir jāsāk tās izpildīt, iekš c++ viss sākas iekš funkcijas main.

int main()
{
  return 0;
}


main ir funkcijas nosaukums, kura tiek izpildīta, kad programma tiek palaista
int ir vērtība ko programma atgriež (vienkāršām programmām int vietā var likt arī void, bet labāk visu darīt pareizi).
( ir argumentu (mainīgo, kuri tiek nodoti funckijai) sākums, main fjai nav neviena argumenta.
) ir argumentu beigu simbols
{ apzīmē funkcijas sākumu
{ apzīmē funkcijas beigas
return - fja tiek pārtraukta, fja atdod vērtību, kas ir no return labajā pusē, main fjai vienmēr ir jāatgriež 0.

Šī programma strādās, taču tā neko nedara.

int main()
{
  int a = 5;
 
  return 0;
}

Programmu palaižot tā izveido mainīgo un piešķir tam vērtību 5 un tas ir arī viss.

Izvads, ievads

#include
using namespace std;

int main()
{
    int a = 5;
    cout<<"Hello, world!";
    cout<     return 0;
}

Ja palaidīsiet šo programmu, tad tā izvadīs uz ekrāna tekstu "Hello, world!", bet uzreiz konsole aizvērsies un jūs pat nepaspēsiet to ieraudzīt. 
#include iekļauj programmā iostream bibliotēku, kurā ir fja cout. Ja bibliotēka ir ielikta <>, tad kompilātors to meklē settingos uzstādītajā direktorijā un pēc tam koda atrašanās vietas direktorijā, ja " ", tad meklē koda direktorijā, bet nemeklē settingos uzstādītajā.
using std namespace; ja šo neuzrakstītu, tad cout vietā vajadzētu rakstīt std::cout
cout<< izvada uz ekrāna to kas atrodas no tā labajā pusē

Protams gribētos, lai mēs redzētu šo rezultātu tāpēc

#include
#include
using namespace std;

int main()
{
  cout<<"Hello, world!";
  char a=getch();  // Var rakstīt arī "getch();" bez "char a", ja tas simbols nav vajadzīgs, kā šeit

  return 0;
}

Iekš conio.h bibliotēkas ir fja getch(), kas no ieejas bufera nolasa vienu simbolu, tas nozīmē, ka programma turpinās rādīt konsoli līdz tiks nospiests kāds taustiņš, getch() nolasa jekuru simbolu  (taustiņu, pat ja nopspiedīsiet pogu palabi).

#include
#include
using namespace std;

int main()
{
  int a;
  cin>>a;
  return 0;
}

cin fja nolasa no ieejas bufera visu, kas tiek uzrakstīts līdz tika nospiests Enter, šajā gadījumā, ja ierakstīsies "asdvcv123", tad radīsies kļūda, jo a ir ar tipu int un nespēj saglabāt burtus, tikai skaitļus.

 Atmiņa, norādes

No sākuma par to kā vērtības tiek glabātas atmiņā.

#include
#include
using namespace std;

int main()
{
    int a = 123;
    cout<     //ar &a tiek iegūta mainīgā a adrese atmiņā
    //Uz ekrāna tiks izvadīts "123 0x22ff44", kur 0x22ff44 ir adrese atmiņā.
   
    return 0;
}

Zīmējumā es atmiņu attēloju ar ne tik lieliem skaitļiem


 

a adrese zīmējumā ir 924, pats a aizņem 4baitus

#include
#include
using namespace std;

int main()
{
    int a = 123;
    cout<    
    unsigned int b = (unsigned int) &a;
    //Tagad b satur skaitli, kas ir a adrese
   
    cout<
    return 0;
}

Norādes

int *a;

Šādi tiek definēts mainīgais, kurš satur skaitli, kas ir adrese. 

    int *a;
    int b = 123;
    int c = 999;
    a = &b;    //a tipam ir jābūt tādam pašam kā b, ja b būtu char ,tad būt jāraksta "char *a;"
   
    cout<     cout<<*a; //tiek izvadits "123"
   
    b = 234;
    cout<<*a; //tiek izvadits "234"

    a = &c;  //tagad a norāda uz c adresi, ar cout<<*a, tiks izvadīts "999"

 

Struktūras 

struct abc
{
};

Šādi definē struktūru, kur abc ir jaunais struktūras vārds. ; simbols ir obligāts pēc struktūras definīcijas. Bet kas ir struktūras?

Piemēram veidojot kaut kādu spēli par tanciņiem, katram tankam ir x, y pozīcijas, virziens, ātrums, utt. , bet apskatīsim tikai šos parametrus. Definēt daudzus masīvus (viens būtu x, viens y, ...) būtu sarežģīti un neērti, tāpēc būtu labi definēt vienu masīvu, kurā katram ierakstam būtu šie parametri. Tāpēc izdevīgi ir izmantot struktūras.

Struktūra ir kā tips, tas ir, definējot mainīgo ar tipu tank, sākumā tiek rakstīts tips (struktūras vārds) un pēc tam seko jaunā mainīgā vārds.

struct tank
{
    long int x;
    long int y;
    int direction;
    int speed;
};

int main()
{
    tank tankarray[100]; //100 tanku masīvs
    tank a;                    //mainīgais a ar tipu tank

    //Lai piekļūtu 17-tajam masīva tankarray elementa x koordinātām:
    tankarray[17].x = 6;

    //Mainīgā a ātruma nomaiņa
    a.speed = 10;

    return 0;
}

Struktūras kāda apakšmainīgā tips var būt arī cita struktūra, taču ne šī pati struktūra (izņemot gadījumu, ja izmanto dinamisko atmiņu), jo ja tā būs, tad sanāks iecikloties un dators nespēj rezervēt bezgalīgu lielu atmiņu.

struct position
{
    int x;
    int y;
};

struct tank
{
    position pos;
    int direction;
    int speed;
};

int main()
{
    tank a;
    a.pos.x = 123;

    return 0;
}

Tas būtu arī viss.

Struktūras dinamiskajā amiņā

struct tank
{
    int x;
    int y;
    int direction;
    int speed;
};

int main()
{
    tank *a;
    a = new tank;

    //Ja tiek izmantota dinamiskā atmiņa, tad . vietā raksta ->
    a->x;

    delete a;
    return 0;
}

 

struct position
{
    int x;
    int y;
};

struct tank
{
    //var rakstīt kā bija iepriekš position pos; taču šoreiz gribu parādīt kā tas ir dinamiskā atmiņā.
    //Protams tas nav loģiski veidot pozīciju dinamiski šajā gadījumā, taču negribēju domāt citu piemēru
    position *pos;
    int direction;
    int pos;
};

int main()
{
    tank *a;
    a = new tank;
    a->pos = new position;

    a->speed = 135;
    a->pos->x = 657;

    return 0;
};

Pati struktūra kā apakšmainīgā tips (saraksta pamats)

struct element
{
    element *next;
    int data;
};

//Kā pievienot elementu, kā parametru nodod pēdējo elementu sarakstā pie kura pievienot vēl vienu elemntu un datus, kurus tam piešķirt.
//Ja funkcija izmainīs somedata, tad vietā no kuras tika uzsaukta šī fja.
//šie dati nemainīsies, bet ja tiks izmainīts last, tad gan izmainīsies, jo izmantojot norādes tiek nodota vieta atmiņā nevis vērtība.

void function addElement(element *last, int somedata)
{
    if (last == 0)  //pārbauda vai šis elements eksistē atmiņā
    {
        last = new element;
    }else{
        last->next = new element;
        last = last->next;
        //Ir jābūt tieši šādā secībā, tiek izveidots jauns elements aiz pēdējā un dodas pa šo norādi uzpriekšu.
        //Ja būtu otrādi, tad jaunizveidotais elements tiktu pazaudēts, tas aizņemtu atmiņu, bet pie tā nevarētu piekļūt pēc vēlviena elementa pievienošanas.
    }

    last->data = somedata;
    last->next = 0;
}

int main()
{
    element *first;
    element *last;
   
    first = last = 0; //nomainam visas norādes uz 0, lai varētu zināt kur ir beigas

    addElement(last, 4);
    first = last;
    //first arī jāpiešķir vērtība, jo tā ir 0, bet mums vajag lai tā norādītu uz pirmo elementu sarakstā.

    addElement(last, 6);
    //Tagad tika pievienots vēlviens elements.

    //Programma automātiski var neatīrīt dinamisko atmiņu, tāpēc labāk par to parūpēties pašam
    while (first != 0)
    {
        last = first;            //Last elementu izmantojam kā pagaidu mainīgo norādes saglabāšanai
        first = first->next; //Pārvietojam norādi pa vienu uz priekšu
        delete last;          //Izdzēš elementu
    }

    return 0;
};

Šādi izskatījās atmiņā, pirms elementi tika izdzēsti. 

  

Klases

Klases ir ļoti līdzīgas struktūrām pēc to definīcijas

class tank
{
};

Atšķirība starp klasēm un struktūrām ir tā, ka tajā var tikt definētas funkcijas (ja netiek, tad nav nepieciešamības to veidot un var iztikt ar struktūru), kā arī tajā var veidot mainīgos un funkcijas, kuri nav redzami no ārpuses (privātos), piemēram, mēģinot iegūt kāda mainīgā vērtībum, kurš ir definēts kā privātais, programma uzvedas tā it kā tā nemaz nebūtu šajā klasē, rodas kļūda. Privātajiem mainīgajiem piekļūt var tikai no klases iekšpuses, tas ir no kādas funkcijas klasē.

Kad tiek izveidots mainīgais nekad nav garantijas, ka tā sākum vērtība ir 0, kā arī sekojošajā piemērā mainīgā health ("dzīvība", "veselība") sākumvērtībai būtu jābūt 100, tādēļ var izmantot konstruktorus un destruktorus, tie ir:

1) Konstruktors - varbūt nosaukums ir dīvains, bet tā ir funkcija, kura tiek izsaukta, kad klases eksemplārs* tiek izveidots. C++ atļauj veidot vairākus konstruktorus (tā pat kā funkcijas) ar vienādiem vārdiem, ja vien to parametri atšķiras. Konstruktora vārdam ir jāsakrīt ar klases nosaukumu!!!.

2) Destruktors - arī funkcija, kura tiek izsaukts kad klases eksemplārs tiek iznīcināts. Destruktora vārds arī sakrīt ar klases nosaukumu, taču tam priekšā nāk "~" simbols.

Konstruktoram un destruktoram netiek priekšā rakstīta atgriežamā vērtība, atšķirībā no funkcijām!

Ja mēs klasē neizveidojam paši kontruktoru un destruktoru, tad to izdara kompilātors, tas izveido tukšu funkciju.

Veidosim tāpat kā vienā no iepriekšējiem piemēriem tanku, tikai šoreiz ar klasi un pievienosim dažas funkcijas.


#include
using namespace std;

struct position
{
    int x;
    int y;
};

class tank
{
    //privātie mainīgie un funkcijas, kuri nebūs "redzami" no ārpuses
    private:
        int health;
   
    //publiskie mainīgie un funkcijas, kuriem varēs piekļūt
    public:
        position pos;
        int direction;
        int speed;

        tank()
        {
            pos.x = 0;
            pos.y = 0;
            speed = 0;
            direction = 0;
            health = 100;
        }
        tank(int startingX, int startingY, int startingSpeed)
        {
            pos.x = startingX;
            pos.y = startingY;
            speed  = startingSpeed;
            direction = 0;
            health = 100;
        }

        //funkcija, kas nomainīs health, jo no ārpuses, mēs to nevaram izdarīt
        void setHealth(int newHealth)
        {
            health = newHealth;
        }
        //šī protams atgriež health
        int getHealth()
        {
            return health;
        }
       
        //Patiesībā mums nemaz nav vajadzīgs destruktors, tāpēc varam to arī neveidot,
      //taču piemēra pēc lūk
        ~tank()
        {
        }
};

//Kā izveidot klasi
int main()
{
    //izveidojot pirmo tanku tiks izsaukts pirmais konstruktors
    tank sometank1;
    //otro tanku veidojot noteiksim sākumvērtības izmantojot otro kostruktoru
    tank sometank2(100,10,0);

    sometank1.setHealth(99);

    cout<<"Pirmais tanks:";
    cout<     cout<
    cout<<"Otrais tanks:";
    cout<     cout<
    //Lai apskatītu rezultātu pievienojam
    char a;
    cin>>a;

    return 0;
}

*klases eksemplārs


    //šeit klases eksemplārs ir sometank, mainīgais, kura tips ir šī klase.
      tank sometank;

Jūs varētu interesēt arī šādi raksti:

Aptauja

Vai Tu apmeklēji gamedev.lv konferenci [0]



Citas aptaujas

Autorizācija

Lietotājs

Parole


Reģistrēties Aizmirsi paroli?