Adressen Rückgabe

Tobi Gast #2775444
Lesenswert?
• ▲
▼ 
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
1
typedef const struct MyStruct 

2
  { 

3
    const char *temp;      

4
  } MyStructure;  

5


6
const char test1[]; 

7
const char test2[]; 

8
const char test3[]; 

9
 

10
static MyStructure MyTest[];


test.c
1
#include "stdio.h"

2


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

4
const char test2[] = {"test 2"};

5
const char test3[] = {"test 3"};

6


7
static MyStructure MyTest[] =

8
  {      

9
    {test1}, 

10
    {test2}, 

11
    {test3}, 

12
  };

13


14
const char *ptr1 = test1;

15
printf("Adresse von ptr1: %p \n", ptr1); 

16
       

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

18
printf("Addresse von ptr2: %p ", ptr2);
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Peter II Gast #2775457
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2775474
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Tobi Gast #2775478
Lesenswert?
• ▲
▼ 
Mit dieser Zeile
1
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
(prx) A. K. #2775490
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Tobi Gast #2775524
Lesenswert?
• ▲
▼ 
Mein Ziel ist es, Zahlen-Arrays (für math. Operation) bzw. 
Strings(Text-Befehle zum Terminal) mittels struct zusammenzuführen und 
über Zeiger zugreifen.
1
Array1[] = {...} /* Zahlen inhaltlich zusammengehörend  */

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

3


4
String1[] = {"pos"};  /* Positionsabfrage und Controller gibt einen Wert zurück */

5
String2[] = {"res"};  /* Controller neustarten */

6
etc.


Das sieht ja echt gruselig aus. Irgendwie stimmen die Adressen immer 
noch nicht überein. Für ptr2 bekomme ich 0-Wert zurück.
1
const char *ptr2 = *(const char**)&MyTest[0];
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2775550
Lesenswert?
• ▲
▼ 
Tobi schrieb:
> Mit dieser Zeile
>
1
> const char *ptr2 = (const char*)&MyTest[0];

2
>

>
> 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

1
const char test1[] = {"test 1"}; 

2
const char test2[] = {"test 2"};

3
const char test3[] = {"test 3"};

1
              test1

2
              +---+---+---+---+---+---+---+

3
              | t | e | s | t |   | 1 | \0|

4
              +---+---+---+---+---+---+---+

5


6
              test2

7
              +---+---+---+---+---+---+---+

8
              | t | e | s | t |   | 2 | \0|

9
              +---+---+---+---+---+---+---+

10
 

11


12
              test3

13
              +---+---+---+---+---+---+---+

14
              | t | e | s | t |   | 3 | \0|

15
              +---+---+---+---+---+---+---+



weiters hast du
1
const char *ptr1 = test1;

ok. damit sieht die ganze Sache so aus
1
              test1

2
              +---+---+---+---+---+---+---+

3
     +------->| t | e | s | t |   | 1 | \0|

4
     |        +---+---+---+---+---+---+---+

5
     |

6
     |        test2

7
     |        +---+---+---+---+---+---+---+

8
     |        | t | e | s | t |   | 2 | \0|

9
     |        +---+---+---+---+---+---+---+

10
     |

11
     |

12
     |        test3

13
     |        +---+---+---+---+---+---+---+

14
     |        | t | e | s | t |   | 3 | \0|

15
     |        +---+---+---+---+---+---+---+

16
     |

17
     +----------+

18
                |

19
  ptr1          |

20
  +-------+     |

21
  |  o----------+

22
  +-------+


Ausserdem hast du noch
1
static MyStructure MyTest[] =

2
  {      

3
    {test1}, 

4
    {test2}, 

5
    {test3}, 

6
  };

damit landest du bei
1
    MyTest

2
    +---------------------+

3
    |   +----------------+|

4
    |   | temp:  o-------------------------+

5
    |   +----------------+|                |

6
    +---------------------+                |

7
    |   +----------------+|                |

8
    |   | temp:  o---------------------+   |

9
    |   +----------------+|            |   |

10
    +---------------------+            |   |

11
    |   +----------------+|            |   |

12
    |   | temp:  o-----------------+   |   |

13
    |   +----------------+|        |   |   |

14
    +---------------------+        |   |   |

15
                                   |   |   |

16
   +-------------------------------+   |   |

17
   |  +--------------------------------+   |

18
   |  |  +---------------------------------+

19
   |  |  |

20
   |  |  |

21
   |  |  |

22
   |  |  |

23
   |  |  |    test1

24
   |  |  +--->+---+---+---+---+---+---+---+

25
   | +------->| t | e | s | t |   | 1 | \0|

26
   | ||       +---+---+---+---+---+---+---+

27
   | ||

28
   | ||       test2

29
   | |+------>+---+---+---+---+---+---+---+

30
   | |        | t | e | s | t |   | 2 | \0|

31
   | |        +---+---+---+---+---+---+---+

32
   | |

33
   | |

34
   | |        test3

35
   +-|------->+---+---+---+---+---+---+---+

36
     |        | t | e | s | t |   | 3 | \0|

37
     |        +---+---+---+---+---+---+---+

38
     |

39
     +----------+

40
                |

41
  ptr1          |

42
  +-------+     |

43
  |  o----------+

44
  +-------+


Zum Schluss machst du noch
1
const char *ptr2 = (const char*)&MyTest[0];

1
                    ptr2

2
                    +-------------+

3
+-------------------------o       |

4
|                   +-------------+

5
|

6
|

7
|   MyTest

8
|   +---------------------+

9
+-> |   +----------------+|

10
    |   | temp:  o-------------------------+

11
    |   +----------------+|                |

12
    +---------------------+                |

13
    |   +----------------+|                |

14
    |   | temp:  o---------------------+   |

15
    |   +----------------+|            |   |

16
    +---------------------+            |   |

17
    |   +----------------+|            |   |

18
    |   | temp:  o-----------------+   |   |

19
    |   +----------------+|        |   |   |

20
    +---------------------+        |   |   |

21
                                   |   |   |

22
   +-------------------------------+   |   |

23
   |  +--------------------------------+   |

24
   |  |  +---------------------------------+

25
   |  |  |

26
   |  |  |

27
   |  |  |

28
   |  |  |

29
   |  |  |    test1

30
   |  |  +--->+---+---+---+---+---+---+---+

31
   | +------->| t | e | s | t |   | 1 | \0|

32
   | ||       +---+---+---+---+---+---+---+

33
   | ||

34
   | ||       test2

35
   | |+------>+---+---+---+---+---+---+---+

36
   | |        | t | e | s | t |   | 2 | \0|

37
   | |        +---+---+---+---+---+---+---+

38
   | |

39
   | |

40
   | |        test3

41
   +-|------->+---+---+---+---+---+---+---+

42
     |        | t | e | s | t |   | 3 | \0|

43
     |        +---+---+---+---+---+---+---+

44
     |

45
     +----------+

46
                |

47
  ptr1          |

48
  +-------+     |

49
  |  o----------+

50
  +-------+


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.

  





  

    Antwort Zitieren Bearbeiten Löschen Beitrag melden
  









    

    

       Thread beobachten


    

        


Antwort schreiben




  
Bitte melde dich an, um einen Beitrag zu schreiben.

  

  
Bestehender Account



  

    

      

        
        
      

      

        
        
      

    


    

      
      
    




  
oder

  Mit Google-Account einloggen





  
Noch kein Account?

  
Die Registrierung ist kostenlos und dauert nur eine Minute.

  Jetzt registrieren