Adresse eines Pointers sichern in C

[TOM (Gast)]

@all,

wie ich einen Inhalt einer Speicheradresse auslese ist mir klar aber
kann ich auch die Adresse selbst an der der Pointer steht
auslesen/sichern konnte bis jetzt nichts finden alles beschreibt nur
das  Auslesen des Inhaltes einer Adresse.

TOM

[Ralf (Gast)]

Gegenfrage: Warum willst du die Adresse sichern? Du kannst den Pointer
doch jederzeit wieder mit dem & (= Adress-of-Operator) auf eine
Variable zeigen lassen. Die einzige Ausnahme ist meines Wissens, wenn
du mit malloc/calloc arbeitest, dann darfst du die Adresse nicht mehr
ändern, sonst ist der allokierte Speicher futsch...

Ralf

[Rufus Τ. F. (rufus)]

Vielleicht meint Tom ja sowas:

  char Variable;
  char* Pointer;
  char** PointerPointer;

  Pointer = &Variable;

  PointerPointer = &Pointer;

"PointerPointer" enthält die Adresse, an der die Variable "Pointer"
gespeichert ist, ganz genau so, wie "Pointer" die Adresse enthält, an
der die Variable "Variable" gespeichert ist.

[TOM (Gast)]

@Ralf,

wenn ich eine Variable deklariere wir diese irgentwo geschrieben und
ich möchte gerne wissen an welcher Adresse die Variable steht.
Ist im Prinzip nur eine Verständnisfrage bzw. möchte ich nur wissen ob
es überhaupt möglich ist die Adresse der Variablen auszugeben.

TOM

[Hegy (Gast)]

Ich bin mir sicher, es war der format specifier %p.

Also geht den so:

#include <stdio.h>
#include <stdlib.h>
                   
int main(void)     
{             
  int i, j = 1;
  char *str, val[3] = {0};
  long double ld[3] = {91382302.293022232};
                                           
  str = calloc(1, 1);                      
                     
  printf("Adr. von\n i=%p, \n j=%p, \n str=%p, \n val=%p, \n
ld[0]=%p, \n ld[2]=%p\n", &i, &j, str, val, &ld[0], &ld[2]);
                                                                       
                                                 
  return 0;                                                            
                                                 
}

Ergebnis:
Adr. von
 i=0xbffff6d8,
 j=0xbffff6dc,
 str=0x8049780,
 val=0xbffff710,
 ld[0]=0xbffff6e0,
 ld[2]=0xbffff6f8

Bug: Es fehlt ein free(str); im Code.

[peter dannegger (Gast)]

@TOM

"ich möchte gerne wissen an welcher Adresse die Variable steht."


Warum möchtest Du das erst umständlich zur Laufzeit wissen ?

Guck doch einfach nach dem Linken ins Listfile.


Peter

[Martin (Gast)]

Hallo Leute!

Ich habe den Beitrag gelesen und das Beschriebene erfolgreich 
ausgetestet.

Ich benötige ebenfalls die Zahl der Adresse eines Feldes, weil ich auf 
eine Funktion zugreife, die diese Adresse als 32-Bit-Integer benötigt 
und
es nicht möglich ist, einfach den Zeiger zu übergeben.

sprintf(feld2,"%p",&feld);

Dies funktionierte recht gut. Nur jetzt müsste ich den String von Feld2 
auf einen 32-Bit-Integer konvertieren.
Da es sich hierbei jedoch um einen Mikrocontroller handelt, finde ich 
diese Vorgangsweise sehr Ressourcen-Raubend.

Gibt es eine andere Möglichkeit?
Ich hätte folgende Zuweisung probiert, leider ohne Erfolg:

unsinged long xx;

xx=&feld;

Danke für eure Antworten.


Tschüss
Martin

[Karl H. (kbuchegg)]

Martin wrote:

> Ich benötige ebenfalls die Zahl der Adresse eines Feldes, weil ich auf
> eine Funktion zugreife, die diese Adresse als 32-Bit-Integer benötigt
> und
> es nicht möglich ist, einfach den Zeiger zu übergeben.

Na, dann caste deine Adresse doch einfach zurecht.

>
> sprintf(feld2,"%p",&feld);
>
> Dies funktionierte recht gut.

Glaub ich nicht. Das macht was völlig anderes.
Es generiert eine Textrepräsentierung des Zahlenwertes der Adresse
und legt diese Repräsentierung (aka: String) in einem Character
Array ab, dessen Adresse in feld2 steht.

Mit der Umwandlung einer Adresse in einen 32-Bit Integer hat das
nichts zu tun.

> Ich hätte folgende Zuweisung probiert, leider ohne Erfolg:
>
> unsinged long xx;
>
> xx=&feld;

So ohne weiteres geht das nicht, weil ja eine Adresse erst mal
kein unsigned long ist.
Da du aber weißt, dass du genau das möchtest: Den Zahlenwert
der Adresse als unsigned long auffassen, kannst du dem Compiler
mitteilen, er soll man sein Typsystem vergessen und die Zuweisung
einfach machen:

  xx = (unsigned long)&feld;


PS: Du brauchst Literatur. Eine Sprache wie C kann man nur bis zu
einem gewissen Grad (der schnell erreicht ist) durch Versuch und
Irrtum erlernen.

[Robert W. (rweber)]

Das sollte funktionieren:

  char feld;
  unsigned long ptr;

  ptr=(unsigned long)&feld;

  printf("%p, %x\n", &feld, ptr);

[Robert W. (rweber)]

ups, zu langsam.

[marcel (Gast)]

hallo

ich würde dies probieren:

int *x;
printf("%d",&x);

nun wird die adresse von x dezimal ausgegeben.

& ist der Adressoperator

[Karl H. (kbuchegg)]

marcel wrote:
> hallo
>
> ich würde dies probieren:
>
> int *x;
> printf("%d",&x);
>
> nun wird die adresse von x dezimal ausgegeben.

Aber nur dann, wenn sizeof(int) == sizeof(int*)
Was zwar auf einem 16-Bit System sehr oft der Fall ist, du
aber keine Garantie dafür hast.
Bei printf lautet der Formatspezifier für Adressen %p. Den
sollte man dann auch benutzen.

Im Übrigen geht es dem OP aber auch gar nicht um printf, sondern
um die Übergabe einer Adresse an eine Funktion, wobei die Funktion
keinen Pointer erwartet sondern einen unsigned long (warum auch
immer).

[Martin (Gast)]

Hallo Leute!

Vielen Dank für die Ratschläge und Lösungen.

Danke auch für eure Lösung Karl heinz Buchegger und Robert Weber.
Genau nach der habe ich gesucht.

Tschüss
Martin