Die Schleife durch array mit Zeigern

Das folgende Programm in C++ druckt mehr Leistung als ich erwartet habe. Kann mir jemand erklären, warum das passiert ist? Das Programm versucht, Zeiger verwenden, um eine Schleife durch das integer-array, drucken jeden Wert mit auf den Weg.

#include <cstdio>
using namespace std;

int main(int argc, char **argv) {
    puts("hi");
    int ia[5] = {1,2,3,4,5};
    for (int *p = ia; *p; ++p) {
        printf("Char is: %d\n", *p);
    }
    return 0;
}

/*
 hi
 Char is: 1
 Char is: 2
 Char is: 3
 Char is: 4
 Char is: 5
 Char is: 32767
 Char is: -811990796
 Char is: -133728064
 Char is: 1606416320
 Char is: 32767
 Char is: -1052593579
 Char is: 32767
 Program ended with exit code: 0
*/

Ihre Schleife geschrieben um zu stoppen, wenn es auf ein null-element in das array (worauf *p ausgewertet, um zu false). Aber das array nicht in der Tat enthalten eine null-element. Also die Schleife geht Weg am Ende des Arrays, also ausstellen zu undefiniertem Verhalten.
FWIW, das ist nicht c++ - Ausnahme: völlig irrelevant using namespace std, und einen alias für stdio.h. ideone.com/saAZKk
Es ist ganz in gültigen C++ - code.
Jeder C-code ist absolut gültigen C++ - code. Heißt das, wir könnten die drop-c-tag? Lassen Sie mich Fragen, eine andere Art und Weise, was in dieses problem ist c++ - spezifisch ist? EDIT: Sorry, gehen wir nicht in eine Debatte bitte. Ich wollte nur darauf hinweisen, das ist nicht wirklich c++ - spezifisch und machen den Menschen neu zu bewerten, ob dies in C oder C++. Zu viele Menschen verwechseln diese.
C-code ist absolut gültigen C++ - code" - Nein, ist es nicht. Der OP-code ist.
Ich zurücknehmen, es gibt in der Tat nur wenige Fälle, in denen die gültigen c-code wird die Reise c++ - compiler. Das hat auch nicht wirklich den Punkt ändern.
Nicht nur die Reise der compiler. Manchmal sind die Unterschiede kompilieren und stattdessen etwas unerwartetes tun, wenn Sie erwarten, dass die C Verhalten.

InformationsquelleAutor none | 2017-01-17

c++pointers

4

Müssen Sie eine 0/NULL-Wert zum stop an, derzeit nicht.

Ihre Schleifenbedingung wird erlauben, iteration, bis man einen Wert, der zu false ausgewertet wird (ich.e 0) und das array nicht enthalten ist, so dass Ihr iteration wird weiter über die Grenzen des Arrays und wird irgendwann beendet, wenn es den Zugriff auf bestimmte Speicher nicht seinen sollen.

Gibt es mehrere Möglichkeiten, es zu beheben. Sie können hinzufügen eine 0 an das Ende des Arrays.
```
#include <cstdio>
using namespace std;

int main(int argc, char **argv) {
    puts("hi");
    int ia[] = {1,2,3,4,5, 0};
    for (int *p = ia; *p; ++p) {
        printf("Char is: %d\n", *p);
    }
    return 0;
}
```
Problem mit diesem ist, dass Sie jetzt nicht verwenden 0 im array, oder es wird beendet früh.

Einen besseren Weg, wäre vor berechnen der Adresse, unter der Sie zu stoppen, da die array-Länge. Diese Adresse ist eine aus dem Ende des Arrays.
```
#include <cstdio>
using namespace std;

int main(int argc, char **argv) {
    puts("hi");
    int ia[] = {1,2,3,4,5};
    int* end = ia + 5;
    for (int *p = ia; p != end; ++p) {
        printf("Char is: %d\n", *p);
    }
    return 0;
}
```
Nun, wir sind immer in Richtung der Methode, mit der Standardbibliothek Iteratoren. Jetzt Vorlagen ableiten kann, die Größe des Arrays.

d.h.
```
#include <iterator>
...

for (auto it = begin(ia); it != end(ia); ++it) {
    printf("Char is: %d\n", *it);
}

...
```
- Oder auch für die Reihe: for (int e : ia) { /*..*/ }.
InformationsquelleAutor Paul Rooney
2

Kann mir jemand erklären, warum das passiert ist?

Zugriff auf die array out of bounds. Das Programm Undefiniertes Verhalten.

Die Linie
```
int ia[5] = {1,2,3,4,5};
```
erstellt ein array mit genau 5 Elementen. Zugriff auf *p nach haben Sie Zugriff auf das Letzte element des Arrays ist nicht gut.

Können Sie verwenden:
```
for (int *p = ia; p != std::end(ia); ++p) {
```
um sicherzustellen, dass Sie nicht auf die array out of bounds.

Müssen Sie hinzufügen:
```
#include <iterator>
```
verwenden std::end.
- #include <iterator>
InformationsquelleAutor R Sahu

Nutzen Sie alternativ sizeof() operator zum ermitteln der Anzahl der Elemente:

for (int *p = ia; p < ia + sizeof(ia)/sizeof(*ia); ++p) {
    printf("Char is: %d\n", *p);
}

InformationsquelleAutor artm

0

in der Tat die Bedingung:
```
for( ; *p; )//...
```
wird überprüft, ob der Wert in der Adresse gleich 0 ist oder nicht, also hört es nur wenn der Wert null ist und das ist natürlich nicht das, was Sie wollte; Sie wollte zum Inkrementieren der Adresse, bis das Letzte element, aber dein code prüft den Wert in der Adresse nicht die Adresse selbst, ausserdem die Adresse nach dem lat-element ist nicht NULL.

um Ihr problem zu lösen Sie können zählen, wie viele Elemente im array und dann innerhalb der Schleife Inkrementieren der Zeiger entsprechend:
```
#include <cstdio>
using namespace std;

int main(int argc, char **argv) {
    puts("hi");
    int ia[5] = {1,2,3,4,5};
   int* end = &ia[0] + 4;
   for (int *p = ia; p <= end; ++p) {
        printf("Char is: %d\n", *p);
    }
   return 0;
}
```
InformationsquelleAutor Raindrop7

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.