Zeiger auf Zeiger

cHillb3rT

Ich hab mal eine Frage:
Nehmen wir mal an, dass wir 3 Daten hätten, also Länge, Breite und Fläche eines Raumes, diese drei Werte sind in bestimmten Speicherbereichen gespeichert, die ich mit Pointern ansprechen kann.
- Prinzip:
*Zimmerdaten = Länge;
*Zimmerdaten+1 = Breite;
*Zimmerdaten+2 = Fläche;

Das ist somit ein Zimmer und das Zimmer ist ein Zeiger-Zeiger: **Zimmer. Jetzt möchte ich die Zimmer ansprechen können:
- Prinzip:
**Zimmer = Erstes Zimmer;
**Zimmer+1 = Zweites Zimmer;
**Zimmer+2 = Drittes Zimmer;

Beim Überschreiben der Zimmerdaten überschreibt er mir die Daten immer in den Speicherbereich des ersten Zimmers. Wie kann ich die Speicherbereiche der anderen Zimmer genau ansprechen und woher weiß der Zeiger-Zeiger für die Zimmer, wieviele Bytes zwischen ihm und dem nächsten Zeiger-Zeiger liegen ?

AJ

cHillb3rT schrieb:

Das ist somit ein Zimmer und das Zimmer ist ein Zeiger-Zeiger: **Zimmer. Jetzt möchte ich die Zimmer ansprechen können:
- Prinzip:
**Zimmer = Erstes Zimmer;
**Zimmer+1 = Zweites Zimmer;
**Zimmer+2 = Drittes Zimmer;

Beschäftige dich mal mit der Reihenfolge der Operatoren in C. Der * (als Zeigeroperator) kommt vor dem +. D. h. der Compiler wertet erst **Zimmer aus und danach zählt er erst 1 bzw. 2 dazu. -> Lösung: Klammerung oder gleich mit [] arbeiten (würde auf jeden Fall besser aussehen als mit etlichen Sternen davor).

Ein Zeiger auf Zeiger kannst du dir vorstellen wie ein Array (dynamische Speicherreservierung jetzt schon mal vorausgesetzt). Du hast im Prinzip 2 Dimensionen. Die erste Dimension bzw. das erste Array enthält Zeiger und auf dieses "Array" zeigt dein Zeiger auf Zeiger.

Zeiger-Zeiger
     |
----------------------------
| Zeiger | Zeiger | Zeiger |
----------------------------

Du hast also eine Reihe von Zeigern. Diese Zeiger zeigen natürlich auch wieder auf einen Speicherbereich bzw. ein Array (dynamisch allokiert).

Zeiger-Zeiger
    |
    | ----------------------------
    \-| Zeiger | Zeiger | Zeiger |
      ----|--------|--------|-----
          |        |        | ---------------------------
          |        |        \-| Länge | Breite | Fläche |
          |        |          ---------------------------
          |        | ---------------------------
          |        \-| Länge | Breite | Fläche |
          |          ---------------------------
          | ---------------------------
          \-| Länge | Breite | Fläche |
            ---------------------------

Alles klar?

DarthZiu

Schickes Bild!!!

cHillb3rT

Beschäftige dich mal mit der Reihenfolge der Operatoren in C. Der * (als Zeigeroperator) kommt vor dem +. D. h. der Compiler wertet erst **Zimmer aus und danach zählt er erst 1 bzw. 2 dazu. -> Lösung: Klammerung oder gleich mit [] arbeiten (würde auf jeden Fall besser aussehen als mit etlichen Sternen davor).

Sry hatte es nur falsch hingeschrieben, da ich die Zeiger-Zeiger schon richtig geklammert habe, damit sie funktionieren.

Beispiel:

piZimmer[i][0] = *piZimmerdaten; 
piZimmer[i][1] = *(piZimmerdaten+1); 
piZimmer[i][2] = *(piZimmerdaten+2); 	
C/C++ Code:	
piZimmer[i][0] = *piZimmerdaten; 
piZimmer[i][1] = *(piZimmerdaten+1); 
piZimmer[i][2] = *(piZimmerdaten+2);

So versuche ich in einer For-Schleife eingebaut, die Werte dann zu übergeben.... Beim ersten Mal klappt das auch, aber dann die nächsten Male muss es verändert werden.
Wie muss ich jetzt den Kram umschreiben, damit der nächste Speicherbereich benutzt wird und nicht der alte in dem schon Werte drin stehen ?!?

_________________

AJ

@chillbert
i um 1 erhöhen??

Ohne Drumherum kann ich da wenig zu sagen.

cHillb3rT

Ich hab mich in der ganzen Zeit mit anderen Problemen beschäftigt und komme nun zu diesem Thema zurück, denn Zeiger-Zeiger beschäftigt mich noch immer

Also ich will mit einem Zeiger-Zeiger auf die Zimmer verweisen, die beliebig in einer Wohnung sind. Nehmen wir an ich hab 3 Zimmer in meiner Wohnung, dann müssen die Zeiger-Zeiger jeweils auf die einzelnen Daten der Zimmer zeigen.

Der Zeiger zeigt auf die Daten der Zimmer: Breite, Länge und Fläche.

piZimmer = Erstes Zimmer
piZimmer+1 = Zweites Zimmer
piZimmer+2 = Drittes Zimmer

piZimmerdaten = Breite
piZimmerdaten+1 = Länge
piZimmerdaten+2 = Fläche

Wie kann ich das realisieren, das in einer Schleife nicht immer wieder die Werte von Breite, Länge und Fläche für ein Zimmer geschrieben werden, weil damit hab ich derzeit noch Probleme.

Habt ihr da Ideen und btw ich weiß, dass es mit Strukturen besser geht, weil damit hab ich es schon hinbekommen und es hängt nur noch bei der Zeiger-Zeiger-Version.

AJ

Was hast du denn bisher? Mit den paar Codestücken kann man nur wenig anfangen und eine Komplettlösung ist sicherlich nicht Sinn der Sache ;).

cHillb3rT

#include <stdio.h>
#include <malloc.h>
#include <conio.h>

int main(int argc, char* argv[])
{
  int *pZahl = (int*)malloc(3*sizeof(int));
  int **ppZimmer,
      zimmeranzahl,
      i;

  printf("Bitte geben sie ein wieviele Zimmer in ihrer Wohnung sein sollen: \n");
  scanf("%d", &zimmeranzahl);
  ppZimmer = (int*)malloc(zimmeranzahl*sizeof*pZahl);

  for (i = 0; i < zimmeranzahl; i++)
  {
    printf("Bitte geben sie die Breite ihres Zimmers ein \n");
    scanf("%d", pZahl);
    printf("Bitte geben sie die Laenge ihres Zimmers ein \n"),
    scanf("%d", pZahl+1);
    printf("Die Flaeche des Zimmers betraegt: \n");
    *(pZahl+2) = *pZahl * *(pZahl+1);
    printf("%d", *(pZahl+2));
    /* Dieser Bereich soll auf das nächste Zimmer verweisen if (i != zimmeranzahl-1)
    {
      ppZimmer++;
      pZahl = ppZimmer;
    }*/
  }

soweit... so gut.... ;/

cHillb3rT

Also die Frage, die ich immer noch habe ist:
Wie kann ich die einzelnen Zimmerdaten (in diesem Falle hab ich sie pZahl genannt) ansprechen, damit ich sie am Ende ausgeben kann.
Der Code, der oben drüber steht, ist nur ein Teilstück des Programms und meine Intension war, dass das ppZimmer immer den Anfang des Speicherbereichs für ein Zimmer darstellt.

Somit kann ich pZahl, was in dem Falle die Breite wäre die Speicheradresse von ppZimmer geben. Aber dann kommt das große Problem, denn die anderen Zeiger pZahl+1 und pZahl+2 zeigen noch auf andere Werte. Wie kann ich das in den Griff bekommen ?

AJ

Warum machst du es dir so schwer?

...
int ** alleZimmer;
int anzZimmer = 0;

//eingabe der Zimmeranzahl
...

alleZimmer = malloc(anzZimmer * sizeof(int *));
for(int i = 0; i < anzZimmer; ++i)
{
   alleZimmer[i] = malloc(3 * sizeof(int));

   printf("Breite: ");
   scanf("%d", alleZimmer[i]); //bzw. &alleZimmer[i][0] oder alleZimmer[i]+0

   ...
}
...