[ cobragangsta @ 20.09.2007. 23:28 ] @


Ovo je primer iz zbirke zadataka "C\C++" od Milana Cabarkape glava 15 zad "3 h - drugo resenje".
Dakle donja f-ja brise one clanove liste koji sadrze karakter koji cuva promenjiva E.
Interesuje me zasto (u liniji oznacenoj sa mnogo "??????" ) svaki put kada se nadje "informacija E"
on ponovo definise pokazivac q. delete q bi trebalo samo da oslobodi memoriju na koju pokazuje a ne i pokazivaca q.
Ja bih recimo pokazivac q definisao odmah u drugom redu f-je (POKC pred=NULL,t=L,q) a "dole" samo q=t.

ima li neko odgovor?

Code:

typedef struct cvor
               {
                 char inf;
                struct cvor *sledeci;
               } CVOR;

typedef CVOR* POKC;

...

void brisi_iter (char E, POKC &L)
       {
         POKC pred=NULL,t=L;
         while (t)
                 if (t->inf==E)
                   {
                     POKC q=t;               // ?????????????????????????
                     if (pred)
                        pred->sledeci=t->sledeci;
                        else
                             L=t->sledeci;
                     t->sledeci;
                     delete q;                     // fusnote
                   }
                  else { pred=t;t=t->sledeci;}
           }
                   
     

a druga stvar moglo bi i sa f-jom free umesto delete. pr:
(red: fusnote)
jel' to Cabarkapa nedosleda pa malo C malo C++ (malo 'leba , malo perece :) )?

Code:

void brisi_iter (char E, POKC &L)
       {
         POKC pred=NULL,t=L;
         while (t)
                 if (t->inf==E)
                   {
                     POKC q=t;               // ?????????????????????????
                     if (pred)
                        pred->sledeci=t->sledeci;
                        else
                             L=t->sledeci;
                     t->sledeci;
                     free( q );                     // fusnote
                   }
                  else { pred=t;t=t->sledeci;}
           }

[ karas @ 23.09.2007. 11:45 ] @
Može se promenljiva definisati i odmah na početku funkcije ali smatra se dobrom praksom da se definiše na mestu na kojem će se upotrebiti.
Ne vidi se kako je zauzimao memoriju: ako je koristio new onda treba delete, a ako je malloc() onda naravno free().
[ cobragangsta @ 23.09.2007. 22:41 ] @
Citat:
karas: Može se promenljiva definisati i odmah na početku funkcije ali smatra se dobrom praksom da se definiše na mestu na kojem će se upotrebiti.
Ne vidi se kako je zauzimao memoriju: ako je koristio new onda treba delete, a ako je malloc() onda naravno free().


Ma to je u redu da se promenjva moze definisati bilo gde u programu!
ali on ovde definise promenjivu UNUTAR PETLJE, tako da svaki put kada se udje u petlju ISTA promenjiva se PONOVO DEFINISE
npr:

Code:

...
i=0;
while (i<10)
{
  int p;
  i++;
...
}

ovaj deo koda 10 puta definise promenjivu p
to je isto kada bih je uradio
Code:

...
int p;
int p;
...
int p;
...


Sto se tice drugog dela - zar se moze u C-u koristiti new i delete, zar to nisu naredbe u C++.
Mislim da za C, new i delete, ne postoje!

hvala na trudu ali mi nisi puno pomogao.

Ima li neko da precizno razume pitanje!?
[ uranium @ 24.09.2007. 00:05 ] @
Citat:
cobragangsta:

ovaj deo koda 10 puta definise promenjivu p
to je isto kada bih je uradio
Code:

...
int p;
int p;
...
int p;
...



Ne, situacija je zapravo ekvivalentna sledećem:

Code:

...
{
    int p;
    ...
}
{
    int p;
    ...
}
...
{
    int p;
    ...
}
...


promenljiva p je lokalna za svaki blok (nije vidljiva spolja, a po izlasku iz bloka se i uništava)...

Možda sam malo preterao... ali isprobaj i sledeći primer:

Code:

#include<stdio.h>

int main(){
    int i = 42;
    printf("\n1: i == %d", i);    
    {
        int i = 100;
        printf("\n2: i == %d", i);
    }
    {
        int i = 101;
        printf("\n3: i == %d", i);
        {
            int i = 102;
            printf("\n4: i == %d", i);
            {
                int i = 103;
                printf("\n5: i == %d", i);
            }
            printf("\n4: i == %d", i);
        }
        printf("\n3: i == %d", i);
    }
    printf("\n1: i == %d", i);
    return 0;
}


[ karas @ 24.09.2007. 07:42 ] @
Da, new i delete su C++ operatori, ne postoje u C-u koji isto to regulise preko funkcija malloc() i free()..
Kao sto rece Uranium, promenljiva p je lokalna za blok u kojem se definise. Nalazi se na steku i po zavrsetku bloka uklanja se sa steka. Potpuno je nebitno da li je taj blok u kojem se definise telo funkcije ili petlje. Npr. mozes imati kod tipa
Code:

for (i = 1; i <= 10; i++)
{
  int k = 10;
  {
     int p = 20;
  }
/* ovde se ne vidi p */
}

tj. unutar bloka petlje se definise novi blok (u ovom slucaju bez potrebe) koji definise p. Svaki prolazak kroz petlju i ulazak u taj blok ponovo definise p a po izlasku se unistava. Zato se p ne vidi u ostatku petlje.
[ cobragangsta @ 24.09.2007. 23:53 ] @
Bravo,bravo na preciznim odgovorima.
Zaboravio sam na vidljivost u blokovima. Mislim da se nebih setio da svaki prolaz kroz petlju (u slucaju definisanja unutar iste) kreira blok za sebe a samim tim kreira i unistava promenjivu.
Hvala Uranium & Karas, cista 10-ka za vas!!!
[ mjux @ 06.11.2007. 21:00 ] @
Code:


typedef struct cvor
               {
                 char inf;
                 struct cvor *sledeci;
               } CVOR;

typedef CVOR* POKC;

...

void brisi_iter (char E, POKC &L)
       {
        
         POKC pred=NULL,t=L,tek;
        
         while (t->sledeci!=NULL)
                 
                   if (t->inf==E)
                   {
                           pred=L;
                           while(pred->sledeci!=t)pred=pred->sledeci;
                           pred->sledeci=t->sledeci;
                           free(t);
                           t=pred;
                   }
                    
                   t=t->sledeci;
      }
                     

ili ova varijanta :)