Verschil tussen de int * i en int** i

Wat is het verschil tussen int* ien int** i?

Antwoord 1, autoriteit 100%

Aanwijzer naar een geheel getal

int* i

Aanwijzer naar een aanwijzer naareen geheel getal

int** i

(Dwz, in het tweede geval heb je twee dereferenties nodig om toegang te krijgen tot de waarde van het gehele getal)

Antwoord 2, autoriteit 54%

• int* i: iis een verwijzing naar een object van het type int
• int** i: iis een pointer naar een pointer naar een object van het type int
• int*** i: iis een aanwijzer naar een aanwijzer naar een aanwijzer naar een object van het type int
• int**** i: iis een aanwijzer naar een aanwijzer naar een aanwijzer naar een aanwijzer naar een object van het type int
• …

Antwoord 3, autoriteit 31%

int* pi

piis een pointer naar een geheel getal

int **ppi

ppiis een aanwijzer naar een aanwijzer naar een geheel getal.

BEWERKEN:

Je moet een goed boek over pointers lezen. Ik raad Aanwijzingen voor C door Kenneth Reekaan.

Antwoord 4, autoriteit 27%

Ik denk niet dat dit specifiek voor opencv is.

int *ideclareert een pointer naar een int. Dus islaat een geheugenadres op en C verwacht dat de inhoud van dat geheugenadres een int bevat.

int **ideclareert een aanwijzer naar… een aanwijzer. Naar een int. Dus ibevat een adres, en op dat geheugenadres verwacht C een andere aanwijzer te zien. Dat tweede geheugenadres zal dan naar verwachting een int bevatten.

Houd er rekening mee dat, terwijl u een aanwijzer naar een int declareert, de werkelijke int niet wordt toegewezen. Het is dus geldig om int *i = 23te zeggen, wat betekent: “Ik heb een variabele en ik wil dat deze verwijst naar geheugenadres 23 dat een int zal bevatten.” Maar als je daadwerkelijk zou proberen om geheugenadres 23 te lezen of te schrijven, zou je waarschijnlijk segfaulten, omdat je programma dat stuk RAM niet “bezit”. *i = 100zou fout gaan. (De oplossing is om malloc() te gebruiken. Of je kunt het laten verwijzen naar een bestaande variabele, zoals in int j = 5; int *i = &j)

Antwoord 5, autoriteit 27%

Stel dat je een leraar bent en aantekeningen moet geven aan een van je leerlingen.

int note;

Nou … ik bedoelde de hele klas

int *class_note; /* class_note[0]: note for Adam; class_note[1]: note for Brian; ... */

Nou … vergeet niet dat je meerdere lessen hebt

int **classes_notes; /* classes_notes[0][2]: note for Charles in class 0; ... */

En je geeft ook les aan verschillende instellingen

int ***intitute_note; /* institute_note[1][1][1]: note for David in class 1 of institute 1 */

etc, enz …

Antwoord 6, autoriteit 15%

Stel je hebt een paar vrienden, een van hen moet je iets geven (een schat… 🙂
Zeg dat John de schat heeft

int treasure = 10000; // in USD, EUR or even better, in SO rep points

Als je het rechtstreeks vraagt, John

int john = treasure;
int you = john;

Als je niet bij John kunt komen, maar Gill weet hoe hij contact met hem kan opnemen,

int john = treasure;
int *gill = &john;
int you = *gill;

Als je niet eens lid kunt worden van Gill, maar eerst contact moet opnemen met Jake die contact kan opnemen met Gill

int john = treasure;
int *gill = &john;
int **jake = &gill;
int you = **jake;

Enz… Aanwijzers zijn slechts indirectheden.

Dat was mijn laatste verhaal voor vandaag voordat ik naar bed ging 🙂

Antwoord 7, autoriteit 15%

Ik ben ervan overtuigd dat een foto meer zegt dan duizend woorden. Neem het volgende voorbeeld

// Finds the first integer "I" in the sequence of N integers pointed to by "A" . 
// If an integer is found, the pointer pointed to by P is set to point to 
// that integer. 
void f(int N, int *A, int I, int **P) {
  for(int i = 0; i < N; i++)
    if(A[i] == I) {
      // Set the pointer pointed to by P to point to the ith integer.
      *P = &A[i];
      return;
    } 
}

Dus in het bovenstaande wijst Anaar het eerste gehele getal in de reeks van N gehele getallen. En Pverwijst naar een aanwijzer waarin de beller de aanwijzer naar het gevonden gehele getal zal hebben opgeslagen.

int Is[] = { 1, 2, 3 };
int *P;
f(3, &Is[0], 2, &P);
assert(*P == 2);

&Pwordt gebruikt om het adres van Pnaar de functie door te geven. Dit adres heeft type int **, omdat het het adres is van een aanwijzer naar INT.

Antwoord 8, Autoriteit 4%

geen van beide is een verklaring. Verklaringsyntaxis toestaat niet ()rond de gehele aangifte. Wat zijn deze ()doen daar? Als dit een deel van de functieverklaring moet zijn, neemt u het hele functieverklaring op in uw vraag, aangezien in het algemeen de werkelijke betekenis van een verklaring daarvan kan afhangen. (Niet in deze echter.)

Wat betreft het verschil … er is één *in de eerste en er zijn twee *s in de tweede. Helpt het? Waarschijnlijk niet. De eerste verklaart ials een aanwijzer naar int. De tweede verklaart ials wijzer naar int *. Helpt dit? Waarschijnlijk niet veel. Zonder een specifiekere vraag is het moeilijk om een ​​zinvoller antwoord te geven.

Geef meer context, alstublieft. Of, als dit eigenlijk zo specifiek is als het kan krijgen, lees dan je favoriete C of C++ Book over Pointers. Dergelijke brede generieke vragen is niet iets dat u op het net vraagt.

Antwoord 9, Autoriteit 4%

INT * I ​​is het adres van een geheugenlocatie van een geheel getal
INT ** is het adres van een geheugenlocatie van een adres van een geheugenlocatie van een geheel getal

Antwoord 10

Merk op dat

int *i

is niet volledig verwisselbaar met

int i[]

Dit is te zien in dat het volgende zal compileren:

int *i = new int[5];

Hoewel dit niet zal zijn:

int i[] = new int[5];

Voor de tweede moet je het een constructorlijst geven:

int i[] = {5,2,1,6,3};

Je krijgt ook wat controle met het []-formulier:

   int *i = new int[5];
    int *j = &(i[1]);
    delete j;

compileert waarschuwingsvrij, terwijl:

   int i[] = {0,1,2,3,4};
    int j[] = {i[1]};
    delete j;

geeft de waarschuwingen:

waarschuwing C4156: verwijdering van een array-expressie zonder gebruik te maken van de array-vorm ‘delete’; matrixvorm vervangen
waarschuwing C4154: verwijdering van een array-expressie; conversie naar aanwijzer geleverd

Beide van deze laatste twee voorbeelden laten de applicatie crashen, maar de tweede versie (met het [] declaratietype) geeft een waarschuwing dat je jezelf in de voet schiet.

(Win32 console C++-project, Visual studio 2010)

Antwoord 11

Tekstvervanging is hier handig, maar pas op dat u het niet blindelings gebruikt, omdat het u kan misleiden (zoals in het geavanceerde voorbeeld hieronder).

T var; // var has type T
T* var; // var has type "pointer to T"

Dit werkt ongeacht wat T is:

int* var; // pointer to int
char* var; // pointer to char
double* var; // pointer to double
// advanced (and not pure textual substitution):
typedef int int3[3]; // confusing: int3 has type "array (of size 3) of ints"
                     // also known as "int[3]"
int3* var; // pointer to "array (of size 3) of ints"
           // aka "pointer to int[3]"
int (*var)[3]; // same as above, note how the array type from the typedef
               // gets "unwrapped" around the declaration, using parens
               // because [] has higher precedence than *
               // ("int* var[3];" is an array (size 3) of pointers to int)

Dit werkt wanneer t zelf een wijzertype is:

typedef int* T; // T is a synonym for "pointer to int"
T* var; // pointer to T
        // which means pointer to pointer to int
// same as:
int** var;

Antwoord 12

int * i; // Ik ben een aanwijzer naar geheel getal. Het kan het adres van een geheel getal variabele bevatten.

int ** i; // Ik ben een aanwijzer om te worden aanwijzer naar geheel getal. Het kan het adres van een integer-aanwijzervariabele bevatten.