konstruktor kopiujący a operator wyłuskania

 #include<iostream>
using namespace std;



class A{
int a;

public:

 A(){
     a=0;
 }
A(const A& p){
    a=p.a;
    }

};


int main(){
A *p1 = new A();
A p2(*p1);
}

Nie rozumiem tego że musi być operator wyłuskania w A p2(*p1), bo w programowaniu strukturalnym jak mam w funkcji argument pobierany przez referencje to wskaźnik jest bez wyłuskania, bo chodzi o adres a nie o wartość a tu jest jakby odwrotnie? No bo przecież p1 wskazuje na obiekt, a my podajemy to p1 do konstruktora przez wartość...

Twoim największym problemem jest to, że na siłę pchasz w to wskaźniki.

A(const A& p)

Argumentem jest stała referencja do obiektu.
p1 jest wskaźnikiem, więc żeby dostać obiekt, trzeba wyłuskać.

twonek napisał(a):

A(const A& p)

Argumentem jest stała referencja do obiektu.
p1 jest wskaźnikiem, więc żeby dostać obiekt, trzeba wyłuskać.

tylko że kiedy mamy np. fun(&int) to możemy zrobić wywołanie fun(wskaźnik_bez_gwiazdki) i z tym mam problem

void foo_val(int i);
void foo_ptr(int *i);
void foo_ref(int &i);

int a;
foo_val(a); // funkcja przyjmuje wartość, zmienną przekazujemy bez żadnego znaczka
foo_ptr(&a); // funkcja przyjmuje wskaźnik, zmienną przekazujemy z ampersandem
foo_ref(a); // // funkcja przyjmuje referencję, zmienną przekazujemy bez żadnego znaczka

int *pa;
foo_val(*pa); // funkcja przyjmuje wartość, wskaźnik przekazujemy z gwiazdką (tak aby przekazać wartość)
foo_ptr(pa); // funkcja przyjmuje wskaźnik, więc go przekazujemy bez żadnego znaczka
foo_ref(*pa); // funkcja przyjmuje referencję. referencje przekazujemy identycznie jak zmienne, czyli musi być z gwiazdką.

Prawdą jest, że referencje to ukryte wskaźniki. Ale przekazujemy je tak jak zwykłe zmienne, więc jeśli mamy wskaźnik to musimy przekazać tak jakbyśmy przekazywali w tym miejscu zmienną.

tylko że kiedy mamy np. fun(&int) to możemy zrobić wywołanie fun(wskaźnik_bez_gwiazdki) i z tym mam problem

Pokaż kod.

Azarien napisał(a):

void foo_val(int i);
void foo_ptr(int *i);
void foo_ref(int &i);

int a;
foo_val(a); // funkcja przyjmuje wartość, zmienną przekazujemy bez żadnego znaczka
foo_ptr(&a); // funkcja przyjmuje wskaźnik, zmienną przekazujemy z ampersandem
foo_ref(a); // // funkcja przyjmuje referencję, zmienną przekazujemy bez żadnego znaczka

int *pa;
foo_val(*pa); // funkcja przyjmuje wartość, wskaźnik przekazujemy z gwiazdką (tak aby przekazać wartość)
foo_ptr(pa); // funkcja przyjmuje wskaźnik, więc go przekazujemy bez żadnego znaczka
foo_ref(*pa); // funkcja przyjmuje referencję. referencje przekazujemy identycznie jak zmienne, czyli musi być z gwiazdką.

Prawdą jest, że referencje to ukryte wskaźniki. Ale przekazujemy je tak jak zwykłe zmienne, więc jeśli mamy wskaźnik to musimy przekazać tak jakbyśmy przekazywali w tym miejscu zmienną.

tylko że kiedy mamy np. fun(&int) to możemy zrobić wywołanie fun(wskaźnik_bez_gwiazdki) i z tym mam problem

Pokaż kod.

Właśnie o to mi chodziło, ale zobacz że w klasie jest właśnie odwrotnie tzn jak masz A(const&x) to używasz wskaźnika z wyłuskaniem bo inaczej nie działa (masz error: no matching function for call to 'A::A(A*&)'|) i tego nie rozumiem

Jeszcze raz.

void foo(int& x);             // przyjmuje referencję (tak samo w przypadku const int&)
void bar(int* y);             // przyjmuje wskaznik

int* ptr;
foo(*ptr);           // skoro przyjmuje referencję, a masz wskaźnik, to musisz wyłuskać by dać mu obiekt
bar(ptr);            // przyjmuje wskaźnik, masz wskaźnik, więc po prostu mu dajesz

foo() to jest ten sam przypadek co Twój konstruktor.