[j.....n]

#cpp #programowanie

Kolejne problemy początkującego programisty.

Muszę napisać rekurencyjną funkcję maximum. Mam tablicę i ilość jej elementów. Całość ma być zrobiona na wskaźnikach.

Na chwilę obecną doszedłem do tego:

int
```**```
* maksimum ( 
```**```
int
```**```
 N, 
```**```
int
```**```
 *t ) {   

    
```**```
if
```**```
 ( N == 0 )

        
```**```
return
```**```
 t + 0;

    
```**```
if
```**```
 ( *( t + N ) > *( maksimum ( N - 1, t )) ) 

        
```**```
return
```**```
 t + N;

}

```Wywołanie dla tablicy int t[] = {1,2,3,4,5,6};```

cout << *maksimum ( 6, t );

Nie mam pomysłu, jak to ruszyć inaczej. Czy byłby ktoś tak miły i choć trochę mnie nakierował?

[wytrzzeszcz]

@jedentrylion: ale dlaczgo zwracasz wksaźnik chcesz otrzymać najwiekszą wartość wiec powinneś zwracać int z nią

[j.....n]

@wytrzzeszcz: chce zwrócić wskaźnik najwyższego elementu.

[wytrzzeszcz]

co mam zwrócić gdy aktualny jest jednak < od policzonego rekurencyjnie?

[E.....L]

... i dlaczego warto dodać jedną zmienną pomocniczą w trakcie, żeby zmniejszyć liczbę pewnych wywołań?

[kowad]

@jedentrylion: sprawdź co będzie jak dodasz na końcu

return maksimum ( N - 1, t );

zasadniczo przy kompilacji masz teraz

warning C4715: 'funkcja' : not all control paths return a value

co oznacza

"Ostrzeżenie to informuje, że funkcja nie uwzględnia wszystkich możliwych ścieżek przejścia, co w konsekwencji może dla pewnych danych spowodować niezdefiniowane zachowanie kodu"

czyli tak jak mówi @wytrzzeszcz zapomniałeś dodać ostatniej opcji

[sylwke3100]

@jedentrylion: Tak swoją drogą nie lepiej przekazywać zmienną przez referencje?

[j.....n]

@wytrzzeszcz: Dziękuję : )

@EssePL: Mam nadzieję, że o to chodziło.

int
```**```
* maksimum ( 
```**```
int
```**```
 N, 
```**```
int
```**```
 *t ) {   

    
```**```
if
```**```
 ( N == 0 )

        
```**```
return
```**```
 t;

    
```**```
int
```**```
* zm = ( maksimum ( N - 1, t ));

    
```**```
if
```**```
 ( *( t + N ) > *zm ) 

        
```**```
return
```**```
 t+N;

    
```**```
else
```**```
 
```**```
if
```**```
 ( *( t + N ) < *zm ) 

        
```**```
return
```**```
 zm;

}

[j.....n]

I nawet działa. Chyba. :D

[kowad]

@jedentrylion: ta zmienna zm jest niepotrzebna, dobrze miałeś, no i nie musisz dodawać "else if" bo jak wejdzie do ifa to pójdzie do returna to i tak dalej nie idzie, a jak nie wejdzie to po prostu dajesz 1 linijke z returnem :)

[E.....L]

@jedentrylion: a po co ten else if? Nie wystarczy samo else? ;)

[j.....n]

@kowad: sugerowałem się EssePL

@kowad: @EssePL: a ten elseif to nie wiem XD

[kowad]

@jedentrylion:

@EssePL:

teraz widze, ze w sumie i else i else if jest zle ;) bo nie uwzglednia ze obie strony sa rowne, daj po prostu linijke z returnem ;) to bedzie tak samo jak else if <=

int * maksimum ( int N, int *t ) {   

    if ( N == 0 )

        return (t + 0);

    if ( *( t + N ) > *( maksimum ( N

[E.....L]

Zmienna po to żeby, dwa razy nie liczyć tego samego ;)

[j.....n]

@kowad: = nie muszę chyba, bo zwracać mam pierwszy największy : )

[j.....n]

@kowad: @EssePL: No i jeszcze jeden problem, który nie wiem jak rozwiązać. Ogólnie funkcja operuje na jednym wskazniku za daleko. Jak tego uniknąć?

[E.....L]

@jedentrylion: tzn?

[j.....n]

@EssePL: przy tablicy int t[] = {1,2,3,-1,4,2,6,8}; , wywołaniu cout << *maksimum ( 8, t ); wyrzuca 36. Wydaję mi się, że leci o jeden za daleko.

[E.....L]

u mnie jest 8 :P

https://gist.github.com/anonymous/6bb75eb1e78cbc6d278d

[j.....n]

@EssePL: Twój kod wyrzuca mi '5903216' :D

[j.....n]

@EssePL: jak zmienie w wywołaniu na 7 wyrzuca mi 8 :D

[E.....L]

esse@depot:~/wdi$ gcc -v

(...)

gcc version 4.8.2 (Ubuntu 4.8.2-19ubuntu1)

esse@depot:~/wdi$ gcc maks2.c -o maks2.o

esse@depot:~/wdi$ ./maks2.o

8

esse@depot:~/wdi$

Więc nie wiem dlaczego u Ciebie jest tak :P