Was macht "* (Zeiger + Integer)" in C++?

Question

Ich bin verwirrt, was eine Codezeile hat in diesem Programm:

int *temp = new int [cap]; 
int num = 0; 

for(int i = name; i < number; i++) 
{ 
*(temp + count) = *(foo + i); 
num++; 
} 

name, number und foo globale Variablen (foo ein Zeiger ist), und cap ist ein Argument.

Insbesondere verstehe ich nicht diese Zeile:

*(temp + count) = *(foo + i); 

Warum gibt es zu den Klammern Zeiger, und was wird das?

Answer 1

*(temp + count) = *(foo + i) bedeutet:

die temp-Adresse erhalten, fügen count zu dieser versetzt, dann Sollwert in temp + count Adresse aus Adresse auf den Wert foo mit Offset i

besser sein wird:

temp[count] = foo[i]; 

(Übrigens ist es ein C-Stil (außer new), nicht C++. Sehr schlechter Code.)

Answer 2

*(temp + count) = *(foo + i); 

Die Operatoren + führen Zeigerarithmetik aus. Das Hinzufügen einer ganzen Zahl zu einem Zeigerwert ergibt einen neuen Zeiger, der eine spezifizierte Anzahl von Objekten nach dem ursprünglichen Zeiger inkrementiert. Zum Beispiel, wenn ist ein Zeiger auf arr[0], dann Punkte auf arr[2].

Der * Operator deferences der resultierende Zeiger, der Ihnen das Objekt gibt, auf das es zeigt.

In der Tat ist der Array-Indexierungsoperator in Bezug auf Zeigerarithmetik definiert, so dass A[i] bedeutet *(A+i) (Ignoring Operatorüberladung). So die obige Codezeile:

*(temp + count) = *(foo + i); 

auch geschrieben werden konnte (deutlicher IMHO) als:

temp[count] = foo[i]; 

Sie könnten die comp.lang.c FAQ, insbesondere die Abschnitte 4 (Pointers) und 6 (Arrays lesen möchten und Zeiger). Die meisten Informationen gelten auch für C++.

Allerdings stellt C++ höhere Bibliotheksschnittstellen bereit, die robuster sein können als die Low-Level-C-Entsprechungen. In C++ ist es selten sinnvoll, Code zu schreiben, der sich direkt mit Arrays und Pointern auf Array-Elemente befasst, es sei denn, es handelt sich um Code auf sehr niedriger Ebene und die Performance ist von entscheidender Bedeutung und/oder es handelt sich um Datenstrukturen aus C-Code.

Answer 3

In Ihrem Beispiel

*(temp + count) = *(foo + i); 

entspricht

temp[count] = foo[i]; 

Der Ausdruck *(temp + count) integer fügt counttemp Zeiger, der man einen Zeiger auf Element count in dem Array an der Position zeigte auf verleiht durch temp und dereferences es.

Answer 4

Vielleicht ist der Schlüssel Zeile Ihrer Frage ist:

Warum gibt es zu den Klammern Zeiger [...]?

Das * Symbol in C und C++ ist etwas verwirrend semantisch überladen. Sie sind richtig, dass es manchmal "Zeiger auf" bedeutet, wie in int* int_ptr, wo die * bedeutet "int_ptr ist ein Zeiger auf der Typ auf der linken Seite der *".

Aber es auch bedeutet "Dereferenzierung eines Zeigers zu ...", was ist eigentlich hier los. Die Ausdrücke (temp + count) und (foo + i) werten zu pointer-to-int s aus, da das Hinzufügen eines int-like-Typs zu einem Zeigerwert zu dem Zeigerwert offset durch den Integer-Typ führt (dh Sie berechnen die Speicheradresse in einiger Entfernung von der ursprüngliche Zeiger). Die Klammern stellen einfach sicher, dass die Additionsoperationen stattfinden, bevor die * angewendet werden. So *(temp + count) ist dereferencing der Zeiger Wert temp + count. Dies bedeutet, dass es den ganzzahligen Wert auswertet, der unter der Adresse temp + count gespeichert ist.

Sie können einige der Verwirrung beseitigen, indem sie als auch der ersten Bedeutung denken ein dereferenzieren angibt: int* int_ptr entspricht int *int_ptr, das heißt, „wenn du dereferenzieren int_ptr, erhalten Sie eine int bekommen.“ Daraus ergibt sich ein intuitives Gefühl dafür, warum int* int_one, int_two erklärt int_one als Zeiger auf ein int und int_two als int - nicht als Zeigertyp.