🚀 go-pugleaf

W dniu 2016-08-04 09:58, stchebel@gmail.com pisze:
> Prośba: Napiszcie mi w kilku "żołnierskich" słowach jaka jest
> różnica/jak to interpretować:
>
> 1) void Jakaś_Tam_Funkcja(int* Jakaś_Tam_Zmienna); 2) void
> Jakaś_Tam_Funkcja(int *Jakaś_Tam_Zmienna); 3) void
> Jakaś_Tam_Funkcja(int * Jakaś_Tam_Zmienna);
>
> Nie chodzi mi o "void". Chodzi mi o umiejscowienie gwiazdek. Aha!! I
> jak następnie prawidłowo wywoływać tą funkcję z pewną zmienną o
> zadanej wartości.
>
> Jakaś_Tam_Zmienna może być dowolnego typu. Całkowita, rzeczywista,
> zespolona, bitmapa, cokolwiek..

Jeśli chodzi o różnicę, to jest różnica estetyczna tylko.

Jeśli chodzi o to, czy zmienna może być dowolnego typu - nie bardzo 
(teoretycznie zawsze możesz rzutować, ale niekoniecznie prawidłowo to 
zadziała)


-- 
Kaczus
http://kaczus.ppa.pl/art/cpp_kompendium_wiedzy,24.html

On 04/08/2016 09:58, stchebel@gmail.com wrote:
> 1) void Jakaś_Tam_Funkcja(int* Jakaś_Tam_Zmienna);
> 2) void Jakaś_Tam_Funkcja(int *Jakaś_Tam_Zmienna);
> 3) void Jakaś_Tam_Funkcja(int * Jakaś_Tam_Zmienna);
>
> Nie chodzi mi o "void". Chodzi mi o umiejscowienie gwiazdek. Aha!! I jak następnie prawidłowo wywoływać tą funkcję z pewną zmienną o zadanej wartości.

Na pierwsze dwa pytania już odpowiedziałem na pierwotne zapytanie na 
pl.misc.elektronika, dodam tylko komentarz do:

 > Jakaś_Tam_Zmienna może być dowolnego typu. Całkowita, rzeczywista,
 > zespolona, bitmapa, cokolwiek..

Jak już Tomasz zauważył, to bardzo zła praktyka. Jeśli jednak naprawdę 
nie ma innego wyjścia, to można ew. kombinować tak, licząc się z tym że 
prędzej czy póżniej to się zemści:

#include <stdio.h>

void f(void *x) {
   short *xshort;
   long *xlong;
   char *xstring;
   xshort = x;
   xlong = x;
   xstring = x;
   printf("short : %d\n", *xshort);
   printf("long  : %ld\n", *xlong);
   printf("string: '%s'\n", xstring);
}

int main(void) {
   long x;
   x = 999999;
   f(&x);
   return(0);
}

Uruchomienie:

mateusz@mateusz:~> ./test
short : 16959
long  : 999999
string: '?B'

Tłumaczenie: "void *" oznacza "wskaźnik jakiegokolwiek typu". C 
potrzebuje znać typ, a typem jest tu wskaźnik, więc wszystko gra. A w co 
ten wskaźnik kieruje to już można sobie potem interpretować na wszelaki 
sposób.

Ja sam nigdy nie użyłbym takiej konstrukcji, powyższe podaję raczej jako 
ciekawostkę. Prawidłowa odpowiedź to "należy deklarować typy zgodnie z 
ich przeznaczeniem".


Mateusz

Użytkownik "Mateusz Viste" <mateusz.viste@localhost> napisał w wiadomości 
news:57a30b27$0$3327$426a74cc@news.free.fr...
> On 04/08/2016 09:58, stchebel@gmail.com wrote:
>> 1) void Jakaś_Tam_Funkcja(int* Jakaś_Tam_Zmienna);
>> 2) void Jakaś_Tam_Funkcja(int *Jakaś_Tam_Zmienna);
>> 3) void Jakaś_Tam_Funkcja(int * Jakaś_Tam_Zmienna);
>>
> > Jakaś_Tam_Zmienna może być dowolnego typu. Całkowita, rzeczywista,
> > zespolona, bitmapa, cokolwiek..
>
> Jak już Tomasz zauważył, to bardzo zła praktyka. Jeśli jednak naprawdę nie 
> ma innego wyjścia, to można ew. kombinować tak, licząc się z tym że 
> prędzej czy póżniej to się zemści:
>
Myślę, że on miał na myśli, że w miejscu int jest coś innego (np. bitmapa), 
a nie, że w momencie wywołania jest wstawiona zmienna dowolnego typu.
P.G. 

Użytkownik <stchebel@gmail.com> napisał w wiadomości 
news:4069150b-d97c-4c69-ac7e-b46f61454c32@googlegroups.com...

>1) void Jakaś_Tam_Funkcja(int* Jakaś_Tam_Zmienna);
> I jak następnie prawidłowo wywoływać tą funkcję z pewną zmienną o zadanej 
> wartości.

Moje podejście do wskaźników w C.
Najprostsze tłumaczenie że
int *p;
oznacza, że p jest wskaźnikiem na int nie do końca tłumaczy spotykane potem 
operacje typu:
int a;
a=*p;

Dlatego ja sobie * i & tłumaczę tak:
------------------- do zapamiętania -----------------------
*p - przerabia p na coś wskazywanego przez p czyli na wskazywaną wartość.
&a - przerabia zmienną a na jej adres czyli na wskaźnik na tę zmienną.
------------------------------------------------------------
Wynika z tego:
p jest wskaźnikiem,
*p jest wskazywaną przez p wartością (*p nie jest wskaźnikiem!)
a jest jakąś wartością,
&a jest wskaźnikiem na a,

Pozwala to zrozumieć następujące zapisy:
*p=a;        // kopiujemy zawartość zmiennej a do zmiennej wskazywanej przez 
p
a=*p;        // odwrotnie
p=&a;       // adres zmiennej a wpisujemy do p (od teraz p wskazuje na a)
Zapis:
&a=p;
nie ma sensu, bo nie można modyfikować adresu zmiennej.

Deklaracja:
int *p;
oznacza, że p po przerobieniu na coś na co ono wskazuje stanie się int więc 
p musi wskazywać na int czyli p jest wskaźnikiem na int.
a deklaracja:
int **p;
oznacza, że p po przerobieniu na to na co wskazuje i po ponownym 
przerobieniu na to na co wskazuje stanie się int zatem p jest wskaźnikiem na 
wskaźnik, który (ten drugi) wskazuje na int.

Wywołanie funkcji void f(int *p):
int a; f(&a);
int *b; b=&a; f(b);

P.G. 

On 04.08.2016 09:58, stchebel@gmail.com wrote:
> Prośba: Napiszcie mi w kilku "żołnierskich" słowach jaka jest różnica/jak to interpretować:

W żołnierskich słowach, za napis:
C/C++
Należy się marszobieg w słonikach;-)

C/C++ to jak "instrukcja sterowania czołgiem/helikopterem" :-)


> 1) void Jakaś_Tam_Funkcja(int* Jakaś_Tam_Zmienna);
> 2) void Jakaś_Tam_Funkcja(int *Jakaś_Tam_Zmienna);
> 3) void Jakaś_Tam_Funkcja(int * Jakaś_Tam_Zmienna);

> Nie chodzi mi o "void". Chodzi mi o umiejscowienie gwiazdek.

Żadna.
Spacja nie ma znaczenia.
void Jakaś_Tam_Funkcja(int*Jakaś_Tam_Zmienna);
to to samo.


> Aha!! I jak następnie prawidłowo wywoływać tą funkcję z pewną zmienną o zadanej wartości.

int zmnienna;
...
Jakaś_Tam_Funkcja ( &zmienna );
...


W C jest to prawidłowe i jedyne rozwiązanie.
Trochę strach się pomylić i wstaewcić tem potem zmienną
zamiast jej adresu... trzeba warningi czytać.

W C++ jeśli chcesz, by funkcja wzięła zmienną i coś z nią
zrobiła (zmodyfikowała) lepiej ndeklarować tak:

void Jakaś_Tam_Funkcja(int &Jakaś_Tam_Zmienna);
Wtedy Jakaś_Tam_Zmienna jest referncją, technicznie wskaźnik do tego,
co tam wsadziłeś, ale obsługujesz jak normalną zmienną.
Odpalać normalnie:
Jakaś_Tam_Funkcja ( zmienna );


Jeśli nie modyfikujesz,
void Jakaś_Tam_Funkcja(const int &Jakaś_Tam_Zmienna);

Niby const niepotrzebne, ale wtedy kompilator pilnuje, czy nie
zrobisz sam błędu zapominając "miałem nie modyfikować"
(a operacja zmodyfikowania zmiennej może siedzieć głęboko
w kolejnycvh wywołacniach!).
Przy dobrych wiatrach może być też ciut lepiej optymalizowane.


pzdr
bartekltg

On Thursday, August 4, 2016 at 9:58:39 AM UTC+2, stch...@gmail.com wrote:
> Prośba: Napiszcie mi w kilku "żołnierskich" słowach jaka jest różnica/jak to interpretować:
> 
> 1) void Jakaś_Tam_Funkcja(int* Jakaś_Tam_Zmienna);
> 2) void Jakaś_Tam_Funkcja(int *Jakaś_Tam_Zmienna);
> 3) void Jakaś_Tam_Funkcja(int * Jakaś_Tam_Zmienna); 
> 
> Nie chodzi mi o "void". Chodzi mi o umiejscowienie gwiazdek. Aha!! I jak następnie prawidłowo wywoływać tą funkcję z pewną zmienną o zadanej wartości. 
> 
> Jakaś_Tam_Zmienna może być dowolnego typu. Całkowita, rzeczywista, zespolona, bitmapa, cokolwiek..

Gwiazdka może być w każdym z tych trzech wariantów. Preferuje pierwszy.

Piotr Gałka <piotr.galka@cutthismicromade.pl> wrote:

> Myślę, że on miał na myśli, że w miejscu int jest coś innego (np. bitmapa), 
> a nie, że w momencie wywołania jest wstawiona zmienna dowolnego typu.

Jeśli to bitmapa, z której każdy piksel jest typu int, to się zgadza - 
wskaźnik na tablicę...

-- 
http://www.chmurka.net/

Przemek Biernat pisze:
> On Thursday, August 4, 2016 at 9:58:39 AM UTC+2, stch...@gmail.com wrote:
>> Prośba: Napiszcie mi w kilku "żołnierskich" słowach jaka jest różnica/jak to interpretować:
>>
>> 1) void Jakaś_Tam_Funkcja(int* Jakaś_Tam_Zmienna);
>> 2) void Jakaś_Tam_Funkcja(int *Jakaś_Tam_Zmienna);
>> 3) void Jakaś_Tam_Funkcja(int * Jakaś_Tam_Zmienna); 
>>
>> Nie chodzi mi o "void". Chodzi mi o umiejscowienie gwiazdek. Aha!! I jak następnie prawidłowo wywoływać tą funkcję z pewną zmienną o zadanej wartości. 
>>
>> Jakaś_Tam_Zmienna może być dowolnego typu. Całkowita, rzeczywista, zespolona, bitmapa, cokolwiek..
> 
> Gwiazdka może być w każdym z tych trzech wariantów. Preferuje pierwszy.
A ja preferuję drugi wariant :P
Literalnie "int" jest zawsze "int",
natomiast Jakaś_Tam_Zmienna może być "int",
ale może być wskaźnikiem na "int", czyli *Jakaś_Tam_Zmienna,
widziałem (może nie koniecznie w połączeniu z "int")
jeszcze takie zapisy: int &argument
(ale to chyba już kodzie w C++).

"PawelS pawel(at)wbcd(dot)pl" <fake@email.org> wrote:

>>> 1) void Jakaś_Tam_Funkcja(int* Jakaś_Tam_Zmienna);
>>> 2) void Jakaś_Tam_Funkcja(int *Jakaś_Tam_Zmienna);
>>> 3) void Jakaś_Tam_Funkcja(int * Jakaś_Tam_Zmienna); 

Skoro już bawimy się w wykopaliska (hint: zobacz, Pawle, z kiedy jest 
post, na który odpowiadasz)...

Ja używam wariantu drugiego, chociaż mam z tym pewien mentalny problem.

Problem polega na tym, że wariant pierwszy bardziej pasuje do mojego 
sposobu myślenia, gdzie kładziony jest nacisk na typ wskaźnika (wariant 
"int* a" mówi, że typem zmiennej "a" jest wskaźnik na int), a wariant 
drugi kładzie nacisk na typ wskazywanych danych ("int *a" mówi, że typem 
danych wskazywanych przez "a" jest int).

Dlaczego więc jednak wariant drugi? Bo rozwiązuje to problem deklarowania 
wskaźnika razem z inną zmienną w jednej linii. W przypadku wariantu 
pierwszego można się spodziewać, że "int* a, b" deklaruje "b" jako 
wskaźnik, co jest oczywiście nieprawdą, mamy też problem podczas 
deklaracji typu "int a, *b" - nie da się, wg mnie, zapisać tego elegancko 
w pierwszym wariancie.

Z drugiej strony Stroustrup preferuje wariant pierwszy...

Spotkałem się też z opinią, że w C powinno się stosować wariant drugi, 
a w C++ pierwszy, bo C++ ma silniejsze typowanie i programiści powinni 
przestać myśleć w kategorii wartości, a zacząć w kategorii typów. Ma to 
jakiś sens. Póki co cały czas stosuję, w C i C++, wariant drugi.

> jeszcze takie zapisy: int &argument
> (ale to chyba już kodzie w C++).

Doczytaj o referencjach.

-- 
[ Email: a@b a=grp b=chmurka.net ]
[ Web:   http://www.chmurka.net/ ]

Adam Wysocki pisze:
> "PawelS pawel(at)wbcd(dot)pl" <fake@email.org> wrote:
> 
>>>> 1) void Jakaś_Tam_Funkcja(int* Jakaś_Tam_Zmienna);
>>>> 2) void Jakaś_Tam_Funkcja(int *Jakaś_Tam_Zmienna);
>>>> 3) void Jakaś_Tam_Funkcja(int * Jakaś_Tam_Zmienna); 
> 
> Skoro już bawimy się w wykopaliska (hint: zobacz, Pawle, z kiedy jest 
> post, na który odpowiadasz)...
Przepraszam, ale data jest za daleko wyświetlona za tematem postu na liście,
także rzadko kiedy patrzę na datę kiedy odpisuję.

> Ja używam wariantu drugiego, chociaż mam z tym pewien mentalny problem.
A jakiż że to problem ?
int - typ zmiennej,
Jakaś_Tam_Zmienna - nazwa zmiennej,
* - swego rodzaju flaga dla zmiennej (nie wiem jak to nazwać),

> Problem polega na tym, że wariant pierwszy bardziej pasuje do mojego 
> sposobu myślenia, gdzie kładziony jest nacisk na typ wskaźnika (wariant 
> "int* a" mówi, że typem zmiennej "a" jest wskaźnik na int), a wariant 
> drugi kładzie nacisk na typ wskazywanych danych ("int *a" mówi, że typem 
> danych wskazywanych przez "a" jest int).
> 
> Dlaczego więc jednak wariant drugi? Bo rozwiązuje to problem deklarowania 
> wskaźnika razem z inną zmienną w jednej linii. W przypadku wariantu 
> pierwszego można się spodziewać, że "int* a, b" deklaruje "b" jako 
> wskaźnik, co jest oczywiście nieprawdą, mamy też problem podczas 
> deklaracji typu "int a, *b" - nie da się, wg mnie, zapisać tego elegancko 
> w pierwszym wariancie.
Dlatego właśnie preferuję wariant drugi:
int - typ zmiennej,
następnie na liście już określamy
czy jest to zmienna, czy wskaźnik na zmienną.
Bardzo ciekawe spostrzeżenie:
"int* a, b"
intuicyjnie wygląda to jakby a i b było wskaźnikiem,
ale jak sam napisałeś jest to nie prawdą.

> Z drugiej strony Stroustrup preferuje wariant pierwszy...
> 
> Spotkałem się też z opinią, że w C powinno się stosować wariant drugi, 
> a w C++ pierwszy, bo C++ ma silniejsze typowanie i programiści powinni 
> przestać myśleć w kategorii wartości, a zacząć w kategorii typów. Ma to 
> jakiś sens. Póki co cały czas stosuję, w C i C++, wariant drugi.
OK, czyli taki sam wariant jaki stosuję ja,
lub jeśli wolisz odwrotną wersję,
jak stosuję taki sam wariant jaki stosujesz Ty
;)

>> jeszcze takie zapisy: int &argument
>> (ale to chyba już kodzie w C++).
> 
> Doczytaj o referencjach.
void funkcja(int *zmienna) { ... }
wywołanie:
int variable;
funkcja(&variable); /* tutaj przekazywana jest referencja do variable */
to dla mnie zrozumiałe.

To akurat niewątpliwie C++ zapis:
(gcc zwraca error, g++ kompiluje)
void funkcja (int &zmienna) { ... }

Mogę się domyślać, że jest to analogiczne do PHP:
funkcja(&zmienna) { ... }
kiedy taką funkcję wywołam:
$variable=5;
funkcja($variable);
echo("variable=$variable\n");
to wartość zapisana w variable może ulec zmianie.