Programiranje u C-u - od svega pomalo

dakle

#include <stdio.h>

void main()

{

float andrija;

float ivica;

float josip;

delta_calcInverse( neki broj, neki broj, neki broj, &andrija, &ivica, &josip);

printf("\n%.2f %.2f %.2f", andrija, ivica, josip);

}

će ispisati vrijednosti koje je vratila funkcija delta_calcInverse? bitno mi je da znam što (nije bitno što funkcija radi, ali je bitno da znam da će mi vratiti izračunati float) i kako će mi vratiti

to inače ide na arduino mikrokontroler i iako ispada da nemam pojma, samo pokazivače nisam nikada volio

Puno hvala =DD

Ne znam, to je prilično trivijalno (ovo što sam ponudio kao potencijalno rješenje) - trebalo bi raditi bez greške.

Mogao bi pitati na Stack Overflow-u, sigurno su daleko upućeniji.

Kako ti izgleda prototip te funkcije delta_calcForward?

Ti njoj ovdje šalješ dereferencirane float pointere koji pokazuju na integere, čudno mi to izgleda.

Ali, ako radi kako ti kažeš, sve pet.

Ne znam na kojem si compileru i u kojem modeu kompajlaš, ali ova tri desna parametra su ti reference iz C++, to ne postoji ni u ANSI C-u ni u C99.

Meni javlja milijun grešaka ako ovakvo nešto pokušam u VS-u.

To mi je pomalo preegzotično, nisam baš upućen.

Možda on dodaje nekakvu dodatnu funkcionalnost.

da, arduino je mikrokontroler na bazi atMega čipova

Inače imamo ovdje politiku izbjegavanja posluživanja gotovih rješenja ali hajde, ako je za pozitivnu ocjenu i to još u srednjoj školi, zašto ne? Očito se neće baviti programiranjem profesionalno...

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

int main()
{
    int korisnikov_broj=0, zamisljeni_broj, n=0;
   
    srand(time(NULL));
    zamisljeni_broj=rand()%10+1;
   
    printf("Zamislio sam broj od 1 do 10\n"
           "Imas tri pokusaja da pogodis koji je to broj.\n\n");
          
    while (0xB00B5)
    {
        scanf("%d", &korisnikov_broj);
       
        if (korisnikov_broj > zamisljeni_broj)
            printf("Broj je prevelik\n\n");
        else if (korisnikov_broj < zamisljeni_broj)
            printf("Broj je premalen\n\n");
        else if (korisnikov_broj == zamisljeni_broj)
        {
            printf("Cestitam pogodio si!\n\n");
            break;
        }
       
        if (++n==3)
        {
            printf("Vise srece drugi puta...\n\n");
            break;
        }
    }
       
    system("pause");
    return 0;
}

  Dakle ti si tu pokušao implementirati rekurzivno traženje na puta u matrici? Taj način ti se zove DFS(Depth First Search) i praktički se svodi na isprobavanje svih mogućih puteva, pa stoga algoritam nije brz. Algoritam se može implementirati na više načina. Jedan način je da koristiš rekurzivne funkcije, i ti u stvari tada koristiš sistemski stack jer svi ti pozivi funkcija pohranjuju na sistemski stack. Buduci da je meni cilj pokazati kako algoritam funkcionira, ja ovdje odstupam od odredenih stvari koje ti koristis, no mislim da ces ga lako prilagoditi.

int min_cost = 10000000;
int shortest_path[num_rows], temp_path[num_rows];
void find_shortest_path(int row, int column, int path_cost){
      if(row < 0 || column < 0 || row >= num_rows || column >= num_columns)
              return;

      temp_path[row] = column;
      path_cost += matrix[row][column];
     
      if(row == num_rows - 1){
              if(min_cost > path_cost){
                      min_cost = path_cost;
                     
                      int i;
                      for(i = 0; i < num_rows; i++)
                              shortest_path[i] = temp_path[i];
              }
              return;
      }

      find_shortest_path(row+1, column, path_cost);
      find_shortest_path(row+1, column+1, path_cost);
      find_shortest_path(row+1, column-1, path_cost);
}

I funkciju find_shortest_path bi pozivao ovako:

int i;
      for(i = 0; i < num_columns; i++){
              find_shortest_path(0, i, 0);
      }

Varijabla min_cost pohranjuje ukupnu vrijednost najkraćega puta. Nju postavimo na neku veliku vrijednost za koju smo sigurni da je veca od svake moguce duzine pute. Polja shortest_path i temp_path služe za pohranjivanje najkraćega puta. Budući da se iz jednoga reda može preći samo u sljedeći(dolje, dolje-desno, dolje-ljevo), onda u svakome redu put može proći kroz samo jedno polje. I mi put pamtimo tako da da za svaki red pamtimo stupac kroz koji je red prolazio. shortest_path zapisuje najkraci put, a temp_path zapisuje trenutni put.

Ako smo dosli do zadnjega reda, onda provjeravamo je li trenutni put najkraci. Ako je trenutni put najkraci, onda to zapisemo, i prepisemo polje temp_path u polje shortest_path, zato jer polje temp_path opisuje put do trenutnog elementa.

Ako to nije zadnji red, onda jednostavno pozovemo funkciju find_shoretst_path za donji, donji-lijevi i donji-desni element.

Umjesto koristenja sistemskoga stacka, mozemo koristiti i neki stack koji smo sami implementirali. Onda cemo ono sto smo gore stavljali kao argumente funkcije jednosta pohranjivati u taj stack. Ja u ovome rjesenju necu koristiti tvoje funkcije, vec cu koristiti svoje tri funkcije za stack:

int stack[10000000], stack_pos = 0;
void stack_add(int value){
      stack[stack_pos] = value;     
      stack_pos++;
}
int stack_pop(){
      stack_pos--;
      return stack[stack_pos];
}

int stack_empty(){
      if (stack_pos == 0)
              return 1;
      return 0;
}

Dakle ovdje imas samo jedan stack, dok ih je kod tvojih funkcija moguce imati koliko god hoces. Svjestan da je ovo jako ograniceno rjesenje i da pri velikim matricama nece raditi, no buduci da je cilj pokazati nacin na koji funkcionira algoritma mislim da ih mogu koristiti. Ti mozes to bez problema prilagoditi na svoje funkcije (kao i cijeli algoritam).

E algoritam izgleda ovako:

      int min_cost = 10000000;
      int shortest_path[num_rows], temp_path[num_rows];

      int i;
      for(i = 0; i < num_columns; i++){
              stack_add(0);
              stack_add(i);
              stack_add(0);
      }     
     
      while(!stack_empty()){
              int path_cost = stack_pop();
              int column = stack_pop();
              int row = stack_pop();

              if(row < 0 || column < 0 || row >= num_rows || column >= num_columns)
                      continue;

              temp_path[row] = column;
              path_cost += matrix[row][column];
             
              if(row == num_rows - 1){
                      if(min_cost > path_cost){
                              min_cost = path_cost;
                             
                              int i;
                              for(i = 0; i < num_rows; i++)
                                      shortest_path[i] = temp_path[i];
                      }
                      continue;
              }
              stack_add(row+1);
              stack_add(column);
              stack_add(path_cost);

              stack_add(row+1);
              stack_add(column+1);
              stack_add(path_cost);

              stack_add(row+1);
              stack_add(column-1);
              stack_add(path_cost);

      }

Algoritam je prakticki isti kao onaj gore, samo sto umjesto rekurzivnih funkcija koristimo stack. Tamo smo kao argumente funkcija imali   red, stupa i duljinu puta, a ovdje te argumente tim redom dodajemo u stack, i onda ih obrnutim redosljedom vadimo zato jer stack LIFO struktura.

Ako te zanima kako se ovo moze brze napraviti, mogu ti i takav algoritam napisati.

Sad mi je jasno na što si ti mislio kad si rekao da algoritam treba implementirati pomoću stacka.

Ono što ti on nudi je vrlo slično ono što sam ja napisao(ono prvo gdje se koristi sistemski stack), ali samo je razlika u tome što on za pohranu puta koristi strukturu stack, a ja obično polje. Ono što je kod njega answer, kod mene je  shortest_path, a ono što je kod njega  temporary kod mene je  temp_path.

Temporary ti je trenutni put. Kada ti ideš iz jednoga reda u drugi, ti na vrh stacka  temproray staviš u koji si stupac otišao(dolje, dolje-desno, dolje-lijevo). I tako kada dođeš do kraja,  u  temporary se nalazi cijeli put od početka, pa do toga mjesta. Ako je put jeftiniji ti taj put zapamtiš tako što ga prepišeš u  answer. Sada kada si došao do vrha, onda se vraćaš, i onda usporedno s time brišeš stupce sa  temporary jer viši nisi u njima.

  To odlična ideja, i na taj način možeš dosta vremena uštediti u određenim slučajevima.

rijec[i] ili *(rijec + i)

Jeli znate neki IDE koji kreira sučelje drag and drop metodom u GTK+-u?

Ima li možda neki eclipse plugin za to,ili plugin u nekom drugom IDE-u?

Kako doći do designera u anjuti?

Kako povezati taj xml sa C kodom?

Draže bi mi bilo da ima nešto sa native c kodom.

Mozes ti i hard kodirati GTK, ali ne preporucam jer nije modularno.

http://zetcode.com/tutorials/gtktutorial/

Ovako je nesto sporije (jer program prije pokretanja treba ucitati XML shemu), ali s obzirom na danasnju racunalnu snagu, cak i prosjecnog racunala to nije problem, a puno dobivas kod odrzavanja koda.

https://live.gnome.org/Glade/Tutorials

Modularnost na prvom mjestu. Uci se pravilno. Ovo drugo nema smisla iz vise razloga, prebaci se na C++ ako zelis OO paradigmu.