Zeiger Arithmetik



  • Guten Tag,

    ich soll eine Funktion bearbeiten die folgend lautet:

    int check(const int **s)
    

    Nur weiß ich nicht, wie ich die einzelnen Zeiger ansprechen soll, also falls ich z.b. auf ein Feld(2)(5) kommen möchte. Wie erhöhe den ersten Zeiger um 3 und dann zweiten um 6 z.b. . Im Script hab ich nichts gefunden und google gibt bei Zeiger auf Zeiger auch nicht viel aus.

    Vielen dank für die Hilfe im vorraus.


  • Mod

    Ein Array ist kein Zeiger und erst recht ist ein Array von Arrays kein Zeiger auf einen Zeiger. Deine Frage macht daher keinen Sinn.

    Physiker96 schrieb:

    Wie erhöhe den ersten Zeiger um 3 und dann zweiten um 6 z.b. .

    Technisch gesehen ist die Antwort s[3][6] , aber wie gesagt, macht das sicher nicht das was du möchtest.



  • Gut dann stelle ich die Frage anders. Wie kann ich mittels Zeigerarithmetik die einzelen Zeiger ansprechen, was erhöht was, falls der Zeiger auf den Zeiger **p heißt was macht p++ oder was macht *p++?


  • Mod

    Physiker1996 schrieb:

    was macht p++

    Es erhöht p. Was sonst? p zeigt hinterher auf den nächsten Zeiger.

    oder was macht *p++?

    Es erhöht p und dereferenziert den neuen Wert, denn:
    http://en.cppreference.com/w/c/language/operator_precedence


  • Mod

    SeppJ schrieb:

    Physiker1996 schrieb:

    was macht p++

    Es erhöht p. Was sonst? p zeigt hinterher auf den nächsten Zeiger.

    oder was macht *p++?

    Es erhöht p und dereferenziert den neuenalten Wert, denn:
    http://en.cppreference.com/w/c/language/operator_precedence

    FTFY



  • camper schrieb:

    SeppJ schrieb:

    Physiker1996 schrieb:

    was macht p++

    Es erhöht p. Was sonst? p zeigt hinterher auf den nächsten Zeiger.

    oder was macht *p++?

    Es erhöht p und dereferenziert den neuenalten Wert, denn:
    http://en.cppreference.com/w/c/language/operator_precedence

    FTFY

    Besiegt.



  • Physiker96 schrieb:

    int check(const int **s)
    

    Nur weiß ich nicht, wie ich die einzelnen Zeiger ansprechen soll,

    s ist ein Zeiger auf einen const int-Zeiger, also quasi eine Liste von const int-Zeigern.
    Darauf zugreifen tut man einfach mit

    const int *z = s[2];
    

    Du willst aber sicher nicht auf einen Zeiger zugreifen, sondern auf einen Wert aus einem in Matrixform organisierten Speicherbereich.

    Physiker96 schrieb:

    , also falls ich z.b. auf ein Feld(2)(5) kommen möchte.

    Das funktioniert nicht, da dein Zeiger die Spaltendimension deines offenbar vorhandenen Arrays von int-Arrays nicht kennt.
    Jeder Zeiger braucht aber die basierende Typinfo (bei deinem Zeiger also die (Spalten)Anzahl deiner int-Zeilen);
    Außerdem ist dein Code sowieso UB, da die Zeiger inkompatibel sind:

    const int a[3][3]={{1,2,3},{4,5,6},{7,8,9}};
    const int **s = a;        /* inkompatibel,UB; auch ein Zeiger-Cast hilft hier nicht, es bleibt UB */
    const int **s = &a[0][0]; /* inkompatibel,UB; auch ein Zeiger-Cast hilft hier nicht, es bleibt UB */
    

    Physiker96 schrieb:

    Im Script hab ich nichts gefunden

    Das glaube ich dir gerne, dein Lehrer hat nämlich keine Ahnung wenn er solche sinnfreien Aufgaben stellt.

    Physiker96 schrieb:

    google gibt bei Zeiger auf Zeiger auch nicht viel aus

    lol
    Es muss heißen: "google gibt bei Zeiger auf Zeiger auch nicht viel Vernünftiges aus";
    - dann gebe ich dir auch hier recht.

    Für den Zugriff auf multidimensional organisierte Speicherbereiche gibt es prinzipiell 2 Fälle:
    - Dimension ist statisch, d.h. zur Compilezeit bekannt
    - Dimension ist dynamisch, d.h. erst zur Laufzeit bekannt

    #include <stdio.h>
    #include <stdlib.h>
    
    enum{DIM=3};
    
    int zugriff1(int(*a)[DIM],int x,int y)
    {
    /* bei zur Compilezeit bekannter Spaltendimension kann der Typ diese Info liefern */
    	return a[x][y]; 
    }
    
    int zugriff2(void*i,int dim,int x,int y)
    {
    /* bei erst zur Laufzeit bekannter Spaltendimension Nutzung von Zeiger auf VLA + compound literal */
    	return (int(*)[dim]){i}[x][y];
    }
    
    int main() {
    	/* Spaltendimension DIM ist (Compilezeit)konstant */
    	int a[DIM][DIM];
    	for(int j=0;j<DIM;++j)for(int k=0;k<DIM;++k) a[j][k]=j*k;
    
    	for(int j=0;j<DIM;++j,puts(""))for(int k=0;k<DIM;++k)
    		printf("%d ",zugriff1(a,j,k)); /* hier keine Spaltendimension nötig, da im Typ vorhanden */
    
    	/* Spaltendimension ist jetzt dynamisch */
    	int d = DIM;
    	int *i=malloc(d*d*sizeof*i);
    	for(int j=0;j<d;++j)for(int k=0;k<d;++k) i[j*d+k]=j*k;
    
    	for(int j=0;j<d;++j,puts(""))for(int k=0;k<d;++k)
    		printf("%d ",zugriff2(i,d,j,k));
    
    	free(i);
    	return 0;
    }
    

    http://ideone.com/Lug9Bk


Log in to reply