definiowanie wskaźnika na wskaźnik na elementy typu int

Witam

Mam pewien problem :

Napisałem sobie taką funkcję:

void find_mtx_max( int ** wsk, int r, int c)
{
	int max=**wsk;
	for (int i=0; i<r; ++i)
		for(int j=0; j<c; ++j)
			if (max<(*(*(wsk+i)+j)))
				max=(*(*(wsk+i)+j));
	cout << endl << endl << endl << max << endl << endl;
}

I teraz tak:

1. Tworzę tablicę tablic :

 int tablica2[5][2]={{10,1},{2,3},{4,5},{6,7},{8,9}}; 

2. Wywołuję funkcję :

 find_mtx_max(tablica2, 5, 2); 

I tutaj pojawia się problem z tym że tablica2 to wg kompilatora nie jest typu wskaźnik na wskaźnik.
Wyrażenie tablica2[x][y] odpowiada wyrażeniu *(*(tablica2+x)+y) i jest wartością elementu (x,y)
Wyrażenie tablica2[x] jest wskaźnikiem na zerowy element wiersza x-owego
Wyrażenie tablica2 odpowiada wyrażeniu &tablica[0] czyli jest to adres wskaźnika pokazującego na początek wiersza zerowego
Wyrażenie tablica2 jest zatem wskaźnikiem na wskaźnik

Pytanie nr 1 :
Dlaczego więc do jasnej ciasnej nie jest możliwe wywołanie takiej funkcji w której za wskaźnik na wskaźnik jest podstawiane tablica2.

Pytanie nr 2 :
Czy zawsze jest tak że w przypadku gdy będziemy definiować tablicę tablic statycznych np. int tablica[5][2] = {...}; to czy zawsze będzie ona zapisywana w jednym nierozerwalnym bloku pamięci przeznaczonym na zmienne globalne ?
Inaczej : czy zdarzyć się może że przy takiej definicji wiersz np. drugi nie będzie leżał w pamięci pod adresem bezpośrednio za adresem określającym koniec wiersza pierwszego ?

Dodatkowo:
Próbowałem obejść ten błąd w ten sposób :

int ** ptrtab = &tablica2[0];
find_mtx_max(ptrtab, 5, 2);

Jednakże również i tutaj otrzymałem błąd na etapie kompilacji o niezgodności typów (int *) i (int **) a przecież jeśli tablica2[0] to adres początku zerowego wiersza to przecież jeśli pobiorę adres operatorem & to powinienem otrzymać wskaźnik na wskaźnik czyli typ (int **) - a jednak tak nie jest ponieważ kompilator zwraca błąd.

Jak to zrobić żeby było dobrze ?

Wiem że można sobie tą funkcję napisać inaczej aby przyjmowała za argument nie "wskaźnik na wskaźnik na daną" ale po prostu "wskaźnik na daną". Ale abym mógł to tak zrobić i później przesuwać ten jeden wskaźnik (arytmetyka wskaźników) to muszę mieć pewność że cały blok pamięci przeznaczony pod tablicę jest "nierozerwalny" a wskaźniki do elementów tablicy są kolejnymi liczbami naturalnymi...

Proszę uprzejmie o odpowiedzi.

Pokaż cały kod i komunikat błędu kompilatora wraz ze wskazaniem linii kodu, której dotyczy.

Rozumiem, że to

max<(*(*(wsk+i)+j))

zamiast

max < wsk[i][j]

jest sztuką dla sztuki?

Pełny kod:

#include <iostream>
#include <cstdlib>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <cstring>
#include <ctype.h>

// #define rozmiar12 5; // definiowanie symbolu
// #define PI 3.1415; // definiowanie symbolu , zmiana dokonywana w kodzie podstawiając literki - preprocesor - nie zajmuje to dodatkowo pamięci RAM
// const float pi=3.1415; // zapewniona kontrola typów przez kompilator w przypadku rzutowania i innych operacji - zmienna tworzona jest w pamięci
// extern const int pi; // szukaj zmiennej typu int pi także i w innych plikach projektu - często spotykana instrukcja w plikach nagłówkowych .h
// const int pi=5; // definiowanie stałej typu int , stała ta będzie stworzona w pamięci RAM

using namespace std;

void find_mtx_max( int ** wsk, int r, int c)
{
	int max=**wsk;
	for (int i=0; i<r; ++i)
		for(int j=0; j<c; ++j)
			if (max<(*(*(wsk+i)+j)))
				max=(*(*(wsk+i)+j));
				
	cout << endl << endl << endl << max << endl << endl;
}


int main()
{
	// definicja (deklaracja, przydzielenie pamięci (zasobów) i inicjalizacja) tablicy pięcioelementowej	
	int tablica2[5][2]={{10,1},{2,3},{4,5},{6,7},{8,9}};
	
	// wywołanie funkcji
	find_mtx_max(tablica2, 5, 2);

	getch();
	return 0;
}

Kompilator wywala:
35 29 C:\Users\Adam\Desktop\Programowanie C\Test2\main.cpp [Error] cannot convert 'int (*)[2]' to 'int**' for argument '1' to 'void find_mtx_max(int**, int, int)'
i podświetleniu na czerwono podlega wówczas linia 35 tj linia z instrukcją:

 find_mtx_max(tablica2, 5, 2); 

Natomiast to :

 max<(*(*(wsk+i)+j)) 

Zamiast :

 max<wsk[i][j] 

To istotnie sztuka dla sztuki - lubię się dokładnie uczyć jak już się uczę. Ale w przyszłości będę operował oczywiście skrótem nr 2.

Pomocy proszę.

void find_mtx_max(int wsk[][2], int r, int c)

Tutaj wyjaśnienie: http://www.cplusplus.com/doc/tutorial/arrays/

Dziękuję ! :D

Mam jeszcze jedno pytanko :

Jeśli dla tablic jednowymiarowych w prototypie funkcji może być argument typu int wsk[] (czyli int * wsk)
to dla tablic tablic wielowymiarowych powinno działać : int wsk[][2] (czyli int * wsk[2]) , jednakże to co napisałem w nawiasie nie działa. Jak by zatem można inaczej rozpisać to:

 int wsk[][2] 

przy założeniu że jest to deklaracja parametru przyjmowanego przez funkcję.

Wie ktoś ?

Okej zacznijmy od początku, bo widzę, że wszystko Ci się miesza.

1. Tablica nie jest wskaźnikiem

int tab[10];

tab jest tablicą, nie wskaźnikiem. W pewnych sytuacja jest zamieniana na wskaźnik na pierwszy element tablicy, np. przy przekazywaniu do funkcji, stąd te 2 zapisy są równoważne

void foo(int tab[])
void foo(int* tab)

Wewnątrz funkcji mamy już wskaźnik niezależnie od tego który zapis wybraliśmy.

2. Wskaźnik może wskazywać na jeden element, lub ciągły obszar takich samych elementów

int* x = new int;
int* y = new int[10];

3. Tablica dwuwymiarowa jest zamieniana na wskaźnik na tablice. Jak skompilujesz swoją pierwszą wersję programu, to kompilator bardzo grzecznie podpowiada, że

int tab[5][2]

ma typ int (*)[2], czyli wskaźnik na tablicę dwuelementową (a z punktu 2 wiemy że może również wskazywać na ciągły obszar wielu takich tablic). Stąd zamiast

void find_mtx_max(int wsk[][2], int r, int c)

możesz pisać

void find_mtx_max( int (*wsk)[2], int r, int c)

Natomiast taki zapis

void find_mtx_max( int* wsk[2], int r, int c)

nie przejdzie, bo tutaj wsk jest tablicą 2-elementową zwykłych wskaźników int* (jak się przesunie gwiazdkę do nazwy typu to lepiej widać)

Idealnie.

Dzięki ! Po stokroć dzięki.

Prosto wytłumaczone, szybko i logicznie.

Wszystko zrozumiałem.

Proszę tylko zweryfikować to co teraz napiszę.
W przypadku gdybym chciał utworzyć coś w rodzaju "macierzy trójwymiarowej" to wówczas:

int tab[5][2][3] = { { {1,2,3 }, {4,5,6} }, { {7,8,9}, {10,11,12} }, };

Czyli tab jest wskaźnikiem na wskaźniki na tablice trójelementowe - tak czy nie ?
Wskaźnik ten będzie wskazywał na pewien ciągły obszar pamięci danych (a tymi danymi są wskaźniki do tablicy trójelementowej).

Wówczas jeśli chciałbym stworzyć funkcję która by taki wskaźnik przyjmowała to musiałbym napisać:

void fun(int (*wsk)[2][3], int r, int c);

lub inaczej:

void fun(int wsk[][2][3], int r, int c);

I ciągle w ciele tej funkcji dysponuję wskaźnikiem do typu int (int *) a nie wskaźnikiem na wskaźnik do typu int (int **).

Proszę o weryfikację tego co napisałem pod kątem moich określeń co do nazw tego o czym mówimy, składni i logicznego sposobu organizacji myślowej. :)

I jeszcze jedna ostatnia już sprawa:

Proszę o weryfikację nazewnictwa :
int * wsk; // wskaźnik na dane typu int
int *(wsk[2]); lub inaczej int * wsk[2]; // dwuelementowa tablica wskaźników na dane int
int (*wsk)[2]; // wskaźnik na tablice dwuelementowe zawierające dane typu int
int *(wsk[3][2]); lub inaczej int *wsk[3][2]; // dwuelementowa tablica trójelementowych tablic wskaźników na dane int ?
int (*wsk)[3][2]; // wskaźnik na tablice dwuelementowe tablic trójelementowych zawierających dane typu int
int (**wsk)[2]; // wskaźnik na wskaźnik na tablice dwuelementowe

Dobrze czy źle ?

Adamos19 napisał(a):

Wówczas jeśli chciałbym stworzyć funkcję która by taki wskaźnik przyjmowała to musiałbym napisać:

void fun(int (*wsk)[2][3], int r, int c);

lub inaczej:

void fun(int wsk[][2][3], int r, int c);

Tak. Zresztą łatwo to sprawdzić kompilując.

Czyli tab jest wskaźnikiem na wskaźniki na tablice trójelementowe - tak czy nie ?
Wskaźnik ten będzie wskazywał na pewien ciągły obszar pamięci danych (a tymi danymi są wskaźniki do tablicy trójelementowej).
Nie, tab będzie typu int (*)[2][3] (łatwo można sprawdzić kompilując). Skłamałem w poprzednim poście pisząc, że tablica dwuwymiarowa jest wskaźnikiem..., powinno być tablica dwuwymiarowa jest zamieniana na wskaźnik....
Kompilator musi wiedzieć jak duże są elementy na które wskazuje (w tym przypadku jeden "element" ma rozmiar 2x3=6 intów), a wskaźnik₁ na wskaźnik₂ na tablice nie daje informacji ile takich tablic znajduje się "pod jednym" wskaźnikiem₂.

Analogicznie int tab[2][3][4][5] to int (*)[3][4][5]

int *(wsk[3][2]); lub inaczej int *wsk[3][2]; // dwuelementowa tablica trójelementowych tablic wskaźników na dane int
dwuwymiarowa tablica 3x2 wskaźników int*

int (*wsk)[3][2]; // wskaźnik na tablice dwuelementowe tablic trójelementowych zawierających dane typu int
wskaźnik na tablice dwuwymiarowe 3x2

Reszta ok.

http://en.cppreference.com/w/cpp/language/array - dobra lektura

Dobra załapałem chyba.
Czy mam rację pisząc że :

int * x ; wskaźnik na int
int * x [2] ; lub inaczej: int * ( x[2] ); dwuelementowa tablica wskaźników na int
int (*x)[2]; wskaźnik na tablicę dwuelementową danych typu int
int *x[2][3]; lub inaczej: int * (x[2][3]); dwuelementowa tablica trójelementowych tablic wskaźników na dane int lub inaczej: dwuwymiarowa tablica wskaźników na dane int
int * (*x)[2]; lub inaczej: int * ( (*x)[2] ); wskaźnik na dwuelementową tablicę wskaźników na dane int
int (*x[2])[3]; dwuelementowa tablica wskaźników na trójelementowe tablice
int **x[2]; lub inaczej int * * (x[2]); dwuelementowa tablica wskaźników na wskaźniki
int (*x)[2][3]; wskaźnik dwuelementowej tablicy trójelementowych tablic przechowujących dane typu int, inaczej: wskaźnik na tablice dwuwymiarowe

W przypadku tworzenia tablic w obszarze zmiennych globalnych tj. poleceniem:
int tab[5][2][3]={...};
Mamy sytuację że tab będzie typu : int (*)[2][3] czyli inaczej tab jest wskazaniem na tablice dwuwymiarowe.
Istotnie przy takiej konstrukcji wskaźnika dokładnie widać jaki rozmiar ma obiekt na który ten wskaźnik wskazuje. Oczywiście wskaźnik wskazuje na zerowy taki obiekt co nie znaczy że dalej w pamięci nie może być ich więcej (ciągły obszar tego typu obiektów). W tym wypadku tymi obiektami są dwuwymiarowe tablice.
Dlatego jak potem zrobimy np. sizeof(tab) to zwrócona będzie ilość bajtów przeznaczona na całą trójwymiarową tablicę.
sizeof(*tab) zwróci nam ilość bajtów przeznaczoną na jeden wiersz tablicy trójwymiarowej (zawierający kolumnę i poziom czyli kolejne dwa wymiary), natomiast: sizeof(**tab) zwróci nam ilość bajtów przeznaczoną tylko na poziom czyli na trzeci wymiar.
sizeof(***tab) zwróci nam ilość bajtów przeznaczoną na typ int.

Dobrze myślę ?

Głównie prosiłbym o sprawdzenie początkowych danych które zamieściłem w poście ...

Początek się zgadza.

W przypadku tworzenia tablic w obszarze zmiennych globalnych tj. poleceniem:

int tab[5][2][3]={...};

To wcale nie oznacza, że tablica jest globalna. Globalna będzie jeśli nie jest w żadnej funkcji (w tym main), w przeciwnym przypadku będzie zwykłą tablicą. Jedną z różnic jest taka, że globalna tablica będzie inicjalizowana zerami, zwykła nie (i używanie jej bez inicjalizacji to undefined behaviour)

Mamy sytuację że tab będzie typu : int (*)[2][3]
tab będzie tablicą 3-wymiarową, natomiast może być niejawnie konwertowane na wskaźnik o typie int (*)[2][3]. Zazwyczaj nie widać różnicy, stąd to się strasznie myli, ale jeżeli przekazujesz tablicę przez referencję to taki wskaźnik nie przejdzie.

Wszystko jasne oprócz jednego :
Nie bardzo rozumiem co masz na myśli... pisząc ostatnie zdanie.

Wiem że nie widać tego jawnie że tablica zostaje przekazywana przez referencję ale przecież chyba zawsze tak jest prawda ?
Np.
int tablica[3][2][5]={...};
Mamy ponadto:
void fun(int * tab[2][5]) lub inaczej void fun(int tab[][2][5]);
Wywołanie:
fun(tablica); // przecież tutaj właśnie do funkcji przekazujemy tablicę poprzez referencję

Co masz na myśli pisząc : "ale jeżeli przekazujesz tablicę przez referencję to taki wskaźnik nie przejdzie."... ??

#include <iostream>
using namespace std;

void foo(int (&tab)[2][3][4]) { tab[0][0][0] = 0; }

int main() 
{
	int tab[2][3][4];
    foo(tab);           // OK
    
    int (*wsk)[3][4] = tab;
    foo(wsk);           // to się nie skompiluje
	
	return 0;
}

http://melpon.org/wandbox/permlink/eaCgZeqcvIbJV5X8

No ok, a czym właściwie w tej chwili jest argument funkcji ? Inaczej jakiego typu argument funkcja jest gotowa przyjąć ?
Czy nie jest to przypadkiem adres czyli wskazanie ?

Jaka jest różnica pomiędzy :

void fun(int * x);

a

void fun(int (&x));

?

Referencja na tablicę czyli int (&) [2][3][4]

Jedno jest wskaźnikiem, drugie referencją.

Nie mogę jednak zrozumieć czym różni się referencja na coś od wskazania na coś ? Przecież to chyba jedno i to samo...

Przekazywanie parametru przez wartość i referencję

Czy dobrze myślę :

Referencja to adres, wskaźnik zaś to pewna zmienna która ten adres przetrzymuje ?

Jeśli funkcja chce przyjąć referencję do tablicy to musimy ją jej zapodać jako "tab", jeśli będzie chciała przyjąć wskaźnik wówczas możemy dać jej także "tab" ale wówczas konwersja referencji na wskaźnik dokona się automatycznie przy przekazaniu , tak czy nie ?

Nie bardzo jednak rozumiem dlaczego kompilator nie dopuszcza przekazania do funkcji tego wskaźnika. Przecież *wsk to wyłuskanie, &wsk to wskaźnik na wskaźnik no więc samo wsk przechowuje referencję. Dlaczego więc nie można tego dać jako argument tamtej funkcji ?

Adamos19 napisał(a):

Referencja to adres
Nie, referencja to jest jakby inna nazwa dla danej zmiennej. Trudniej dokładnie określić czym jest, łatwiej jest powiedzieć co robi i do czego jej użyć.
Jedną z przydatniejszych funkcji referencji jest przekazanie argumentu funkcji tak, by można dokonać zmiany na oryginale.

Jeśli funkcja chce przyjąć referencję do tablicy to musimy ją jej zapodać jako "tab", jeśli będzie chciała przyjąć wskaźnik wówczas możemy dać jej także "tab" ale wówczas konwersja referencji na wskaźnik dokona się automatycznie przy przekazaniu , tak czy nie ?
Konwersja tablicy, nie referencji. Jak masz

 int tab[5];

to w tym miejscu tab jest tablicą, a nie wskaźnikiem ani referencją.

Coraz bardziej to wszystko staje się dla mnie jasne.

Wobec tego jednak operator "&" powinien nazywać się operatorem tworzenia referencji do danej a nie operatorem pobrania adresu czyli wskazania.
Wobec powyższego jest więc tak że :
referencję możemy przypisać do wskaźnika, jednak już wskaźnik do referencji nie.

Dowód mamy w zapodanym przez Ciebie przykładzie.

Przy przekazywaniu do funkcji void fun(*wsk[2][3]); tablicy: fun(tablica) automatycznie dokonywana jest zamiana tablicy na referencję i ta referencja przypisywana jest dalej wskaźnikowi którym możemy się posługiwać w ciele funkcji.
W drugą stronę to działać nie będzie bo tak jak pisałem powyżej nie da się zrzucić wskaźnika na referencję którą wymaga funkcja.

Możesz mi to wszystko potwierdzić bo ciągle nie mam pewności czy to jest dobrze, ale to mi wyjaśnia raczej wszystko więc chyba dobrze co ?

Pracujesz tutaj na 4programmers ? Czy też jesteś jednym z wielu ogarniających tematy ? ;)

C++ ze względów historycznych (kompatybilność z C) nie lubi wprowadzać nowych symboli ani słów kluczowych, stąd często te same rzeczy są używane w różnych kontekstach i znaczą różne rzeczy.

int* x = &y;

& tutaj oznacza pobranie adresu zmiennej, nie ma żadnej referencji tutaj

int& x = y;

& tutaj oznacza specjalny typ "referencyjny" dla x

Przy czym pierwsze & nie ma wiele wspólnego z drugim &. Referencja i wskaźnik to różne byty, nie można przypisywać jednego do drugiego w żadnym kierunku. Ciekawostka: istnieje referencja do wskaźnika (przykład użycia w moim artykule podlinkowanym wyżej).

Przy przekazywaniu do funkcji void fun(*wsk[2][3]); tablicy: fun(tablica) automatycznie dokonywana jest zamiana tablicy na referencję i ta referencja przypisywana jest dalej wskaźnikowi którym możemy się posługiwać w ciele funkcji.
Następuje konwersja z tablicy na wskaźnik, nie ma tutaj żadnej referencji.

Mylisz znaczenia znaku &:

void foo(int &x); // przekazywanie parametru przez referencje - nie jest to operator
int &bar(); // zwracanie wartości przez referencje - nie jest to operator
int &x=...; // zmienna referencyjna - nie jest to operator
int *y=&x; // ten ampersand nie ma nic do referencji to pobranie adresu - ba, tylko to  jest operatorem

Ok. Przyjąłem do wiadomości.

Jednak jak w takim razie wyjaśnić że w chwili gdy
do funkcji przekazuję tablicę (i następuje konwersja na wskaźnik) argument funkcji deklarowany jako taki że ma być przekazywany przez referencję
to kompilator nie protestuje. Jeśli nie protestuje w chwili gdy przekazujemy wskaźnik (który sam się zrobił z tablicy) to czemu nie protestuje gdy chcemy przekazać właśnie wartość wskaźnika ?

To dlatego że tablica przekazywana jest domyślnie przez referencję (wtedy mu się zgadza z typem argumentu)
A zwraca błąd dlatego że wskaźnik nie jest referencją ?

Czyli że niby wskaźnik i referencja to dwie różne rzeczy ? :)

Dajcie no jeszcze ze dwa merytoryczne posty podsumowujące bo muszę to jakoś wszystko sobie ułożyć... please ! :D

Jednak jak w takim razie wyjaśnić że w chwili gdy
do funkcji przekazuję tablicę (i następuje konwersja na wskaźnik) argument funkcji deklarowany jako taki że ma być przekazywany przez referencję
to kompilator nie protestuje. Jeśli nie protestuje w chwili gdy przekazujemy wskaźnik (który sam się zrobił z tablicy) to czemu nie protestuje gdy chcemy przekazać właśnie wartość wskaźnika ?
Pokaż kod, bo nic nie zrozumiałem.

Nie było tematu, wszystko zrozumiałem.

Wówczas jak zaczęliście pisać mi o tym że referencja i wskaźnik to dwie różne rzeczy to właśnie wtedy pojąłem jak to wszystko dokładnie działa.

Ale nachodzi mnie jeszcze jedno pytanie na które nie mogę sobie odpowiedzieć :

Wiem już teraz że jest tak że jeśli funkcja ma mieć możliwość modyfikacji argumentu którego jej wysyłamy, to znaczy że musi przyjmować argument typu referencja lub argument typu wskaźnik.
Załóżmy że jest ona postaci :

void foo(int * wsk);

Wobec tego jeśli wywołamy ją tak :

int x=2;
int *ptr=&x;
foo(ptr); // lub tak: foo(&x);

To wówczas na stosie stworzy się lokalna kopia wskaźnika a następnie pracując na tej kopii wskaźnika i używając wyłuskania danej spod tej kopii dostaniemy się do oryginalnej wartości x.

Pytanie brzmi:

Czy w przypadku stosowania referencji uzyskujemy to samo (tj. możliwość modyfikacji argumentu) nie ponosząc przy tym dodatkowych kosztów związanych z tym że trzeba odłożyć coś na stos ? Czy ta tzw. "referencja" też jakoś zajmuje stos ?

void foo(int &wsk);

int x=2;
int *ptr=&x;
foo(x); // kompiluje się - tutaj 
// foo(ptr); // nie kompiluje się ponieważ wskaźnik to nie jest referencja

Dodatkowe pytanie:
Czy istnieje coś takiego jak referencja do wskaźnika lub wskaźnik do referencji ?

No bo co by było w przypadku np. takim :

void foo(int *&wsk); // referencja do wskaźnika

Gdzie takie coś w ogóle ma zastosowanie ?

twonek napisał(a):

Ciekawostka: istnieje referencja do wskaźnika (przykład użycia w moim artykule podlinkowanym wyżej).
http://4programmers.net/Forum/1236720

Czy w przypadku stosowania referencji uzyskujemy to samo (tj. możliwość modyfikacji argumentu) nie ponosząc przy tym dodatkowych kosztów związanych z tym że trzeba odłożyć coś na stos ? Czy ta tzw. "referencja" też jakoś zajmuje stos ?
Standard nie określa jak referencja ma być zaimplementowana, niemniej referencja to nie magia, jakiś tam koszt musi być. W szczególności referencja może być zaimplementowana pod spodem za pomocą wskaźnika. Niemniej przejmowanie się takimi "kosztami" to premature optimization.

Nie musi być żadnych argumentów na stosie, to zależy od calling convention. Ponadto kompilator i linker mogą sobie inline'ować co im się podoba (byle działało tak samo), więc koszt może spaść do zera. http://goo.gl/zjE9iO ⟵ zobacz jak wygląda koszt użycia wskaźnika w funkcji bar ;)

No i super. Tylko że ja nie robię przy komputerowych aplikacjach tylko przy mikrokontrolerach gdzie takie niby znikome koszty wywołania mogą mieć w pewnych miejscach duże znaczenie ze względu na małe rozmiary SRAM'u.

Niemniej bardzo dziękuję za precyzyjne wyjaśnienia.

Mam jeszcze jedno pytanko: dlaczego kolega przedstawił kod celem wnioskowania o "kosztach referencji" podczas gdy ten kod operuje wskaźnikami a nie referencjami.... ?

Chodzi Ci o ten post, gdzie napisałem:

kq napisał(a):

koszt użycia wskaźnika

?

Jeśli tak, to pisząc "wskaźnik" miałem na myśli wskaźnik. Ale nic nie szkodzi, abyś zmienił to sobie na referencję i również sprawdził :)

A jak wygenerować plik assemblera do stworzonego i skompilowanego kodu w dev c++ ?
A kolega twonek proszę aby kolega wrzucił ponownie tego linka o którym mówi a który to ma określać referencję do wskazania...
No proszę. Bardzo proszę.

dev-cpp używa jakiegoś antycznego mingw, ale tam wciąż powinna być opcja -S do generowania ASM.