Adressen Rückgabe

[Tobi (Gast)]

Hallo Leute,

ich beschäftgie mich gerade mit Zeigern und bin auf ein Problem 
gestoßen, das ich nicht verstehe. Wieso bekomme ich 2 verschiedene 
Adressen für die Zeiger ptr1 und ptr2? Die müssen doch gleich sein.

test.h

typedef const struct MyStruct 
  { 
    const char *temp;      
  } MyStructure;  

const char test1[]; 
const char test2[]; 
const char test3[]; 
 
static MyStructure MyTest[];

test.c

#include "stdio.h"

const char test1[] = {"test 1"}; 
const char test2[] = {"test 2"};
const char test3[] = {"test 3"};

static MyStructure MyTest[] =
  {      
    {test1}, 
    {test2}, 
    {test3}, 
  };

const char *ptr1 = test1;
printf("Adresse von ptr1: %p \n", ptr1); 
       
const char *ptr2 = (const char*)&MyTest[0];
printf("Addresse von ptr2: %p ", ptr2);

[Tobi (Gast)]

ups beim Kopieren #include "test.h" in test.c vergessen

[Peter II (Gast)]

Tobi schrieb:
> Die müssen doch gleich sein.

nein, denke ich nicht.

Versucht mal mit

const char *ptr2 = (const char*)&MyTest[0]->temp;

ich blicks gerade aber auch nicht vollständig, das ist sehr verwirrend 
was du willst, es fehlt auf den Fall zu zugriff auf das Member der 
Struct

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

Die Adressen eines Strings (test1) und eines Pointers auf diesen String 
(&MyTest[0]) sind logischerweise verschieden.

[Karl H. (kbuchegg)]

Tobi schrieb:

> Adressen für die Zeiger ptr1 und ptr2? Die müssen doch gleich sein.

Wie kommst du denn da drauf?

in MyTest[0]->temp steht derselbe wert wie in ptr1, nämlich die Adresse 
von test1. Aber MyTest[0] und test1 sind 2 verschiedene Variablen und 
haben daher auch verschiedene Adressen.

Du verwechselst gerade die Adresse einer Variablen selber mit ihrem 
Inhalt.

[Tobi (Gast)]

Mit dieser Zeile

const char *ptr2 = (const char*)&MyTest[0];

will auf die einzelnen Member Test1 bis Test3 mittels Adressen zugreifen 
können. Es ist nur ein Problem, wenn die Adressen ptr1 und ptr2 nicht 
übereinstimmen. Dann weiss ich nicht, wie ich sonst ausser direkt auf 
test1[] bis test3[] zu greifen kann. Mittels Struct könnte ich auf 
Adressen via Index auslesen - was ungemein praktisch wäre für mich.

[Peter II (Gast)]

die Frage ist doch wozu du noch die struct brauchst?

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

Tobi schrieb:
> Mit dieser Zeile
> const char *ptr2 = (const char*)&MyTest[0];
> will auf die einzelnen Member Test1 bis Test3 mittels Adressen zugreifen
> können.

Ist zwar grässlich, aber wenn du dich schon erhängen willst, dann mit
const char *ptr2 = *(const char**)&MyTest[0];

Oder, was wohl eher bezweckt ist
const char **ptr2 = (const char**)&MyTest[0];
und nun ptr2[0] mit ptr1 vergleichen.

Wie schon angedeutet: Damit steckst du deinen Kopf in die Schlinge und 
eines unbekannten Tages öffnet sich unvermutet der Boden unter dir.

[Tobi (Gast)]

Mein Ziel ist es, Zahlen-Arrays (für math. Operation) bzw. 
Strings(Text-Befehle zum Terminal) mittels struct zusammenzuführen und 
über Zeiger zugreifen.

Array1[] = {...} /* Zahlen inhaltlich zusammengehörend  */
Array2[] = {...} /* Zahlen inhaltlich zusammengehörend, aber  Array1 != Array2 */

String1[] = {"pos"};  /* Positionsabfrage und Controller gibt einen Wert zurück */
String2[] = {"res"};  /* Controller neustarten */
etc.

Das sieht ja echt gruselig aus. Irgendwie stimmen die Adressen immer 
noch nicht überein. Für ptr2 bekomme ich 0-Wert zurück.

const char *ptr2 = *(const char**)&MyTest[0];

[Peter II (Gast)]

Tobi schrieb:
> mittels struct zusammenzuführen und
> über Zeiger zugreifen.

eine struct mit nur einem element ist aber meist unnötig.

Warum nicht einfach:

char* liste[] = { "test1", "test2","test3" }

[Karl H. (kbuchegg)]

Tobi schrieb:
> Mit dieser Zeile
>

> const char *ptr2 = (const char*)&MyTest[0];
>

>
> will auf die einzelnen Member Test1 bis Test3 mittels Adressen zugreifen
> können.

Ich denke, es wir Zeit das mal aufzulösen.

&MyTest[0] ist die Adresse von MyTest selber. Das ist aber nicht das was 
du willst! DU willst den Inhalt von MyTest[0] haben! Das ist ebenfalls 
eine Adresse, nämlich die Adresse4 von test1, die du vorher dort 
reingeschrieben hast.

Aber lass uns erst mal von vorne anfangen
Du hast

const char test1[] = {"test 1"}; 
const char test2[] = {"test 2"};
const char test3[] = {"test 3"};

              test1
              +---+---+---+---+---+---+---+
              | t | e | s | t |   | 1 | \0|
              +---+---+---+---+---+---+---+

              test2
              +---+---+---+---+---+---+---+
              | t | e | s | t |   | 2 | \0|
              +---+---+---+---+---+---+---+
 

              test3
              +---+---+---+---+---+---+---+
              | t | e | s | t |   | 3 | \0|
              +---+---+---+---+---+---+---+

weiters hast du

const char *ptr1 = test1;

ok. damit sieht die ganze Sache so aus

              test1
              +---+---+---+---+---+---+---+
     +------->| t | e | s | t |   | 1 | \0|
     |        +---+---+---+---+---+---+---+
     |
     |        test2
     |        +---+---+---+---+---+---+---+
     |        | t | e | s | t |   | 2 | \0|
     |        +---+---+---+---+---+---+---+
     |
     |
     |        test3
     |        +---+---+---+---+---+---+---+
     |        | t | e | s | t |   | 3 | \0|
     |        +---+---+---+---+---+---+---+
     |
     +----------+
                |
  ptr1          |
  +-------+     |
  |  o----------+
  +-------+

Ausserdem hast du noch

static MyStructure MyTest[] =
  {      
    {test1}, 
    {test2}, 
    {test3}, 
  };

damit landest du bei

    MyTest
    +---------------------+
    |   +----------------+|
    |   | temp:  o-------------------------+
    |   +----------------+|                |
    +---------------------+                |
    |   +----------------+|                |
    |   | temp:  o---------------------+   |
    |   +----------------+|            |   |
    +---------------------+            |   |
    |   +----------------+|            |   |
    |   | temp:  o-----------------+   |   |
    |   +----------------+|        |   |   |
    +---------------------+        |   |   |
                                   |   |   |
   +-------------------------------+   |   |
   |  +--------------------------------+   |
   |  |  +---------------------------------+
   |  |  |
   |  |  |
   |  |  |
   |  |  |
   |  |  |    test1
   |  |  +--->+---+---+---+---+---+---+---+
   | +------->| t | e | s | t |   | 1 | \0|
   | ||       +---+---+---+---+---+---+---+
   | ||
   | ||       test2
   | |+------>+---+---+---+---+---+---+---+
   | |        | t | e | s | t |   | 2 | \0|
   | |        +---+---+---+---+---+---+---+
   | |
   | |
   | |        test3
   +-|------->+---+---+---+---+---+---+---+
     |        | t | e | s | t |   | 3 | \0|
     |        +---+---+---+---+---+---+---+
     |
     +----------+
                |
  ptr1          |
  +-------+     |
  |  o----------+
  +-------+

Zum Schluss machst du noch

const char *ptr2 = (const char*)&MyTest[0];

                    ptr2
                    +-------------+
+-------------------------o       |
|                   +-------------+
|
|
|   MyTest
|   +---------------------+
+-> |   +----------------+|
    |   | temp:  o-------------------------+
    |   +----------------+|                |
    +---------------------+                |
    |   +----------------+|                |
    |   | temp:  o---------------------+   |
    |   +----------------+|            |   |
    +---------------------+            |   |
    |   +----------------+|            |   |
    |   | temp:  o-----------------+   |   |
    |   +----------------+|        |   |   |
    +---------------------+        |   |   |
                                   |   |   |
   +-------------------------------+   |   |
   |  +--------------------------------+   |
   |  |  +---------------------------------+
   |  |  |
   |  |  |
   |  |  |
   |  |  |
   |  |  |    test1
   |  |  +--->+---+---+---+---+---+---+---+
   | +------->| t | e | s | t |   | 1 | \0|
   | ||       +---+---+---+---+---+---+---+
   | ||
   | ||       test2
   | |+------>+---+---+---+---+---+---+---+
   | |        | t | e | s | t |   | 2 | \0|
   | |        +---+---+---+---+---+---+---+
   | |
   | |
   | |        test3
   +-|------->+---+---+---+---+---+---+---+
     |        | t | e | s | t |   | 3 | \0|
     |        +---+---+---+---+---+---+---+
     |
     +----------+
                |
  ptr1          |
  +-------+     |
  |  o----------+
  +-------+

So.
Das ist dein Szenario, das du aufgebaut hast.
Warum erwartest du jetzt, dass ptr1 und ptr2 als gleich gewertet werden. 
Schau dir dir Grafik an. Die Pfeile, die in ptr1 bzw. ptr2 losgehen, 
münden an komplett unterschiedlichen Stellen. ptr1 und ptr2 sind daher 
ganz einfach nicht gleich.
Der Pfeil, der in ptr1 beginnt, endet bei test1
Der Pfeil, der in ptr2 beginnt, endet beim ersten Array Element in 
MyTest.

Logisch, dass die beiden nicht gleich sein können.


Und nochwas:
Wenn du das casten musst, dann machst du mit Sicherheit etwas falsch. 
Pointer Umcasten ist die absolute Ausnahme und sollte bei dir NIE 
notwendig sein.