Pointer auf array

[unregistered (Gast)]

Ich komme gerade nicht wirklich zurecht und leider wüsste ich auch nciht 
unter welchem Stichwort google die Antwort weiß...

In einem 2d-Array merke ich mir Koordinaten

uint16_t coord[][2] = { {x0,y0},{x1,y1},... };

jetzt möchte ich einen Pointer haben, der auf ein Wertepaar zeigt, also 
ein uint16_t[2].
Ich dachte das ginge so, ergibt aber ein 'initilization from 
incompatible pointer type'.

uint16_t (*pcoord)[2] = coord[0];


*pcoord[0] ----> x0

*(pccord+1)[0] ----> x1

Wie geht das?

[Karl H. (kbuchegg)]

unregistered schrieb:

> Wie geht das?

Am besten geht das, wenn du dein Repertoir an Datenstrukturen noch um 
Strukturen erweiterst.

Eine Zusammenfassung von 2 uint16_t (also 2 Koordinaten-Werten), nennst 
du einen 'Punkt'.

struct Punkt_
{
  uint16_t x;
  uint16_t y;
};

noch ein typedef dazu, um die struct ohne viel Tippaufwand verwenden zu 
können

typedef struct Punkt_ Punkt;

und du kannst ein Array von Punkten(!) erstellen

Punkt coord[] = {
  { 10, 12 },
  {  8,  4 },
  { 45, 68 },
  ..
};

Ein Pointer auf einen bestimmten Punkt ist dann ganz einfach ein

 Punkt* somePoint = &coord[5];

Nicht alles wird vernünftig als Array modelliert. Wenn zwischen Dingen 
ein starker Zusammenhalt besteht, wie zb zwischen Vorname und Nachnahme, 
oder Tag/Monat/Jahr oder Stunde/Minute/Sekunde oder .... oder eben auch 
der X und Y Koordinate einer Position dann modelliert man diesen 
Zusammenhalt besser als Struktur und erzeugt dann erst davon ein Array.

Das hat dann auch den Vorteil, dass man in eine Funktion zb direkt einen 
Punkt reingeben kann (oder einen Pointer darauf) und somit mit 
projektbezogenen Begriffen und Datentypen operiert.

Punkt add( Punkt* a, Punkt* b )
{
  Punkt result;
  result.x = a->x + b->x;
  result.y = a->y + b->y;
}

Punkt sub( Punkt* a, Punkt* b )
{
  Punkt result;
  result.x = a->x + b->x;
  result.y = a->y + b->y;
}

double distance( Punkt* start, Punkt* end )
{
  Punkt diff = sub( end, start );
  return sqrt( diff->x * diff->x + diff->y * diff->y );
}

void draw( Punkt* start, Punkt* end )
{
  DrawLine( start->x, start->, end->x, end->y );
}

int main()
{
  Punkt Diff = sub( &coord[4], &coord[8] );  // Berechne die Differenzz vom Punkt 4 zum Punkt 8
  double distance( &coord[2], &coord[1] );   // Berechne die Distanz vom Punkt 2 zum Punkt 1

  draw( &coord[3], &coord[4] ); // zeichne eine Linie von Punkt 3 zum Punkt 4
}

[(prx) A. K. (prx)]

uint16_t (*pcoord)[2] = &coord[0];

[unregistered (Gast)]

Da hast du natürlich Recht.

Und für meinen Seelenfrieden - wie würde denn das originale Problem 
notiert werden? int (*p)[2] ist doch ein Pointer auf einen Vektor, oder? 
-sollte- das nicht funktionieren?

Ich habe mich da sicher etwas verzettelt und danke dir für die Antwort, 
aber wurmt mich jetzt schon.

[unregistered (Gast)]

ok gerade gelesen, danke an Karl Heinz und A.K.

Und Schande über mich -.-

&coord[0] hatte ich tatsächlich versucht mit Fehler. Schleuerweise hatte 
ich das obige Array const notiert.

Ich bin aber froh über eure Ratschläge und irgendwie auch, daß ich nicht 
völlig daneben lag.

[Karl H. (kbuchegg)]

unregistered schrieb:
> Da hast du natürlich Recht.
>
> Und für meinen Seelenfrieden - wie würde denn das originale Problem
> notiert werden? int (*p)[2] ist doch ein Pointer auf einen Vektor, oder?

Das passt schon.

Von innen nach aussen gelesen

      p        p ist
     *p        p ist ein Pointer
    (*p)[      p ist ein Pointer auf ein Array
    (*p)[2]    p ist ein Pointer auf ein Array der Länge 2
int (*p)[2]    p ist ein Pointer auf ein Array der Länge 2 von int


> -sollte- das nicht funktionieren?

Dein Problem ist die rechte Seite der Initilisierung.


ABer du solltest wirklich die Sichtweise des 'Im Notfall kann ich immer 
ein mehrdimensionales Array benutzen' zugunsten von Strukturen aufgeben. 
Da beginnt das Modellieren eines Problems.

[unregistered (Gast)]

Nehme ich mir zu Herzen. Danke