Copy
char tekst[] = "Ovo je neki tekst";
  

Copy
char tekst[] = {'O', 'v', 'o', ' ', 'j', 'e', 'n', 'e', 'k', 'i',
                ' ', 't', 'e', 'k', 's', 't', '\0'};
  

Copy
char tekst[] = "Ovo je neki tekst";
  

Copy
char tekst[] = {'O', 'v', 'o', ' ', 'j', 'e', ' ', 'n', 'e', 'k', 'i',
                ' ', 't', 'e', 'k', 's', 't', '\0'};
  

Copy
char ch = 'A';
printf("Kod slova i slovo: %c %d\n", ch, ch);
  

Kod slova i slovo: A 65
  

Copy
#include <stdio.h>

int main() {
    char c = 'A';
    printf("Character: %c, ASCII value: %d\n", c, c);
    return 0;
}
  

Copy
#include <stdio.h>
#include <stdlib.h>

int main() {
    for(int ch = 32; ch <= 126; ch++) {
        printf("%c %d\n", ch, ch);
    }
    return 0;
}
  

! 33
" 34
# 35
$ 36
% 37
...
~ 126
  

Copy
#include <stdio.h>
#include <ctype.h>

int main() {
    int sc = 0; // broj znakova interpunkcije
    int nd = 0; // broj cifara
    int uc = 0; // broj velikih slova
    int lc = 0; // broj malih slova
    char ch;

    printf("Unesite šifru!\n");

    do {
        ch = getchar();

        if (ispunct(ch)) {
            sc++;
        }
        if (isdigit(ch)) {
            nd++;
        }
        if (isupper(ch)) {
            uc++;
        }
        if (islower(ch)) {
            lc++;
        }

    } while (ch != EOF && (!isspace(ch) && !iscntrl(ch)));

    printf("Šifra ima %d malih slova, %d velikih slova, %d cifru/cifre i %d specijalnih znakova.\n",
           lc, uc, nd, sc);

    return 0;
}
  

Copy
char* pTekst = "Danas je lep dan"; 
char tekst2[19] = {'A','n','a',' ','v','o','l','i',' ',
                   'M','i','l','o','v','a','n','a','\0'};

Copy
pTekst++; // sada pokazuje na sledeći karakter

Copy
char* pch2 = tekst2; // pokazivač pch2 pokazuje na prvi element niza tekst2

Copy
#include <stdio.h>

int main() {
    // Dinamičko kreiranje stringa pomoću pokazivača
    char* pTekst = "Danas je lep dan"; 
    // Pokazivač pokazuje na konstantni string u memoriji.

    // Statičko kreiranje stringa pomoću niza
    char tekst2[19] = {'A','n','a',' ','v','o','l','i',' ',
                       'M','i','l','o','v','a','n','a','\0'};

    // Ispis stringa kreiranog dinamički
    printf("tekst 1:\t");
    while (*pTekst != '\0') { 
        printf("%c", *pTekst); // Ispis trenutnog karaktera
        pTekst++;              // Pomeri pokazivač na sledeći karakter
    }
    printf("\n");

    // Povezivanje pokazivača sa statičkim nizom
    char* pch2 = tekst2; 
    printf("tekst 2:\t");
    while (*pch2 != '\0') {
        printf("%c", *pch2);  // Ispis karaktera
        pch2++;               // Pomeri pokazivač na sledeći karakter
    }

    printf("\n");
    return 0;
}

Copy
char rec[10];
scanf("%s", rec);

Copy
scanf("%9s", rec); // Maksimalno 9 karaktera + '\0'

Copy
fgets(tekst2, sizeof(tekst2), stdin); 

Copy
#include <stdio.h>
#include <stdlib.h>

int main() {
    char tekst1[10], tekst2[50]; // prvi niz manji, drugi veći

    // Učitavanje jedne reči pomoću scanf
    printf("Unesi tekst (jedna rec):\n");
    scanf("%9s", tekst1); // sigurno učitavanje do 9 karaktera
    printf("Ucitano: %s\n", tekst1);

    getchar(); // da "pojede" Enter sa tastature

    // Učitavanje celog reda pomoću fgets
    printf("Unesi ceo red teksta:\n");
    fgets(tekst2, sizeof(tekst2), stdin);
    printf("Ucitano: %s\n", tekst2);

    return 0;
}

Problemi sa učitavanjem stringova

Problemi koji se javljaju pri učitavanju:

• Zaostali karakter u baferu kada se učitava tekst do belog znaka
• Prelivanje bafera kod učitavanja zastarelom metodom gets

1. Zaostali karakter u ulaznom baferu

Kada scanf() pročita unos, ostavlja novi red (\n) u ulaznom baferu nakon unete vrednosti. Ako odmah nakon scanf() koristite funkciju koja čita ceo red, poput fgets(), ona će pročitati preostali \n, što može izgledati kao da korisnik nije uneo ništa.

Rešenje: pozvati getchar() nakon unosa sa scanf(). Poziv getchar() uklanja taj preostali \n iz bafera, omogućavajući pravilno učitavanje sledećeg reda teksta.

a. Korišćenje modifikatora za scanf()

scanf("%s", ime);

b. Korišćenje fgets() i sscanf()

#include <stdio.h>
#include <string.h>

int main() {
    char unos[30];
    char ime[30];

    // Učitava ceo unos
    fgets(unos, sizeof(unos), stdin);
    sscanf(unos, "%s", ime); // Ekstraktuje prvu reč iz unosa

    printf("Prva reč: %s\n", ime);
    return 0;
}

c. Ručno uklanjanje znakova iz bafera

int ch;
while ((ch = getchar()) != '\n' && ch != EOF);

d. Upotreba fgets() i obrade stringova

d.1 Primer sa sscanf()

#include <stdio.h>

int main() {
    char unos[100];
    char ime[30];

    printf("Unesite tekst: ");
    fgets(unos, sizeof(unos), stdin); // Učitava ceo red, uključujući razmake

    if (sscanf(unos, "%s", ime) == 1) {
        printf("Prva reč: %s\n", ime);
    } else {
        printf("Nije uneta validna reč.\n");
    }

    return 0;
}

d.2 Primer sa strtok()

#include <stdio.h>
#include <string.h>

int main() {
    char unos[100];

    printf("Unesite tekst: ");
    fgets(unos, sizeof(unos), stdin);

    unos[strcspn(unos, "\n")] = '\0'; // uklanjanje '\n'

    char* token = strtok(unos, " ");
    while (token != NULL) {
        printf("Reč: %s\n", token);
        token = strtok(NULL, " ");
    }

    return 0;
}

2. Problem sa prelivanjem bafera

Kada se koristi zastarela funkcija gets, dolazi do rizika prelivanja bafera jer funkcija ne ograničava broj učitanih karaktera.

#include <stdio.h>

int main() {
    char ime[10]; 
    printf("Unesite ime: ");
    gets(ime); // Potencijalno prelivanje bafera
    printf("Uneto ime: %s\n", ime);
    return 0;
}

Rešenje: koristiti fgets() umesto gets().

fgets(ime, sizeof(ime), stdin);

Poboljšana verzija koda

#include <stdio.h>
#include <string.h>

int main() {
    char tekst1[10];
    printf("Unesi tekst (do belog znaka):\n");
    scanf("%9s", tekst1);
    printf("Unesena reč: %s\n", tekst1);

    char tekst2[10];
    getchar(); 
    printf("Unesi ceo red teksta:\n");
    fgets(tekst2, sizeof(tekst2), stdin);
    printf("Uneseni tekst: %s\n", tekst2);

    char tekst[] = "Priprema za takmičenje iz programiranja";
    int poz = 12;
    int duzPodstr = 10;

    char podstring[duzPodstr + 1];
    strncpy(podstring, tekst + poz, duzPodstr);
    podstring[duzPodstr] = '\0';
    printf("Izdvojeni podstring: %s\n", podstring);

    return 0;
}

Određivanje dužine teksta

char tekst[] = "Priprema za takmičenje iz programiranja";
int duzina = strlen(tekst);
printf("Dužina teksta je %d\n", duzina);

Izdvajanje dela teksta iz teksta (Izdvajanje podstringa)

Deo teksta se može izdvojiti iz celog teksta tako što se, upotrebom petlje, prolazi kroz niz podataka tipa char od pozicije u tekstu odakle treba izdvojiti podstring, pa sve do krajnje željene pozicije. Tada se tekući znak dodaje u novi niz char podataka, tj. u podstring.

Primer 4: Izdvajanje podstringa

Neka je zadat tekst: "Priprema za takmičenje iz programiranja". Izdvojiti deo teksta od pozicije 12, dužine od 10 karaktera i ispisati ga na ekranu.

Rešenje sa petljom

#include <stdio.h>
#include <string.h>

int main()
{
    char tekst[] = "Priprema za takmičenje iz programiranja";
    int duzina = strlen(tekst);
    int poz = 12; // podstring počinje od pozicije 12
    int duzPodstr = 10;

    char podstring[duzina];
    for (int c = poz, i = 0; c <= poz + duzPodstr; c++, i++) {
        char ch = tekst[c];
        podstring[i] = ch;
    }
    podstring[duzPodstr] = '\0'; // terminator stringa
    printf("%s\n", podstring);

    return 0;
}

Pozicija c predstavlja poziciju tekućeg karaktera unutar zadatog teksta, a i je pozicija tekućeg elementa u nizu podstring.

Rešenje pomoću funkcije strncpy()

Zadatak je moguće rešiti i pomoću funkcije strncpy() iz zaglavlja <string.h>. Ova funkcija kopira deo jednog stringa u drugi, koji je po dužini manji ili jednak prvom.

#include <stdio.h>
#include <string.h>

int main()
{
    char tekst[] = "Priprema za takmičenje iz programiranja";
    int duzina = strlen(tekst);
    int poz = 12; // podstring počinje od pozicije 12
    int duzPodstr = 10;

    char podstring[duzina];
    strncpy(podstring, tekst + poz, duzPodstr);
    podstring[duzPodstr] = '\0'; // dodavanje terminatora
    printf("%s\n", podstring);

    return 0;
}

Parametri funkcije strncpy():

• 1. parametar – odredište (podstring koji treba dobiti)
• 2. parametar – pokazivač na znak u polaznom tekstu od pozicije poz
• 3. parametar – dužina podstringa

➡ Ostale funkcije iz zaglavlja <string.h> možete pogledati ovde: cplusplus.com/reference/cstring/

Rešenje sa posebnom funkcijom

Još bolji pristup je da se napravi posebna funkcija za izdvajanje podstringa, koju možemo pozivati više puta za različite delove teksta.

#include <stdio.h>
#include <string.h>

void izdvojiPodstring(char* izvor, char* cilj, int poz, int duzina) {
    strncpy(cilj, izvor + poz, duzina);
    cilj[duzina] = '\0'; // dodavanje terminatora
}

int main()
{
    char tekst[] = "Priprema za takmičenje iz programiranja";

    char pod1[20];
    char pod2[20];

    // Izdvajamo deo od pozicije 12 dužine 10
    izdvojiPodstring(tekst, pod1, 12, 10);
    printf("Podstring 1: %s\n", pod1);

    // Izdvajamo deo od pozicije 0 dužine 9
    izdvojiPodstring(tekst, pod2, 0, 9);
    printf("Podstring 2: %s\n", pod2);

    return 0;
}

Ova funkcija izdvojiPodstring() je univerzalna i može se koristiti za izdvajanje bilo kog dela teksta, što čini kod preglednijim i fleksibilnijim.

Pretraga dela teksta unutar većeg teksta

Često je potrebno ispitati da li se neka reč ili neki tekst nalazi u zadatom tekstu i, ako se nalazi, pronaći na kojim pozicijama. Sledeći primer pokazuje jedan način da se ovo uradi.

Primer 5: Pretraga stringa

Proveriti da li i na kojim pozicijama se zadate reči (ana i pera) nalaze u datom tekstu. Ispisati koliko puta se ponavljaju i na kojim pozicijama, ili ispisati "nije se pojavila" ako se reč ne nalazi u tekstu.

Linearna pretraga za jednu reč

Jedan način je korišćenjem linearne pretrage: prolazi se kroz kompletan tekst znak po znak i poredi se tekući znak sa prvim znakom reči koja se traži. Ako se naiđe na podudaranje prvog znaka, proveravaju se i ostali znakovi. Ako svi znakovi reči odgovaraju, konstatuje se pozicija početka podstringa u tekstu.

#include <stdio.h>
#include <string.h>

int main()
{
    char tekst[] = {'a','n','a','v','o','l','i','M','i','l','o','v','a','n','a','\0'};
    char rec1[] = "ana";
    int brPoj = 0;
    int duzTeksta = strlen(tekst);
    int duzReci = strlen(rec1);
    int poz1 = -1;
    int pronasao = 0;
    int j = 0;

    for(int i = 0; i < duzTeksta; i++) {
        char chT = tekst[i];
        char ch = rec1[j];

        if(!pronasao && chT != ch) {
            continue;
        }
        else if(!pronasao && chT == ch) {
            pronasao = 1;
            poz1 = i;

            while(chT == ch && i < duzTeksta && j < duzReci) {
                i++;
                j++;
                chT = tekst[i];
                ch = rec1[j];
            }

            if(j == duzReci) {
                pronasao = 0;
                j = 0;
                brPoj++;
                printf("Pronadjena na %d poz\n", poz1);
            }
            else {
                pronasao = 0;
                j = 0;
            }
        }
    }

    if(brPoj > 0) {
        printf("Rec se pojavila %d puta u tekstu\n", brPoj);
    } else {
        printf("Ne\n");
    }

    return 0;
}

U prethodnom kodu se pretraga izvršava samo za reč "ana", a ne za "pera". U sledećem primeru se koristi dvodimenzioni niz reči i posebna funkcija za pretragu koja vraća poziciju ili -1 ako reč nije nađena.

Pretraga više reči pomoću funkcije

#include <stdio.h>
#include <string.h>

// Funkcija koja vraća poziciju reči u tekstu, ili -1 ako nije pronađena
int pozicijaUTekstu(int poz, char txt[], char rec[]) {
    int duzTeksta = strlen(txt);
    int duzReci = strlen(rec);
    int pronasao = 0;

    for(int i = poz + 1, j = 0; i < duzTeksta; i++) {
        char chT = txt[i];
        char ch = rec[j];

        if(!pronasao && chT != ch) {
            continue;
        }
        else if(!pronasao && chT == ch) {
            pronasao = 1;
            poz = i;
            while(chT == ch && i < duzTeksta && j < duzReci) {
                i++;
                j++;
                chT = txt[i];
                ch = rec[j];
            }
            if(j == duzReci) {
                break;
            } else {
                pronasao = 0;
                j = 0;
                if(i >= duzTeksta) {
                    poz = -1;
                    break;
                }
            }
        }
    }
    return poz;
}

int main() {
    char tekst[] = {'a','n','a','v','o','l','i','M','i','l','o','v','a','n','a','\0'};
    char rec[2][10] = {"ana", "pera"};
    int brPoj = 0;
    int poz = -1;

    for(int i = 0; i < 2; i++) {
        do {
            poz = pozicijaUTekstu(poz, tekst, rec[i]);
            if(poz != -1) {
                brPoj++;
                printf("Rec %s Pronadjena na %d poz\n", rec[i], poz);
            }
        } while(poz != -1);

        if(brPoj > 0) {
            printf("Rec %s se pojavila %d puta u tekstu\n", rec[i], brPoj);
        } else {
            printf("Rec %s se nije pojavila u tekstu nijednom\n", rec[i]);
        }
        brPoj = 0;
        poz = -1; // resetuje poziciju pre prelaska na sledeću reč
    }

    return 0;
}

U ovom kodu:

• Funkcija pozicijaUTekstu() traži zadatu reč unutar teksta.
• Ako se reč pronađe, vraća poziciju njenog prvog karaktera; inače vraća -1.
• Glavna funkcija main() pretražuje sve reči iz dvodimenzionog niza rec i ispisuje rezultate.

Pretraga reči u tekstu – logika i optimizacija

U glavnoj funkciji (main) je zadat dvodimenzionalni niz znakova sa rečima za pretragu i definisani su:

• tekst za pretragu,
• početna pozicija inicijalizovana na -1,
• broj pojavljivanja (brPoj), čija je početna vrednost nula.

U do-while petlji poziva se funkcija pozicijaUTekstu(), kojoj se prosleđuju: pozicija, tekst i reč za pretragu. Funkcija vraća prvu poziciju veću od prethodno pronađene na kojoj se nalazi reč, ili -1 ako reč nije pronađena.

Objašnjenje logike

Zašto se koristi pronasao: Promenljiva pronasao signalizira trenutak kada se prvi znak reči poklapa sa znakom u tekstu. Ona omogućava praćenje početka potencijalnog podudaranja i prelazak na detaljnije poređenje narednih znakova.

Kako funkcioniše upoređivanje: Kada se otkrije podudaranje prvog znaka, algoritam koristi petlju za poređenje narednih znakova. Ako se svi znakovi poklope, reč je pronađena. Ako se pojavi razlika, algoritam se resetuje i nastavlja pretragu.

Optimizacija algoritma

Alternativna metoda: KMP algoritam (Knuth-Morris-Pratt). KMP koristi preprocesiranje reči za kreiranje "prefix-suffix" tabele, što omogućava preskakanje nepotrebnih poređenja, značajno ubrzavajući pretragu, posebno za velike tekstove i česte ponavljajuće šablone.

Problemi sa memorijom i dinamička alokacija stringova u C-u

Nepravilno rukovanje stringovima može dovesti do curenja memorije ili prepunjavanja bafera.

Alokacija i promena veličine stringova

char *str = (char *)malloc(50 * sizeof(char));
if (str == NULL) {
    printf("Alokacija memorije nije uspela");
    return 1;
}

str = (char *)realloc(str, 100 * sizeof(char));

Izbegavanje prepunjavanja bafera

strncpy(str, "Siguran string", 49);
str[49] = '\0';  // Osigurajte završni null karakter

Oslobađanje memorije

free(str);
str = NULL;

Napredni primer: Dinamička konkatenacija stringova

Primer funkcije koja dinamički spaja stringove:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char *concat(const char *s1, const char *s2) {
    size_t len1 = strlen(s1), len2 = strlen(s2);
    char *result = (char *)malloc((len1 + len2 + 1) * sizeof(char));
    if (!result) {
        printf("Alokacija memorije nije uspela");
        exit(1);
    }
    strcpy(result, s1);
    strcat(result, s2);
    return result;
}

int main() {
    char *pozdrav = concat("Zdravo, ", "Svete!");
    printf("%s\n", pozdrav);
    free(pozdrav);
    return 0;
}

U ovom primeru:

• malloc kreira memoriju za spojene stringove.
• strcpy kopira prvi string, strcat dodaje drugi.
• free oslobađa memoriju nakon korišćenja, čime se sprečava curenje memorije.