arr kein Zeiger ?

#include <stdio.h>

int main()
{
    int i = 0;
    int arr[10];

    for ( i=0; i<10; i++ )
        *(arr + i) = i; // Kein Zeiger ?
    for ( i=0; i<10; i++ )
        printf("%d\n", *(arr + i) ); // Kein Zeiger ?
    return 0;
}

resis

Hallo ...
Du definierst dir hier keinen Zeiger, sondern ein Array!
Ein Array ist ähnlich wie ein Zeiger, wobei der Zeiger nur eine Speicheradresse allokiert und ein Array einen ganzen Bereich. Auf diesen Bereich kannst du direkt zugreifen...auf den Beispiel bezogen:

#include <stdio.h>

int main()
{
    int i = 0;
    int arr[10];

    for ( i=0; i<10; i++ )
        arr[i] = i; 
    for ( i=0; i<10; i++ )
        printf("%d\n", arr[i]);
    return 0;
}

Arraypointer NOOB schrieb:

#include <stdio.h>

int main()
{
    int i = 0;
    int arr[10];

    for ( i=0; i<10; i++ )
        *(arr + i) = i; // Kein Zeiger ?
    for ( i=0; i<10; i++ )
        printf("%d\n", *(arr + i) ); // Kein Zeiger ?
    return 0;
}

meines erachtens nach sollte der code funsen....
wo liegt das problem?

*(arr + i) == arr[i]

LordJaxom

Mal abgesehen davon, dass bereits mehrmals das Offensichtliche dargestellt wurde, worum geht's hier überhaupt?

arr ist kein Zeiger. Dass arr sich als Zeiger benutzen lässt, zeigt rein garnichts.

Tachyon

int main()
{
    double a;
    int b;
    int c;
    for(c = 0; c < 20; ++c)
    {
        a = c;   //kein double?
        b = a;   //kein int?
    }
    //wo ist die Frage?
};

BorisDieKlinge

#include <stdio.h>

int main()
{
    int i = 0;
    int arr[10];
     int *p= arr;

    for ( i=0; i<10; i++ )
        *(p + i) = i; // Kein Zeiger ?
    for ( i=0; i<10; i++ )
        printf("%d\n", *(p + i) ); // Kein Zeiger ?
    return 0;
}

müsste auch mit

*(arr+x)

gehen

arr kein Zeiger ?
Ja und nein.

Betrachtet man arr stellvertretend für das Array int arr[10], so ist die Frage mit nein zu beantworten.
Betrachtet man jedoch arr als Namen, so ist es ein Zeiger auf das erste Element des Arrays und auch genauso wie ein Zeiger einsetzbar.
Dazu ein Zitat aus Galileo Computing:

...
da laut ANSI C-Standard der Arrayname immer als Zeiger auf das erste Array-Element angesehen wird. Hier der Beweis und das Beispiel dazu:

Mit zugehörigem Programm:

/* arr_ptr2.c */
#include <stdio.h>
#include <stdlib.h>
int main(void) {
   int element[8] = { 1, 2, 4, 8, 16, 32, 64, 128 };
   int i;
   printf("*element     = %d\n", *element);
   printf("*(element+1) = %d\n", *(element+1));
   printf("*(element+3) = %d\n", *(element+3));
   printf("\nJetzt alle zusammen : \n");
   for(i=0; i<8; i++)
      printf("*(element+%d) = %d \n", i, *(element+i));
   return EXIT_SUCCESS;
}

Tachyon

int arr[10];

ist vom Typ jer nie ein Zeiger, sondern immer ein int[10]. Immer, wenn sich das Objekt so wie ein Zeiger verhält, findet ein impliziter Cast statt. Nichts desto trotz ändert das nichts daran, dass es KEIN Zeiger ist. Ein sizeof(arr) zeigt das übrigens direkt und ganz deutlich, denn sizeof(int*) != sizeof(int[10]):

int main()
{
    int arr[10];
    int p_arr = &arr[0];

    printf("arr   : %u\n", sizeof(arr));
    printf("p_arr : %u\n", sizeof(p_arr));
    if(sizeof(arr) == sizeof(p_arr))
    {
        printf("Galileo Computing == Qualitaet\n");
    }
    else
    {
        printf("Galileo Computing == Pro7 Galileo\n");
    }
    return 0;
}

LordJaxom

Erbsenzähler schrieb:

Betrachtet man jedoch arr als Namen, so ist es ein Zeiger auf das erste Element des Arrays und auch genauso wie ein Zeiger einsetzbar.

"Es ist ein Zeiger und auch genauso wie ein Zeiger einsetzbar."

Wenn es ein Zeiger ist, erwarte ich auch, dass es sich wie ein Zeiger einsetzen lässt, insofern ist diese Aussage redundant. Leider ist die erste Hälfte der Aussage falsch, so dass sich das wieder relativiert.

Dazu ein Zitat aus Galileo Computing:

<ironie>Na, da hast Du dir ja direkt die zuverlässigste aller Quellen rausgesucht</ironie>

Wo wir bei "Beweisen" sind, hier ist einer, der zeigt, dass ein Array kein Zeiger ist:

int array[100];
int* zeiger = &array[0];

printf("%u\n", sizeof(array)/sizeof(*array));
printf("%u\n", sizeof(zeiger)/sizeof(*zeiger));

Wenn array ein Zeiger wäre, müsste ja bei beiden das gleiche Ergebnis rauskommen.

LordJaxom schrieb:

"Es ist ein Zeiger und auch genauso wie ein Zeiger einsetzbar."
...
Wenn es ein Zeiger ist, erwarte ich auch, dass es sich wie ein Zeiger einsetzen lässt, insofern ist diese Aussage redundant. Leider ist die erste Hälfte der Aussage falsch, so dass sich das wieder relativiert.

Lässt er sich ja auch einsetzen, wenn auch nur eingeschränkt:

int arr[10];
	int* int_ptr = arr;
	arr[0] = -1;
	printf( "%d\n", *arr );// Zeiger dereferenziert das erste Element.

Eine Inkrementierung arr++, funktioniert z.B. nicht.

<ironie>Na, da hast Du dir ja direkt die zuverlässigste aller Quellen rausgesucht</ironie>

Ist denn diese Aussage falsch? Ich habe den Standard nicht zur Hand und sehe es auch nicht ein, den extra wegen dem Thema hier zu kaufen.

Warum so umständlich:

int* zeiger = &array[0];

Wollen wir etwa die Zeigereigenschaft verschleiern? Tststs...
So geht es auch:

int* zeiger = array;

int main()
{  
	int arr[10];
	int* int_ptr = arr;
	arr[0] = -1;
	printf( "%d\n", *arr );
 	printf( "%d %d %d\n", *int_ptr, *arr, arr[0] );
	return 0;
}

LordJaxom

Erbsenzähler schrieb:

Lässt er sich ja auch einsetzen, wenn auch nur eingeschränkt:

Ich wollte darauf hinaus, dass, wenn es ein Zeiger ist, es sich auch als Zeiger einsetzen lässt. Das braucht man nicht extra erwähnen. Dehalb ist die Aussage redundant.

Aber da Du gerade selbst einen Unterschied zwischen Array und Zeiger (neben dem Unterschied der Rückgabe von sizeof) genannt hast, brauchen wir hier eigentlich nicht mehr zu diskutieren.