Programowanie - pytania, problemy, przykłady programów

[Thrandir 1]

Dnia 03.12.2013 o 12:23, ziptofaf napisał:

Jak pisałem wielokrotnie - za nazywanie zmiennych ''i'' albo ''j'' to na mojej uczelni
stawiali za to dwóję. Bez dalszego wnikania co i jak.

Tak szczerze powiem, że nazwa "loop1" dla licznika pierwszej pętli mówi dokładnie tyle, co "i". Albo nawet mniej, bo "i" to już tradycyjnie jest licznik pierwszej pętli (a kolejne litery alfabetu to liczniki kolejnych pętli; zresztą, tak jak "t" to tradycyjnie zmienna tymczasowa..), a "loop1" mówi tylko o tym, której pętli tyczy się dana zmienna, nie ujawniając samą nazwą jej funkcji.

Nie żebym się czepiał, ale po prostu- nie ma sensu wpajać komuś swoich nawyków. Rozumiem, zmienne należy nazywać tak, aby mówiły, co robią- bo inaczej intepretacja kodu trwa później wieki (szczególnie, jeżeli ma on kilkaset a nie kilkanaście linijek)- i ten motyw pojawia się chyba na każdej uczelni...

...ale bez przesady. "i" to od zawsze jest licznik, od kiedy ja programuję to zawsze "i", "j", "k" itp robią za liczniki dla fora, i jak mam okazję oglądać programy ludzi z informatyki na EiTI na PW (a zdarza mi się, bo mam tam sporo znajomych)- licznik to zawsze jest "i"/kolejne litery. To nie jest zły nawyk, to jest normalny nawyk. "Loop1" czy coś innego nie jest lepszym zamiennikiem w sensie ogólnym- Ty się do tego przyzwyczaiłeś, bo tego wymagają na Twojej uczelni, ale inne uczelnie wcale nie podchodzą do tego tak radykalnie (a o EiTI powiedzieć, że to zły wydział który ma kiepską informatykę nie można :D) i dla każdego poza absolwentami Twojej uczelni "Loop1" będzie nazwą licznika mniej intuicyjną niż "i" :P

Inna sprawa, że nazywanie innych zmiennych jako "a", "b", "c" czy "w", "h" itp to nie jest dobry pomysł... Zazwyczaj. Bo jak program jest wykomentowany od początku, i mówi np., że będzie obliczał wartość kolejnych wyrazów ciągu, to nazwa "n" dla zmiennej przyjmującej argumenty jest bardzo logiczna. Tak samo jak "x" w przypadku funkcji określonej dla dziedziny szerszej niż naturalne bez zera, czy "y" do przechowywania wartości funkcji. To jest kwestia konwencji, nazwy zmiennych muszą być logiczne- ale bez przesady. W razie czego, dla pewności zostawia się przecież komentarze...

A przy okazji tematu pisania we względnie czystym C- mnie na przykład (niestety) obecnie do tego przymuszają. Ostatnie trzy lata pisałem w C++ (nie jakoś bardzo ambitnie, ale zawsze), a teraz się okazuje, że praktycznie cała Politechnika Warszawska wymaga pisania w samym C, najchętniej bez naleciałości związanych ze standardem C99. Niby nic, ale jednak za każdym razem jest ten moment zawahania, gdy pisze się fora i nie można w nim deklarować licznika... :c
Ma to oczywiście swoje logiczne uzasadnienie, ale i tak, przyzwyczajenia to druga natura człowieka :P

[Erton 0]

Ja jestem z informatyki z EITI.

I oczywiście, że nazywam zmienne w pętlach "i", "j" i tak dalej. To jest w dobrych praktykach programistycznych tak samo jak wcięcia w blokach czy pisanie virtual nawet jeśli nie trzeba. Jak jest i czy j to każdy ogarnie, że to zmienna iterująca.

Chociaż nie da się ukryć, że czasem lubię sobie trzasnąć nazwę funkcji typu "takeFromOneBoxToAnother()". I ch*j, i będę ją wywoływał :P Przynajmniej mam samodokumentujący się kod.

[Thrandir 1]

Dnia 03.12.2013 o 21:57, Erton napisał:

Ja jestem z informatyki z EITI.

O! Ja sąsiad, MELowiec, ale znajomych mam na EiTI sporo, z czego znam dobre 50% damskiej części pierwszego roku (acz biorąc pod uwagę strukturę płciową, która na EiTI od dość dawna kształtuje się we względnie podobny sposób to nie jest wielki wyczyn :D)

Dnia 03.12.2013 o 21:57, Erton napisał:

I oczywiście, że nazywam zmienne w pętlach "i", "j" i tak dalej. To jest w dobrych praktykach
programistycznych tak samo jak wcięcia w blokach czy pisanie virtual nawet jeśli nie
trzeba. Jak jest i czy j to każdy ogarnie, że to zmienna iterująca.

Zgadzam się. "i" to jest licznik, i tyle. To każda nazwa inna niż "i", "j" itd mówi mniej o tym, od czego dana zmienna jest, a nie odwrotnie :P

Dnia 03.12.2013 o 21:57, Erton napisał:

Chociaż nie da się ukryć, że czasem lubię sobie trzasnąć nazwę funkcji typu "takeFromOneBoxToAnother()".
I ch*j, i będę ją wywoływał :P Przynajmniej mam samodokumentujący się kod.

:D

[ziptofaf 2]

/.../

W zasadzie masz rację, może lekko przesadzam. Ale często kod początkującego programisty wygląda tak:

int a,b,c,e,i,j,k;
(blablabla)
for (i=0; i<10; i++)
{
blablabla;
}

Znając życie pewnie potem ktoś zapomni o wyzerowaniu swojej zmiennej i, zrobi sobie kolejną pętelkę i będzie się dziwić że nie działa. Samemu na PWR widziałem takie rzeczy że naprawdę nie dziwię się wykładowcom iż nie lubią krótkiego nazewnictwa zmiennych. Choć faktem jest że w późniejszych okresach już raczej sprawdzają czy to co piszesz działa a nie w jaki sposób.

I oczywiście skłamałbym mówiąc że samemu nie korzystam nigdy ze zmiennych o krótkim nazewnictwie, także w aplikacjach komercyjnych (choć mimo wszystko w c++ jest to o tyle prostsze że można sobie zmienną zadeklarować i zainicjować bezpośrednio w pętli a potem i tak zostanie wyrżnięta z pamięci), po prostu zwracam uwagę na to żeby ich liczbę ograniczać do rozsądnego poziomu. A nie jak w poprzednim przykładzie do którego się odnosiłem - mamy 3 zmienne i,j, w oraz kilka printfów. Nie dziwię się że ktoś się w tym pogubił zwłaszcza jeśli języka dobrze nie zna - paradoksalnie im krótszy kod, tym bardziej będę narzekać na jego kiepską budowę - jak mi w bibliotece na kilkaset linii ułatwiasz sobie pracę używając tego typu tymczasowych zmiennych to ok - i tak żeby ją zaimplementować w swoim programie musiałbyś wiedzieć jak działa linker, pliki nagłówkowe itd.
Ale jeśli piszesz kod który ma zrozumieć początkujący to możesz chociaż zamienić literkę w na wiersz. W końcu nie piszesz tego dla siebie.

Dnia 03.12.2013 o 21:52, Thrandir napisał:

W razie czego, dla pewności zostawia się przecież komentarze...

A co to takiego? :D Komentarze to jedna z tych rzeczy które widuję tylko w ładnych bibliotekach jak Boost czy Qt. 90% pozostałego kodu jaki widzę w necie to gotowce które po prostu robią coś i czasem nawet zostanie wyjaśnione co.
Choć masz rację - od każdej zasady są wyjątki. Jak chcesz to możesz sobie połowę programu załatwić choćby przeciążając operatory i właśnie wtedy wyda się to najbardziej naturalne dla użytkownika. Ja po prostu jestem przeciwnikiem programowania kwalifikującego się do pierwszego miejsca na http://www.ioccc.org/ ;)

[Gumisiek2 2]

Na uczelni kazali nam przesiąść się z C++ na C#, a ja mam z tym problem już na samym początku. Chciałem napisać prosty program, który dodawałby dwie liczby do siebie, ale nie mogę sobie z tym poradzić.

Kod w C++:

{
int a,b,suma;
cout<<"Podaj a: ";
cin>>a;
cout<<"Podaj b: ";
cin>>b;
suma = a + b;
cout<<"Suma wynosi: "<<suma;
}

Kod w C#:

{
int a = 0, b = 0, suma = 0;
Console.WriteLine("Podaj a: ");
Console.Read(a);
Console.WriteLine("Podaj b: ");
Console.Read(b);
suma = a + b;
Console.WriteLine("Suma tych liczb wynosi " + suma);
Console.ReadKey();
}

Co robię źle? Kompilator wywala mi błąd przy Console.Read(a) o treści "No overload for method ''Read'' takes 1 arguments".

[CatInABag 0]

Dnia 04.12.2013 o 18:25, Gumisiek2 napisał:

Co robię źle? Kompilator wywala mi błąd przy Console.Read(a) o treści "No overload for
method ''Read'' takes 1 arguments".

Widocznie nie ma metody Console.Read przyjmującej 1 argument. Spróbuj a = Consol.Read().

[Gumisiek2 2]

Próbowałem, też wywala błąd. Udało mi się już ogarnąć ten problem, jednak nie wiem właściwie, co takiego zrobiłem :P Byłbym wdzięczny, gdyby ktoś wytłumaczył mi sens pisania "a = int.Parse(Console.ReadLine());" oraz napisał, czy nie ma innego sposobu na wczytanie danej zmiennej.

{
int a = 0, b = 0, suma = 0;
Console.WriteLine("Podaj a: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("Podaj b: ");
b = int.Parse(Console.ReadLine());
suma = a + b;
Console.WriteLine("Suma tych liczb wynosi " + suma);
Console.ReadKey();
}

[CatInABag 0]

Generalnie Consol.ReadLine() zwraca stringa. Twoje zmienne a i b to inty, więc musisz to co zwraca ReadLine() skonwertować do inta.

Proponowałbym użycie metody TryParse przykład:

if(!int.TryParse(Console.ReadLine(), out a))
Console.WriteLine("Zły format");

Na chwilę obecną aplikacja Ci się wywali jak ktoś poda coś innego niż liczba, więc warto się przed tym zabezpieczyć :)

[Gumisiek2 2]

Więc ""a = int.Parse(Console.ReadLine());" konwertuje mi zmienną a do typu integer i czeka na wprowadzenie jej przez użytkownika, tak? W takim razie mam jeszcze jedno pytanie. Napisałem sobie program, zapisuję go, wszystko jest OK. Po jakimś czasie otwieram go i niezależnie od tego, czy chcę wprowadzić zmiany, czy nie, opcja "Debug" jest zablokowana. Jedynym wyjściem jest skopiowanie programu i stworzenie nowego projektu, ale takie rozwiązanie byłoby akceptowalne 30 lat temu. Dlaczego tak się dzieje i czy można temu jakoś zapobiec? Z góry dziękuję za odpowiedzi ;-)

[CatInABag 0]

Dnia 04.12.2013 o 19:06, Gumisiek2 napisał:

Więc ""a = int.Parse(Console.ReadLine());" konwertuje mi zmienną a do typu integer i
czeka na wprowadzenie jej przez użytkownika, tak?

Użycie Console.ReadLine() powoduje pobranie danych wprowadzonych przez użytkownika. To zwraca stringa i to on jest konwertowany do inta i przypisany do zmiennej a. Można to zapisać tak:

string dane = Console.ReadLine();
int a = int.Parse(dane);

Czyli nie konwertujesz zmiennej a tylko wartość zwracaną przez Console.ReadLine().

Z tym drugim to nie wiem o co może chodzić, nie miałem nigdy czegoś takiego :(

[Thrandir 1]

Mam pytanie: jak poprawnie deklarować i wywoływać funkcje od tablic w C?

W sensie, ja dawno temu nauczyłem się (na gruncie C++) składni wyglądającej mniej-więcej:

int funkcja (double tablica[], double.... )

i potem przy jej użyciu:

y=funkcja (fajna_tablica, cośtam, cośtam....)


podczas gdy ostatnio na ćwiczeniach z infy pojawiło się coś wyglądającego mniej-więcej jak:

int funkcja (double *tablica, double... )

y= funkcja (fajna_tablica, cośtam, cośtam...)


I tu pytanie: czy mam rozumieć, że pierwsza wersja jest bardziej związana z C++? Z tego, co pamiętam w ten sposób można używać tylko tablic jednowymiarowych... Czy są tu jeszcze jakieś ogarniczenia (zastanawia mnie na przykład, czy ten sposób zadziała z tablicą dynamiczną, ale to zaraz sprawdzę na własną rękę :P)?

Pytanie nie jest bardzo istotne, ot- czysta ciekawość, bo zawsze z przyzwyczajenia uzywałem tab[], i teraz mnie jakoś naszło (szczególnie, że na mój nos wersja ze wskaźnikiem może być tą bardziej pożądaną, żeby nie powiedzieć- "profesjonalną").

[Volvox 1]

Słabo u mnie z C, ale czy obje wersje nie są takie same? (tj. przekazanie wskaźnika do pierwszego elementu tablicy)
No i chyba można wielowymiarowe tablice też przekazywać, bo przecież to praktycznie to samo co zwykła. I czy w C były w ogóle tablice dynamiczne, bo nie przypominam sobie takich rzeczy.

[Dregorio 0]

/.../
Były dynamiczne(malloc). Co do funkcji, to jedno i drugie poprawne. Wskaźnik na tablice to tak naprawdę tab[0] czyli pierwszy element tablicy.

[Thrandir 1]

Dnia 06.12.2013 o 01:10, Volvox napisał:

Słabo u mnie z C, ale czy obje wersje nie są takie same? (tj. przekazanie wskaźnika do
pierwszego elementu tablicy)

Cóż, że tak powiem- to jest istota mojego pytania :D
Względnie dokładnie rozumiem mechanizm działania wywołania z użyciem wskaźnika, ale zwyczajnie nie wiem, czy podanie tego w wersji tab[] również działa na identycznej zasadzie. Efekt jest identyczny (we wszystkich przypadkach, z jakimi się spotkałem), ale może to nie jest dokładnie to samo, bo np. są jakieś wyjątki/ jest to interpretowane inaczej, chociaż wizualny efekt zazwyczaj jest taki sam. Nie jest to jednak jakieś bardzo istotne pytanie, ot- ciekawi mnie to, chociaż nigdy żadnych problemów pod tym względem nie miałem.

Dnia 06.12.2013 o 01:10, Volvox napisał:

No i chyba można wielowymiarowe tablice też przekazywać, bo przecież to praktycznie to
samo co zwykła.

Przekazanie wielowymiarowych w wersji double funkcja(double tab[][][]) zwyczajnie nie działa (muszą być tam wpisane wymiary, aby poszło, ew. pierwszy nawias może być pusty, ale reszta- wypełniona).
Z pierwszym pustym nawiasem kwadratowym- jasne, ale przy wiekszej liczbie się sypie. Między innymi to skłoniło mnie do zadania tego pytania, czy wersja z pustym nawiasem różni się czymś (np. w mechanizmie działania/ może ta wersja z pustym nawiasem jest "chałupnicza" i mało formalna, podczas gdy ta jawnie wykorzystująca wskaźnik jest bardziej pożądana).

Dnia 06.12.2013 o 01:10, Volvox napisał:

I czy w C były w ogóle tablice dynamiczne, bo nie przypominam sobie takich
rzeczy.

Tak jak napisał Dregorio, jest malloc, nawet działa.

[Thrandir 1]

Dnia 06.12.2013 o 01:14, Dregorio napisał:

/.../
Były dynamiczne(malloc). Co do funkcji, to jedno i drugie poprawne. Wskaźnik na tablice
to tak naprawdę tab[0] czyli pierwszy element tablicy.

Czy mam rozumieć, że tab[] to jest dokładnie to samo, co tab[0]? Bo jak wskaźnik na tablicę działa, to wiem, ale w sumie to nie przyszło mi do głowy, że tab[] jest interpretowane identycznie jak tab[0], bo pominięcie zera nic nie zmienia, a przecież tab[0] to wskaźnik. Jeżeli tak jest, to ma to sens i rozumiem już zasadę działania :D

[Boguslav4 0]

Dnia 03.12.2013 o 21:52, Thrandir napisał:

> /.../
Ma to oczywiście swoje logiczne uzasadnienie, ale i tak, przyzwyczajenia to druga natura
człowieka :P

Myślę, choć nie jestem tego pewien, że nazewnictwo zmiennych utrwaliło się z powiązań z matematyką. W większości twierdzeń mamy użyte i,n,x,y i często spotyka się je w programach. Oczywiście czasem ktoś nazwie wynik "wynik", ale większość nazwie go "x"...

[ziptofaf 2]

Dnia 06.12.2013 o 20:18, Thrandir napisał:

Czy mam rozumieć, że tab[] to jest dokładnie to samo, co tab[0]? Bo jak wskaźnik na tablicę
działa, to wiem, ale w sumie to nie przyszło mi do głowy, że tab[] jest interpretowane
identycznie jak tab[0], bo pominięcie zera nic nie zmienia, a przecież tab[0] to wskaźnik.
Jeżeli tak jest, to ma to sens i rozumiem już zasadę działania :D

Akurat jak zrobisz coś takiego:
int tablica(int tab[], int rozmiar=50)

To poprawnymi wywołaniami są:

int tab[50];

tablica(tab);
tablica(tab[0]);

Z kolei
tablica(tab[]);
Wywali błąd.
NAZWA tablicy jest wskaźnikiem do jej pierwszego elementu. Nazwą jest tab. tab[0] sam w sobie jest wskaźnikiem do jej pierwszego elementu. tab[] w sumie to... nie wiem czym jest w wywołaniu funkcji.

[Thrandir 1]

Dnia 06.12.2013 o 21:24, ziptofaf napisał:

Z kolei
tablica(tab[]);
Wywali błąd.

O, fakt, przykład wywoływania dobrze pokazuje, że jednak tab[0] nie jest w swoim działaniu tożsame z tab[].

Dnia 06.12.2013 o 21:24, ziptofaf napisał:

NAZWA tablicy jest wskaźnikiem do jej pierwszego elementu. Nazwą jest tab. tab[0] sam
w sobie jest wskaźnikiem do jej pierwszego elementu. tab[] w sumie to... nie wiem czym
jest w wywołaniu funkcji.

No właśnie, a to mnie interesuje, czym to jest. Bo o wskaźniku to wiadomo, ale czo to za dziwny twór, tab[]? Wraz z tym, czy ewentualna różnica (o ile taka istnieje, bo równie satysfakcjonującą odpowiedzią byłoby ''''to działa dokładnie tak samo, bo to dokładnie tak samo, tylko inaczej zapisane'''') w działaniu wersji int funkcja(int tab[]) i wersji int funkcja(int *tab) nakłada na programistę jakieś ograniczenia (poza ograniczeniem: składnia z nawiasem kwadratowym jest problematyczna w przypadku tablic wielowymiarowych)?

Gdyby więc ktoś coś wiedział, to byłbym wdzięczny za podzielnie się taką informacją :)

Mi osobiście przychodzi do głowy jedna interpretacja: składnia ze wskaźnikiem wpisanym jawnie ''''mówi'''' komputerowi tylko: tu się zaczyna to coś, z czego masz pobrać dane (bo składnia z gwiazdką nie indukuje jasno, że tam będzie tablica- funkcja chce tylko wskaźnik; równie dobrze można więc dać jej wskaźnik prowadzący do zwykłej zmiennej, i też ma szansę zadziałać: prawdopodobnie poza pierwszym elementem pobierze sobie jakieś wzięte z pamięci liczby zupełnie nie związane z tym, co chcemy zrobić, ale ma szansę się wykonać). Nie mówi, co to jest, jaki ma rozmiar- przekazuje tylko informację o tym, gdzie to coś się znajduje. Zaś składnia z nawiasem na mój rozum to bardziej: ta funkcja będzie wywołana od tablicy. Też przekazuje wskaźnik, ale nie w sposób dosłowny, i a wywołanie jej od wskaźnika nie będącego początkiem jawnej tablicy nie przejdzie.

Pytanie tylko, czy naprawdę tab[] mówi ciut dokładniej o tym, od czego wywołamy funkcję, niż tylko *tab? Równie dobrze moja logika może być bzdurna.

Ot, gadanina ''''na mój rozum''''. Wesoła twórczość i nic więcej, bo ani tego nie przetestowałem, ani nie wiem, jak w rzeczywistości działa wersja z nawiasami. W wolnej chwili to zrobię, może dojdę do czegoś ciekawego...

[ziptofaf 2]

/.../

A więc po kolei:

W definicji funkcji:
int tab[]
oznacza że tu pojawi się wskaźnik do tablicy o bliżej niesprecyzowanym rozmiarze. Jeśli ten rozmiar sprecyzujemy np:

int tablica(int tab[50])
{
}

int main()
{
int tab[999];
for (int a=0; a<50; a++)
{
tab[a]=a;
}

return 0;
}

To nic to nie zmieni (sprawdziłem na poziomie asemblera, generowany kod jest identyczny). Dla kompilatora NIE MA różnicy w funkcji która ma argument int tab[] a int tab[50] czy int tab[9999]. W końcu i tak karmisz ją wskaźnikiem a tablice w C++ ograniczone rozmiarami są tylko przez programistę, nie mają żadnego własnego sposobu sprawdzania swojej objętości.
Ba, nawet taka konstrukcja jest dopuszczalna (czyt. to się skompiluje i może nawet zadziała):

int tab[5];
tab[6] = 7;
cout << tab[6] << endl;

Zaś co do przekazania czemuś co oczekuje tablicy zwykłego insta - reinterpret_cast i jedziesz.
Jak się uprzesz to możesz nawet zrobić coś takiego:

const double stala = 10;
const double *wskaznik_staly=&stala;
int *wskaznik_zmienny;
wskaznik_zmienny = reinterpret_cast<int*>(const_cast<double*>(wskaznik_staly));
*wskaznik_zmienny=5;
Tak, właśnie zmieniłeś wartość obiektu const. I to wpisałeś do niego dane typu int a powinien być typu double. Albo raczej... jest na to spora szansa że je zmieniłeś - zależnie od wersji G++. U mnie (kompilator TDM 64, gcc 4.8.1) tworzy dodatkową zmienną i *wskaznik_zmienny pokaże na jedno a wskaznik_staly na coś innego. W niektórych przypadkach to by jednak zadziałało inaczej - zgodnie z oficjalnymi danymi od twórcy C++ wynik takiego działania jest niezdefiniowany. Więc nie polecam bo wywalisz kod w powietrze i będziesz jechał losowo po pamięci. Teoretycznie w ten sam sposób możesz przekazać funkcji oczekującej danych jednego typu coś zupełnie innego. Ale tylko teoretycznie.

Odpowiadając na twoje pytanie z kolei:
tab[] nie oznacza niczego. Jest błędem. Wolno ci tego używać w deklaracji funkcji jako int tab[] np. bo funkcji tak naprawdę NIE OBCHODZI co wpiszesz w polu z rozmiarem.

Ale nie możesz np. zrobić tak:

int main(){

int tab[]; //błąd
ani tak:
funkcja(tab[]);
}
Za to możesz zrobić tak:
int * tabler = tab;
tabler+=3;
tablica(tabler);
To sprawi że elementem początkowym tab dla funkcji tablica będzie jej czwarty element.


A dlaczego nie możesz wsadzić tab[] w wywołaniu funkcji tablica? Bo to programistyczna bzdura. Nie możesz stworzyć tablicy o nieokreślonym rozmiarze. Ani przesłać jako argumentu czegoś takiego bo co to w ogóle jest - wstawiasz fragment inicjalizacyjny tablicy ale nawet nie podałeś jej typu. Przypomnę - [] to jednoargumentowy operator. Możesz go sobie nawet przeciążać. Nie wolno ci tam za to zostawiać pustego pola. To tak jakby wpisać:
int a;
a=a+;
i liczyć na to że to zadziała. Nie da się. Operator + jest dwuargumentowy, inaczej nie zadziała.
To że możesz to zrobić w deklaracji funkcji bierze się tylko z tego powodu że tak naprawdę przesyłasz nie tablicę a wskaźnik do niej. Jak chcesz przesłać całą tablicę to też się da tak swoją drogą. Tylko że tego się zazwyczaj nie robi bo zżera więcej pamięci (jak kiedyś zamiast przesłać wektor przez referencję przesyłałem go przez wartość, w dodatku rekurencyjnie to po chwili okazało się że 4 GB RAM''u to stanowczo za mało).

Składnia ze wskaźnikiem napisanym "jawnie" nie mówi kompilatorowi niczego. Dostajesz dokładnie takie same dane.

[Thrandir 1]

Ok, załapałem. Dziękuję za wyczerpującą odpowiedź, teraz już rozumiem, "jak to działa", a to dla mnie podstawa :) Samo stosowanie i świadomość, że "działa" to trochę mało, ale zrozumienie, czemu i jak (w tym przypadku- dokładnie tak samo, jak z jawnym wskaźnikiem, czyli używając *) jest bardzo ważne.

Dnia 07.12.2013 o 01:43, ziptofaf napisał:

Jak chcesz przesłać całą tablicę to
też się da tak swoją drogą.

Hmm... Rozumiem, że takie przekazanie całej tablicy drugi (szerzej: kolejny) raz alokowałoby dla niej miejsce w pamięci, gdzie funkcja wrzuciłaby kopię całej tej tablicy "na własny użytek", tak? Jeżeli tak, to rzeczywiście, przy funkcji rekurencyjnej pamięć może się skończyć dość szybko :D
I jak by to wyglądało w kodzie? Przyznam się, z przesłaniem całej tablicy na zasadzie innej, niż poprzez wskaźnik jeszcze się nie spotkałem (a chętnie bym się dowiedział, jak się to robi). W przypadku takiego wywołania wartości zapisane w pierwotnej tablicy się nie zmienią (bo funkcja będzie pracowała na kopii), tak?