właśnie spotkałem się z takim zapisem wskaźnika
void funkcja(int *&obj){
{
//zawartość funkcji
}
natomiast coś takiego nie jest poprawne
int main()
{
int *&obj; //źle
}
dlaczego parametr funkcji jest ok, a delkaracja obiektu w main jest nie ok ? Jak to rozumieć ?
referencja to jest sprawdzenie gdzie położyłeś dane. A dereferencja to zajrzenie gdzie wskazuje ten adres, po co mieszać jedno z drugim, teoretycznie powinno się wykasować, ale powinno być zapisane odwrotnie najpierw & potem *, dodatkowo musisz użyć nawiasów, żeby kompilator wiedział kolejność wykonywania działań poprawną.
no taki zapis spotkałem w książce bo jeszcze takiego dziwoląga nie widziałem i dlatego pytam jak to ustrojstwo rozumieć ?
@CloudPro:
zrobiłem taki kod
int main()
{
int *wsk;
int *&refWsk=wsk;
int zmienna = 77;
wsk=&zmienna;
cout << *refWsk << endl;
return 0;
}
teoretycznie najpierw patrzysz gdzie jest położone, czyli dostajesz adres stosu, potem ten adres stosu wskazuje, że jest położone na stosie czyli dostajesz obj, czyli wychodzi masz obj same. Jeśli patrzysz od prawej do lewej strony obj, potem & referencja, potem * dereferencja. Te dwie rzeczy się anihilują &* jak adresu nie zmienisz, referencja daje adres, a dereferencja wartość pod tym adresem, jedynie jak zamienisz kolejność to może być zależne od adresu.
Nigdy nie pamiętam kolejności wykonywania działań więc mogę się mylić, bo to nie jest oczywiste, różne kompilatory różnie to robią to nie jest jak z matematyką najpierw nawiasy, potem mnożenie, potem dodawanie. Dlatego najlepiej wszystko w nawiasy robić co ma mieć pierwszeństwo dla czytelności.
zkubinski napisał(a):
dlaczego parametr funkcji jest ok, a delkaracja obiektu w
mainjest nie ok ? Jak to rozumieć ?
Bo to jest referencja, a referencje w C++ wymagają inicjalizacji XD
Referencja w moment deklaracji już musi "referować" do jakieś zmiennej.
Zmienna referencyjna w momencie powstania musi już "referować" do jakieś zmiennej lub obszaru pamięci.
W funkcji jest ok, ponieważ dopiero jak tą funkcje wywołasz to musisz podać do czego formalny parametr będzie "referować".
int *val;
int *&obj=val; // już ok
Alley Cat napisał(a):
zkubinski napisał(a):
dlaczego parametr funkcji jest ok, a delkaracja obiektu w
mainjest nie ok ? Jak to rozumieć ?Bo to jest referencja, a referencje w C++ wymagają inicjalizacji XD
znaczy jak jakiejś zmiennej zrobisz referencję to dostaniesz adres stosu/heapu, a wyżej już nic nie ma.
I referencje w C++ nie wymagają inicjalizacji, referencja przez kompilator podaje adres, gdzie znajduje się dana wartość. Jesteś noobem...
I referencje w C++ nie wymagają inicjalizacji, referencja przez kompilator podaje adres, gdzie znajduje się dana wartość. Jesteś noobem... — CloudPro 10 minut temu
@CloudPro: Nie, wcale nie wymagają, a ja jestem noobem i autorzy kompilatorów najwyraźniej też:
struct str
{
int &memb;
};
int main()
{
int &ref;
str x;
}
Otóż jednak wymagają:
c++ -O2 -pipe -o noinit noinit.cc
noinit.cc:9:7: error: declaration of reference variable 'ref' requires an initializer
int &ref;
^~~
noinit.cc:10:6: error: call to implicitly-deleted default constructor of 'str'
str x;
^
noinit.cc:4:7: note: default constructor of 'str' is implicitly deleted because field 'memb' of reference type 'int &' would not be initialized
int &memb;
^
2 errors generated.
@cloudpro nie wiem czy się nie znasz czy trollujesz, ale zaprzestań siania dezinformacji.
Definicja referencji i dereferencja to zupełnie różne rzeczy
kq napisał(a):
@cloudpro nie wiem czy się nie znasz czy trollujesz, ale zaprzestań siania dezinformacji.
Definicja referencji i dereferencja to zupełnie różne rzeczy
Teraz to mega mnie podważyłeś, referencja daje nam adres gdzie leży dana informacja, czy to adres czy liczba, czy cokolwiek, bo to abstrakcja matematyczna.
_13th_Dragon napisał(a):
Referencja w moment deklaracji już musi "referować" do jakieś zmiennej.
W szczególnym przypadku OP. Natomiast w przypadku ogólnym nie musi tak być.
CloudPro napisał(a):
kq napisał(a):
@cloudpro nie wiem czy się nie znasz czy trollujesz, ale zaprzestań siania dezinformacji.
Definicja referencji i dereferencja to zupełnie różne rzeczy
Teraz to mega mnie podważyłeś, referencja daje nam adres gdzie leży dana informacja, czy to adres czy liczba, czy cokolwiek, bo to abstrakcja matematyczna.
Wzięcie referencji owszem. Przykładowo:
int x;
int &ref_x = x; // teraz ref_x wskazuje na to samo miejsce co x
W powyższym przykładzie, referencja, to będzie obiekt ref_x, który musi być na wstępie zainicjalizowany (tzn musisz tam zrobić = x, nie możesz zakończyć linijki średnikiem).
Funkcje operują na kopiach argumentów i wskaźników to również dotyczy.
Jeśli chcesz w funkcji zmodyfikować wskaźnik to musisz go przesłać przez referencję/podwójny wskaźnik.
#include <iostream>
void false_set(int* ptr)
{
static int new_value = 50;
ptr = &new_value;
}
void real_set(int*& ptr)
{
static int new_value = 100;
ptr = &new_value;
}
int main()
{
int value = 10;
int* ptr = &value;
false_set(p);
std::cout << "Value = " << *p << '\n'; // <- Wciąż będzie '10'
real_set(p);
std::cout << "Value = " << *p << '\n'; // <- Tu już będzie '100'
return 0;
}
int value,*ptr; // deklaracja zmiennej i wskaźnika
int &ref=value; // ref jest typem referencyjnym do int, zainicjalizowany zmienną value, czyli od teraz ref to alias do value
ptr=&value; // operator referencji (czyli pobranie adresu) z value, czyli adres value
ptr=&ref; // operator referencji (czyli pobranie adresu) z aliasa do value, czyli niejako adres value
_13th_Dragon napisał(a):
ptr=&value; // operator dereferencji (czyli pobranie adresu) z value, czyli adres value ptr=&ref; // operator dereferencji (czyli pobranie adresu) z aliasa do value, czyli niejako adres value
Bosssssh! Od kiedy & jest operatorem dereferencji w C++ albo dereferencja oznacza pobranie adresu?
_13th_Dragon napisał(a):
Referencja w moment deklaracji już musi "referować" do jakieś zmiennej.
Nie musi, na przykład:
void foo(int &ref /* deklaracja referencji */)
{
}
int main()
{
int v = 123;
foo(v); /* inicjalizacja referencji */
}
zkubinski napisał(a):
no taki zapis spotkałem w książce bo jeszcze takiego dziwoląga nie widziałem i dlatego pytam jak to ustrojstwo rozumieć ?
Chyba ostatecznie nikt ci na to nie odpowiedział.
Zauważ, że w poniższym kodzie sprawa jest oczywista
void funkcja(T& val){
{
//zawartość funkcji
}
int main()
{
T& obj; //źle
}
w końcu doskonale rozumiesz czym jest referencja.
To teraz wystarczy zauważyć, że
using T = int*;
da nam dokładną sytuację z oryginalnego posta.
Inaczej mówiąc: nie da się mieć w C++ niezainicjalizowanej referencji. Można doprowadzić do wiszącej, ale tu też trzeba chcieć i jest to UB.