abyss
Lapkritis 7, 2006

C pointerių pagrindai

Šiame straipsnyje norėčiau skaitytojus supažindinti su c pointerių pagrindais.
Straipsnyje aptariamos temos:


1. Pointer’ių pagrindai

Pointer (rodyklėlė) yra papraščiausiai kintamasis, kuris talpina duomenų vienetus adrese, esantis kažkur atmintyje, užuot talpinęs tą atmintį pats. Kitaip tariant, pointer’iai turi/saugo atminties adresus. Taip sutaupoma atminties. Netgi patyrusiems programuotojams kartais sunku įsivaizduoti kaip jie veikia, ypač kai reikia susidurti su komplikuotomis pointer’ių konstrukcijomis, tokiomis kaip pointer’iai nukreipti į pointer’ius.
Užuot rodę tikrus adresus diagramose, pointer’iai yra įprastai piešiami kaip rodyklėlės jungiančios vieną vietą su kita. Kai pointer’is visiškai nieko nerodo/nesaugo, t.y. kai jis yra NULL- jis yra iliustruojamas, kaip linija užbaigiama dviejų brukšniukų.

Kaip su kitų tipų kintamaisiais, mes neturėtume manyti, kad pointer nurodo (išsaugo adresą) ką nors naudingo, iki mes jį nurodome (paaiškiname prog). Taip pat svarbu atminti, kad niekas pointer’iui netrukdo C kalboje nurodyti klaidingą adresą. Pointer’iai, kurie nurodo klaidingą adresą, kartais vadinami nežinomais pointer’iais. Žmogus blogai suprantantis pointer’ius ir juos naudojantis gali padaryti daug programavimo klaidų, tokių kaip: pasirenkami nežinomieji/klaidingi pointer’iai, nustatyti pointer’ius už array (masyvo) ribos.

Norint realizuoti pointer’į reikia po kintamojo padėti asteriską(*), šitaip:

int daiktas; //išreiškiame daiktą
int *daiktas_ptr; //išreiškiame per pointer'į daiktą (pointer'is saugo daikto adresą)

C kalboje, kalbant apie pointer’ius taip pat naudojamas ženklas (&), kuris gražina daikto adresą. Ženklas (*) gražina objektą į kurį pointer’is rodo (pointina). Šie operatoriai gali jus sumaišyti, bet tolimesni pavyzdžiai, viską paaiškins.
C kodas | aprašymas daiktas | Paprastas daiktas(kintamasis) &daiktas | Pointer į kintamajį daiktas daiktas_ptr | Pointer į sveikajį skaičių(integer) *daiktas_ptr | sveikasis skaičius(integer)
Pažiūrėkime į keletą pavyzdžių su šiais operatoriais:

int daiktas; //išreiškiame sveikajį skaičių (integer)
thing = 4;
int *daiktas_ptr; //išreiškiame per pointer'į daiktą
daiktas_ptr = &daiktas; /* nurodo (pointina)  daiktą.

&daiktas yra pointer, o daiktas yra objektas, taigi (&) operatorius gauna objekto adresą (gauna pointer’į), taigi &daiktas yra pointer. Mes tai priskiriame daiktas_ptr, kuris taip pat yra pointer.Taigi rašydami:

*daiktas_ptr = 5; //iš tikrųjų pakeičiame objektą "daiktą" į 5, kur anksčiau buvo 4.

*daiktas_ptr nurodo daiktą, o daiktas_ptr yra pointer.

Programos pvz:

#include <stdio.h>
 
int main()
{
        int daiktas = 4;
        printf("daiktas = %d \n", daiktas);
        int *daiktas_ptr;
        daiktas_ptr = &daiktas;
        *daiktas_ptr = 5;
        printf("Dabar daiktas = %d\n", daiktas);
        return 0;
}

Į viršų
2. Pointer kaip funkcijos argumentas
Įsivaizduokime, kad funkcija main() nori, kad funkcija sk_count() padidintų kintamojo count reikšmę.
Perduoti paprastai/tiesiai (directly) nepavyks, todėl naudojam pointer (”Štai adresas kintamojo, kurį aš noriu, kad tu padidintum”).
Štai pavyzdys, kad suprastumėte:

#include <stdio.h>
 
void sk_count(int * count)
{
        (*count)++;
}
 
int main()
{
        int count = 0;
        while(count < 10)
        {                 
                sk_count(&count);
                printf("Skaicius: %d\n", count);
        }
 
return 0;
}

Egzistuoja pointer, kuris rodo/pointina į nieką, jis vadinamas NULL. Jis išreikštas locale.h, jis dažniausiai nenaudojamas, nes jį įterpia sdtio.h arba sdtlib.h .
Į viršų
3. Pastovūs (constant) pointer’iai
Išreikšti konstanta pointer’į yra truputį sudėtinga, pvz:

const int count = 5;

tai pasako C kompiliatoriui, kad count yra konstanta (pastovus kintamasis), taigi, jei mes rašytume:

count = 10; //gautume error'ą

Dar vienas pavyzdys:

char *ats_ptr = "atsakymas";

Šita formuluotė nepasako, kad ats_ptr yra konstanta. Tačiau, ji pasako, kad duomenys į kuriuos rodo pointer (rodyklėlė) yra konstanta. Duomenys negali būti pakeisti, bet pointer gali.
Taigi paklauskime savęs “kas yra ats_ptr?”, ar galima jį pakeist? TAIP galima, tai tik pointeris. Į ka jis rodo (points)? Į const char masyvą. Ar duomenys į kuriuos rodo (points) ats_ptr gali būti pakeisti? NE, jis yra pastovus (constant).
Truputis kodo:

ats_ptr = "vienas"; //galimas variantas (ats_ptr yra kitamasis)
*ats_ptr = "du";   //klaidingas variantas (*ats_ptr yra konstanta)

Jeigu mes padėtume asteriską (*) prieš const, pasakytume C kompiliatoriui, kad pats pointer’is yra nekintamas, pastovus (constant).
Pavyzdžiui:

char *const tst_ptr = "Testas";

Kas yra tst_ptr? Tai nekintamas pointer’is - konstanta. Ar galime jį pakeisti? NE. Į ka jis rodo (points)? Į tekstą (character). Ar duomenys į kuriuos jis rodo gali būti keičiami? TAIP.

tst_ptr = "vienas"  //klaidingas variantas (ats_ptr yra konstanta)
*tst_ptr = "du"    //galimas variantas (*ats_ptr yra char)

Galiausiai, mes const galime padėti abiejose vietose, sukurdami pointer’į ir duomenis (data), kurių keisti nebūtų galima:

const char *const t_ptr = "Time";

Į viršų
4. Pointer’iai ir masyvai (arrays)
C kalboje pointer’iai palaiko aritmetiką (sudėti ir atimti). Sakykime mes turime:

char array[5];
char *array_ptr = &array[0];

Šiame pavyzdyje, *array_ptr yra tas pats kaip array[0], *(array_ptr+1) yra tas pats kaip array[1], *(array_ptr+2) yra tas pats kaip array[2], ir taip t.t.
Vis dėlto ir čia galima lengvai susimaišyti, kadangi (*array_ptr) +1 yra NE tas pats kaip array[1]. Kadangi +1 yra už sklaustelių, todėl jis dedamas tik po pointer’io priskyrimo. Tai (*array_ptr) +1 yra tas pats kaip array[0] + 1.
Array (masyvo) elementai/adresai yra priskiriami iš eilės. Pvz, array[0], gali būti patalpintas adrese 0xff000000. Tada array[1] būtų 0xff000001, ir t.t. Šituo noriu pasakyti, kad pointer gali būti naudojamas rasti kiekvieną array (masyvo) elementą. Štai trumpa programėlė, kuri viska paaiškins:

#include <stdio.h>
 
#define ARRAY_SIZE 10
 
char array[ARRAY_SIZE + 1] = "0123456789";
 
int main()
{
  int index;
        printf("&array[index], (array + index), array[index]\n");
        for(index =0; index < ARRAY_SIZE; ++index)
        {
            printf("0x% - 10p,     0x% - 10p,      0x%x\n",&array[index], (array + index), array[index] );
        }
  return 0;
}

Pastaba: %p naudojamas, kai reikia išspausdinti pointer’į.
Char elementai naudoja vieną bitą ir priskiriami iš eilės. O short int naudoja 2 bitus, taigi short int masyve adresai didėja kas du. Ar tai reiškia , kad array+1 veiks tik su char? NE. C automatiškai apskaičiuoja pointer’ių aritmetiką, taigi tai veikia gerai. Tokiu atveju array+1 rodys į elementą numeris 1.
C kalboje yra sutrumpinimų dirbant su masyvais (array), užuot rašę:

array_ptr = &array[0];

mes galime rašyti:

array_ptr = array;

C užglaisto skirtumus tarp pointers (rodyklėlių) ir arrays (masyvų) elgdamasis su jais panašiai daugeliu atžvilgių. Čia mes naudojame kitamajį array kaip pointer, ir C automatiškai padaro konvertavimą.
Pvz:

#include <stdio.h>
 
int array[] = {4, 5, 1 , 3 , 8 ,9 ,10, 3, 4 , 6, 0 , 7, 11};
int index;
 
int main()
{
index = 0;
        while(array[index] != 0)
        {
                ++index;
                printf("Kiekis elementu, pries nuli: %d\n", index);
        }
        return 0;
}

Pvz su pointers:

#include <stdio.h>
 
int array[] = {4, 5, 1 , 3 , 8 ,9 ,10, 3, 4 , 6, 0 , 7, 11};
int *array_ptr;
 
int main()
{
array_ptr = array;
        while((*array_ptr) != 0)
        {
                ++array_ptr;
                printf("Kiekis elementu pries nuli: %d\n", array_ptr - array);
 
        }
return 0;
}

Pastaba: kai mes norime patikrinti duomenis masyve, mes naudojame operatorių (*). Šis operatorius naudojamas šioje formuluotėje:

while ((*array_ptr) != 0)

Kai mes norime pakeisti pointer’į, joks kitas operatorius nenaudojamas. Pavyzdžiui, eilutė:

**array_ptr

Padidina pointer’į, bet ne duomenis.
Formuluotė (array[index] !=0) reikalauja kompiliatoriaus sugeneruoti index operaciją, kuri užima daugiau laiko nei pointer patikrinimas, ((*array_ptr) != 0).
Sakinys programos gale, array_ptr - array, apskaičiuoja kaip toli array_ptr yra nuėjęs masyve.
Kai perduodame array (masyvą) į procedūrą, C automatiškai pakeičia array į pointer (rodyklėlę). Iš tikrųjų jeigu tu prieš array padėtum &, C praneštų apie klaidą.
Šis pavyzdys parodys keletą būdų kaip masyvas (array) gali būti perkeliamas i paprogramį (subroutine):

#define MAX 10 /* array dydis */
 
/*funkcija init_array_1 - masyva isnulina.
   paramentras data - masyvas kuri reikia isnulinti */
void init_array_1(int data[])
{
        int index;
        for(index = 0; index < MAX; ++index)
        {
                data[index] = 0;
        }
}
 
/*funkcija init_array_2 - masyva isnulina
   paramentras data_ptr - rodo i masyvo nuli*/
 
void init_array_2(int *data_ptr)
{
        int index;
        for(index = 0; index < MAX; ++index)
        {
                *(data_ptr + index) = 0;
        }
}
 
int main()
{
        int array[MAX];
        void init_array_1();
        void init_array_2();
 
                /*vienas budas kaip panaudoti array*/
                init_array_1(array);
 
                /*kitas budas kaip panaudoti array*/
                init_array_1(&array[0]);
 
                /*Panasus i pirma tik funkcija skirtinga*/
                init_array_2(array);
 
                return 0;
}

Į viršų
5. Kaip nenaudoti pointer’ių
Štai programėlė, kuri parodo praktiką, kuri NETURĖTŲ būti naudojama:

int array[10]; //masyvas musu duomenims
 
int main()
{
        int *data_ptr; //rodo i duomenis
        int value; //duomenu dydis
 
        data_ptr = &array[0]; //rodo i pirmaji elementa
        value = *data_ptr++; //Gaunam elementa #0, data_ptr rodo i elementa #1
        value = *++data_ptr; //Gaunam elementa #2, data_ptr rodo i elementa #2
        value = ++*data_ptr; //Padidinam elementa #2
        return 0;
}

Kad suprastume šias formuluotes, mes turime atidžiai jas išnagrinėti ir rasti paslėptą prasmę. Kai aš darau programos peržiūrą, aš nenoriu jaudintis dėl paslėptų/sudėtingų reikšmių, todėl toks programos rašymas yra klaidingas, todėl stenkitės taip nerašyti, o rašančius perspėkite.
Dar vienas funkcijos pavyzdys, kuriame programa kopijuoja tekstą iš šaltinio (q) į (p).

void copy_str(char *p, char *q)
{
while(*p++ = *q++); //atminkite, kad (=) yra priskirimo zenklas
}

Duodant laiko, geras programuotojas išsiaiškintų kas čia parašyta (čia sakinys kopijuojamas imant po vieną raidę (character)). Vis dėlto suprasti programą būtų kur kas lengviau, jei mes ją kiek pagražintume.

/* 
    Funkcija copy_str - kopijuoja viena teksta i kita 
 
    Paramentrai:
         dest - vieta kur kopijuoti teksta(string)
         source - is kur imti teksta
                                                      */
void copy_str(char *dest, char *source)
{ 
     while(1)
     {
        *dest = *source;
 
        // Baigiam darba jei visas tekstas nukopijuotas //
        if(*dest == '\0')
           {
              return;
           }
 
        ++dest;
        ++source;
     }
}

Pastaba: kiekvienas tekstas (string) baigiasi

'\0'

, kurį C kompiliatorius uždeda automatiškai.
Į viršų
6. Pointer’iai teksto perskyrimui
Sakykime mes turime tekstą “Pirmas/Antras” ir mes norime padalinti jį į du, t.y. į pirmą ir į antrą.
Mums reikia funkcijos, kuri surastų slašą. Funkcija strchr įeinanti į standartinę biblioteką mums padės. Toliau programos pavyzdyje mes naudosime šios funkcijos duplikatą, kad suprastumėt kaip veikia ši funkcija.
Šita funkcija reikalauja pointer’io, kuris rodytų į tekstą, mūsų atveju tai būtų string_ptr ir charakteris, kurį mums reikia rasti (find) kaip jo argumentus. Tai prasideda su ciklu while, kuris tęsiasi tol, kol suranda mums reikalingą charakterį (ženklą, raidę).
Mūsų būsima programa skaito vieną eilutę, išimdama iš jos naujos eilutės ženklą ‘\0′. Funkcija my_strchr yra iškviečiama, kad surastų slašo (\) vietą.
Mūsų atžvilgiu, first_ptr rodys į pirmą charakterį, “Pirmas” gabaliuką, o last_ptr rodys į slašą. Tada mes perskirsime tekstą (string), vietoje slašo (\) įstatydami eilutės pabaigą (NULL arba \0). Dabar first_ptr rodys į pirmą teksto dalį, t.y. “Pirmas”, o last_ptr rodys į nulinį tekstą (string) t.y. (\0). Pastumiant last_ptr vienu charakteriu, gausim teksto gabaliuko ”Antras” pradžią. Štai lauktas pavyzdys:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
/* 
   my_strchr - suranda charakterį tekste(string).
 
   Parametrai:
       string_ptr - tekstas kuri reiks nagrineti
       find - charakteris kurio ieskosime
 
   Grazina pirma rastą charakterį tekste arba NULL
   jei rastas klaida(error). 
                                                   */
 
char *my_strchr(char *string_ptr, char find)
{
   while(*string_ptr != find)
   {
 
        if(*string_ptr == '\0')  //jeigu mes  neradome ko ieskojome        
        {                        //t.y jei tektas baigesi graziname NULL.
         return (NULL);          //Atminkite kad NULL dazniausiai naudojamas kai kalbama
        }                        //apie pointer'ius.
 
    ++string_ptr;                //Jeigu dar ne teksto(string) pabaiga, tai nustatome
    }                            //pointer rodyti i kita charakteri.
        return(string_ptr);      //rasta, tai ir graziname
}
 
 
int main()
{
        char line[80];          //ivestis
        char *first_ptr;        //pointer'is kuris rodo i "Pirmas" vieta
        char *last_ptr;         //pointer'is kuris rodo i "Antras" vieta
 
        printf("Iveskite du vardus perskiradami juos slasu (/)\n\n");
 
        fgets(line, sizeof(line), stdin); // fgets funkcijai nurodome kur kaupti ivestus duomenis, ju dydi, 
                                          // bei is kur skaityti musu atveju, is ivesties, t.y tiesiai is klaviaturos.
 
        line[strlen(line)-1] = '\0';        // '\n' pakeiciame '\0' taip uzbaigdami  teksta(string)
 
        first_ptr = line;                   // "Pirmas" vieta yra eilutes(line) pradzioje
 
        last_ptr = my_strchr(line, '/');    //randam slasa
 
        if(last_ptr == NULL)
        {
                fprintf(stderr, "Klaida, nepavyko rasti slaso %s\n", line);  // stderr standartine neturinti bufferio 
                exit(8);                    // isvestis skirta isvesti klaidoms(error) i ekrana, ji isreiksta sdtio.h
        }
        *last_ptr = '\0';  //slasa pakeiciame nuliu
 
        ++last_ptr;       //pastumiam vienu charakteriu i prieki
 
        printf("Pirmas:%s\t Antras:%s\n", first_ptr, last_ptr);
 
        return 0;
 
}

Į viršų
7. Komandinės eilutės argumentai
Procedūra main iš tikrųjų palaiko du argumentus, jie vadinami argc ir argv. Jie gali būti vadinami bet kaip, vis dėlto 99% programų naudoja, šiuos pavadinimus.

main(int argc, char *argv[])
{

Pastaba: kad lengviau įsidėmėtumėt jų eiliškumą, atkreipkit dėmesį į jų alfabetišką išdėliojimą.
Paramentras argc laiko parametrų kiekį, įskaitant programos pavadinimą. Masyvas (array) argv laiko tikruosius argumentus. Pavyzdžiui, jei mes paleisime programą args su šiais komandinės eilutės argumentais:

args tai yra testas

tada:

argc     = 4
argv[0]  = "args"
argv[1]  = "tai"
argv[2]  = "yra"
argv[3]  = "testas"
argv[4]  = "NULL"

Beveik visos UNIX komandos naudoja standartinę komandinės eilutės įvestį. Šis standartas palaipsniui perkeliamas į kitas aplinkas. Standartinė UNIX komandinė forma atrodo maždaug taip:

komanda nustatymas failas1 failas2 ...

Nustatymus pažymi brukšnelis (-), o patys nustatymai dažniausiai būna vieno charakterio/raidės. Pvz:

-v

Jeigu nustatymui reikia daugiau nei vieno paramentro, tai jie vedami iškart po raidės. Pvz:

-m1024

nustato maksimalų simbolių skaičių 1024.
Pažiūrėkime į programą, kuri gali skaityti komandinę eilutę ir veikti pagal nustatymus. Šita programa formatuoja ir spausdina failus. Dalį dokumentacijos panagrinėsime dabar:

print_file [-v] [-llenght] [-oname] [file1] [file2] ...

kur:
-v
Įjungia daug progreso žinučių
-llength
Nustato puslapio dydį pagal eilučių ilgį
-oname
Nustato išvesties vardą
file1, file2
Sąrašas failų spausdinimui.
Mes galime naudoti ciklą while, kad gautume komandinės eilutės nustatymus.
Ciklas atrodytų šitaip:

while((argc >1) && (argv[1][0] == '-')) {

Vienas argumentas visada egzistuoja, t.y. programos pavadinimas. Išraiška (argc >1) tikrina ar nėra daugiau argumentų. Pirmas argumentas yra numeris 1 (nes 0 yra programos pvd). Pirmas charakteris (raidė/ženklas), pirmojo argumento yra argv[1][0]. Jeigu tai brūkšnelis, mes turime nustatymą.
Ciklo pabaigoje yra kodas:

--argc;
++argv;
}

Tai suvartojo argumentą. Argumentų skaičius yra pamažinamas, kad rodytų vienu argumentu mažiau, o pointer’is (rodyklėlė) į pirmajį argumentą yra padidinamas, taip perstumiant sąrašą į kairę.
Switch formuluotė naudojama nustatymo iškodavimui. Argumento charakteris yra (-) brūkšnelis. Charakteris 1 yra nustatymas, taigi mes naudojame šitokią išraišką:

switch(argv[1][1]){

dekoduojam nustatymą.
Nustatymas -v neturi jokių argumentų, tai tik nustatomoji vėliavėlė.
Nustatymas -o reikalauja failo. Užuot kopijavę visą tekstą (string), mes nustatome pointer’į out_file, kad rodytų teksto dalį su failo vardu.

argv[1][0] = '-'
argv[1][1] = 'o'
argv[1][2] = failo pavadinimo pirmas charakteris (raidė)

Nustatome out_file, kad rodytų į tekstą (string) su šia formuluote:

out_file = &argv[1][2];

Nuostata -l yra sveikas skaičius (integer). Bibliotekos funkcija atoi yra naudojama paversti tekstą į sveikajį skaičių (integer). Iš ankščiau pateiktų pavyzdžių, mes žinome, kad argv[1][2] yra pirmas charakteris (raidė/ženklas) teksto, kuris turi numerį. Šitas tekstas (string) yra perduodamas atoi.
Galiausiai mes einame per ciklą, kur patikrinam nustatymus. Tai papraščiausiai įvykdo do_file kiekvienam argumentui. Štai print programos pavyzdys:

/* 
    Programa: Print.
    Tikslas: formatuoja failus spauzdinimui.
    Naudojimas: print [nustatymas]  failas/ai
    Nuostatos: -v('Verbose' ?inut?s), -o<failas>(suncia isvesti i faila), -l<eilutes>(nustato eiluciu skaiciu lape)
                                                                                                                                                                      */
#include <stdio.h>
#include <stdlib.h>
 
int verbose = 0;                         //pagal numatyma 0
char *out_file = "print.out";       //iseities failo pavadinimas
char *program_name;               //programos pavadinimas
int line_max = 66;                     //eiluciu skaicius per puslapi
 
void do_file(char *name)
{
        printf("Verbose %d Eilutes %d Ivestis %s Isvestis %s\t\n", verbose, line_max, name, out_file);
 
}
 
void usage(void) //pasako vartotojui kaip naudotis sia programa
{
        fprintf(stderr, "Naudojimas yra %s [nustatymas] [failu sarasas]\t\n", program_name);
 
        fprintf(stderr, "Nustatymai\t\n");
        fprintf(stderr,"  -v          verbose\t\n");
        fprintf(stderr,"  -l<numeris>  eiluciu skaicius\t\n");
        fprintf(stderr,"  -o<pavadinimas>    nustatyti failo pavadinima\t\n");
        exit (8);
}
 
int main(int argc, char *argv[])
{
 usage();
        program_name = argv[0]; //issaugom programos pavadinima
while((argc>1) && (argv[1][0] == '-')) //cikals kiekvienam nustatymui
        {
                switch(argv[1][1]) //tikrasis nustatimo charakteris
                {
                                case 'v':
                                        verbose = 1;
                                        break;
                                case 'o':
                                        out_file = &argv[1][2];
                                        break;
                                case 'l':
                                        line_max = atoi(&argv[1][2]);
                                        break;
                                default:
                                        fprintf(stderr, "Bloga nuostata %s\t\n", argv[1]);
                                        usage();
                }
                        ++argv;
                        --argc;
        }
   /*
        Siuo momentu visos nuostatos jau praeitos.
        Patikrinam ar sarase yra failu.
        Jei nera tai naudojame paprasta ivesties srauta
 
                                                                                   */
 
if(argc ==1)
        {
                do_file("print.in");
        }
        else
        {
                while(argc >1)
                {
                        do_file(argv[1]);
                        ++argv;
                        --argc;
                }
        }
 
        return 0;
}

Į viršų

Laukiame jūsų komentarų.

Panašūs straipsniai


“C pointerių pagrindai” komentarų: 13

  1. Slave-4-Code

    Šaunu ;-)

  2. spt

    Baisu :) Klaidos kode, klaidos tekste. Galima būtų paredaguoti prieš publikuojant straipsnį viešai.

  3. Eimantas Vaičiūnas

    spt - jie jau turi redaktorę, kuri tikrina straipsnius prieš juos išleisdama viešai.

  4. abyss

    Nu del klaidu zinau, o del klaidu kode, man po pellesC ner…

  5. asterisk

    na jinai ne visagalė, iš esmės čia kalta buvo wordpress codesnippet sistema, kuri eilinį kartą nukirpo kodo dalis. Straipsnis atnaujintas ir klaidos ištaisytos.

  6. HEADSHOT

    Oho sis straipsnis turbut pretenduoja i ilgiausio straipsnio titula (p.s. neskaiciau :D)

  7. petras

    int daiktas; //išreiškiame sveikajį skaičių (integer)
    thing = 4;

  8. petras

    int daiktas; //išreiškiame sveikajį skaičių (integer)
    thing = 4; —-
    int *daiktas_ptr; //išreiškiame per pointer’į daiktą
    daiktas_ptr = &daiktas; /* nurodo (pointina) daiktą.

    Vel verstas straipsnis. Negi Lietuvoj nesugebam sukurt ka nors savo.

  9. NePo

    Mielas petrai, jeigu straipsnis verstas pateikite nuorodą į originalą

    Be to mes labai laukiame originalaus jūsų straipsnio. Juk Lietuvoje tikrai sugebiame sukurti kažką savo, taip?

  10. petras

    Mielas NePo, tuomet gal galėtumėte paaiškint iš kur originaliam, Lietuviškam “tutoriale” tokios tat eilutės atsiranda - “thing = 4;”?

  11. petras

    http://www.oreilly.com/catalog/pcp3/chapter/ch13.html
    Ir guglint daug nereikėjo, panašūs kaip du vandens lašai.
    Sarmatos turetumet…

  12. ingas

    Gerai parasyta,labai gerai tinka pradedantiems mokinantis programavimo,ir man nesvarbu is kokiu saitu imti duomenys,perskaiciau lietuviskai,jei noresiu,tai papildomai perskaitysiu ir saitus anglu kalba,zmogus savo darba pateike kitiems ir tai fain.

  13. pilietis_007

    Nepaisant keliu klaidu, tikrai neblogas straipsnis. ;)

Rašyti komentarą

Jūs privalote prisijungti jeigu norite rašyti komentarą.