Adressen Rückgabe

Gast #2775444 
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 Langsamer Modus Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Melden Danke
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
Antwort Zitieren Bearbeiten Löschen Melden Danke 
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 Melden Danke
Gast 
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 Melden Danke 
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 Melden Danke
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.
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 Melden Danke 
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 Melden

    
      
      
        Danke
        
      
    
  









    

    

    

       Thread beobachten


    

    
        


Antwort schreiben







  

    

      Eine eigene Frage?
      Dieser Thread ist über 14 Jahre alt.
      Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.
    

    

      Neuen Thread starten
    

    
Eine Lösung, Ergänzung oder Rückmeldung zu diesem Thread? Dann antworte hier.

  








  


    
    
      

    
    
    

    



    

    

      
      
      
      

  Formatierung
  
    
    
  • [c]C-Code[/c]
    • 
      
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
    • 
      
  • [math]Formel in LaTeX-Syntax[/math]
    • 
      
  • [[Titel]] – Link zu einem Artikel
    • 
      
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen
    • 
  

  
Mehr zur Formatierung




    



    

      
      

      

        Längeren Sourcecode als Anhang, nicht in den Text.
        JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF.
        Siehe Bildformate.
      


      
    
        
      


      

      

    


      

        

          
Dein Name und deine E-Mail-Adresse

          
Schon registriert?
            Anmelden

        


        

          
          
          
        


        

          
          
          
          
Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

        


      


        




    
Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.