Ik heb deze symbolen verschillende keren gevonden in een functiedeclaratie, maar ik weet niet wat ze betekenen.
Voorbeeld:
void raccogli_dati(double **& V, double **p, int N) {
int ultimo = 3;
V = new double * [N/2];
for(int i=0; i < N/2; i++) {
V[i] = new double[N/2], std :: clog << "digita " << N/2 - i
<< " valori per la parte superiore della matrice V: ";
for(int j=i; j < N/2; j++)
std :: cin >> V[i][j], p[ultimo++][0] = (V[i][j] /= sqrt(p[i][0]*p[j][0]));
}
for(int i=1; i < N/2; i++)
for(int j=0; j < i; j++)
V[i][j] = V[j][i];
}
Antwoord 1, autoriteit 100%
Dat is de parameter als referentie nemen. Dus in het eerste geval neem je een pointerparameter als referentie, dus elke wijziging die je aan de waarde van de pointer doet, wordt buiten de functie weerspiegeld. De tweede is vergelijkbaar met de eerste, met als enige verschil dat het een dubbele wijzer is. Zie dit voorbeeld:
void pass_by_value(int* p)
{
//Allocate memory for int and store the address in p
p = new int;
}
void pass_by_reference(int*& p)
{
p = new int;
}
int main()
{
int* p1 = NULL;
int* p2 = NULL;
pass_by_value(p1); //p1 will still be NULL after this call
pass_by_reference(p2); //p2 's value is changed to point to the newly allocate memory
return 0;
}
Antwoord 2, autoriteit 18%
De eerste is een verwijzing naar een aanwijzer, de tweede is een verwijzing naar een aanwijzer naar een aanwijzer. Zie ook FAQ over hoe pointers en referenties verschillen.
void foo(int*& x, int**& y) {
// modifying x or y here will modify a or b in main
}
int main() {
int val = 42;
int *a = &val;
int **b = &a;
foo(a, b);
return 0;
}
Antwoord 3, autoriteit 15%
Dat is het doorgeven van een aanwijzer op basis van referentie in plaats van op waarde. Dit maakt het bijvoorbeeld mogelijk om de aanwijzer (niet het object waarnaar wordt verwezen) in de functie zodanig te wijzigen dat de aanroepende code de wijziging ziet.
Vergelijk:
void nochange( int* pointer ) //passed by value
{
pointer++; // change will be discarded once function returns
}
void change( int*& pointer ) //passed by reference
{
pointer++; // change will persist when function returns
}
Antwoord 4, autoriteit 6%
Een int*is een verwijzing naar een int, dus int*&moet een verwijzing zijn naar een verwijzing naar een int. Op dezelfde manier is int**een verwijzing naar een verwijzing naar een int, dus int**&moet een verwijzing zijn naar een verwijzing naar een een verwijzing naar een int.
Antwoord 5, autoriteit 3%
Laten we een paar dingen bekijken om deze zinnen te begrijpen:
typedef double Foo;
void fooFunc(Foo &_bar){ ... }
Dus dat is een dubbel doorgeven als referentie.
typedef double* Foo;
void fooFunc(Foo &_bar){ ... }
nu geeft het een pointer door naar een dubbel als referentie.
typedef double** Foo;
void fooFunc(Foo &_bar){ ... }
Ten slotte geeft het een pointer door aan een pointer naar een double door middel van referentie. Als je in termen van typedefs als deze denkt, begrijp je de juiste volgorde van de & en * plus wat het betekent.
Antwoord 6, autoriteit 3%
*&betekent het ontvangen van de aanwijzer als referentie. Het betekent dat het een alias is voor de passerende parameter. Het heeft dus invloed op de passerende parameter.
#include <iostream>
using namespace std;
void foo(int *ptr)
{
ptr = new int(50); // Modifying the pointer to point to a different location
cout << "In foo:\t" << *ptr << "\n";
delete ptr ;
}
void bar(int *& ptr)
{
ptr = new int(80); // Modifying the pointer to point to a different location
cout << "In bar:\t" << *ptr << "\n";
// Deleting the pointer will result the actual passed parameter dangling
}
int main()
{
int temp = 100 ;
int *p = &temp ;
cout << "Before foo:\t" << *p << "\n";
foo(p) ;
cout << "After foo:\t" << *p << "\n";
cout << "Before bar:\t" << *p << "\n";
bar(p) ;
cout << "After bar:\t" << *p << "\n";
delete p;
return 0;
}
Uitvoer:
Before foo: 100
In foo: 50
After foo: 100
Before bar: 100
In bar: 80
After bar: 80
7
Dit * & amp; in theorie, evenals in praktisch het mogelijk en opgeroepen als verwijzing naar aanwijzervariabele. en het doet als hetzelfde.
Dit * & amp; combinatie wordt gebruikt als functieparameter voor ‘Pass-by’ -type definiëren. In tegenstelling tot ** kan ook worden gebruikt voor het declareren van een dubbele wijzer variabele.
Het doorgeven van de parameter is verdeeld in PASS per waarde, passeren per referentie, passeren door aanwijzer .
Er zijn verschillende antwoorden over “Pass by” -typen beschikbaar. De basis die we echter moeten begrijpen voor dit onderwerp is.
Pass per referentie – & GT; Werkt in het algemeen op reeds gecreëerde variabele gerefereerd tijdens het passeren naar functie E.G fun(int &a);
Pass per aanwijzer – & GT; Werkt op reeds geïnitialiseerd ‘Pointer-variabele / variabele adres’ die doorgeven aan functioneren b.g fun(int* a);
auto addControl = [](SomeLabel** label, SomeControl** control) {
*label = new SomeLabel;
*control = new SomeControl;
// few more operation further.
};
addControl(&m_label1,&m_control1);
addControl(&m_label2,&m_control2);
addControl(&m_label3,&m_control3);
In het bovenstaande voorbeeld (dit is het echte levensprobleem dat ik tegenkwam) Ik probeer een paar aanwijzer-variabele van de Lambda-functie te initeren en daarvoor moeten we het door een dubbele wijzer geven, dus dat wordt geleverd met D-referentie van POINTER VOOR HET ALLE GEBRUIK BINNEN VAN DIE LAMBDA + TERUG DIE POSER PASSEREN IN FUNCTION DIE DUBBELE POINTER DEREN, moet u de verwijzing naar de wijzervariabele doorgeven.
Dus met hetzelfde verwijzing naar de aanwijzervariabele, * & amp; helpt deze combinatie. in onderstaande manier voor hetzelfde voorbeeld heb ik hierboven genoemd.
auto addControl = [](SomeLabel*& label, SomeControl*& control) {
label = new SomeLabel;
control = new SomeControl;
// few more operation further.
};
addControl(m_label1,m_control1);
addControl(m_label2,m_control2);
addControl(m_label3,m_control3);
Hier kunt u zien dat u kunt zien dat u geen D-referenties nodig heeft, noch dat we een verwijzing naar aanwijzervariabele moeten doorgeven tijdens het passeren van functie, omdat de huidige passages per type al verwijst naar de aanwijzer.
Ik hoop dat dit helpt: -)