adressbereich auslesen

[tommy (Gast)]

Mahlzeit,
ich möchte gerne werte über einen Adressbereich ermitteln. Habe dabei 
aber Probleme, wo ich nicht weiter komme.
gegeben ist eine Startadresse (als variable) und die länge.
einen Wert auszulesen ist kein Problem

uint64_t* adress = (uint64_t*)(startAddress);
processValue(*adress);

habe gedacht, dass ich dann einfach eine loop über die länge machen kann

for(uint32_t x=0; x<length; x++)
{
  uint64_t* adresse = (uint64_t*)(startAddress+x);
  processValue(*adress);
}

allerdings stürzt zweiteres immer ab. Gibt es eine andere möglichkeit, 
wie ich einen Bereich auslesen kann?

[Einer K. (Gast)]

> uint64_t* adresse = (uint64_t*)(startAddress+x);


uint64_t* adresse = ((uint64_t*)startAddress)+x;

[Dr. Sommer (Gast)]

tommy schrieb:
> allerdings stürzt zweiteres immer ab

Nicht verwunderlich. Du liest 8 Bytes auf Einmal aus, und zwar auch bei 
ungeraden Adressen. Viele Prozessoren können das nur bei Adressen, die 
Vielfache von 4 sind. Sinnlos ist es auch, denn dabei liest du jedes 
Byte 8x aus... Also: Entweder einzelne Bytes auslesen, oder x um 8 statt 
um 1 inkrementieren, oder fufu's Lösung, welche praktisch x*8 auf die 
Adresse addiert statt x.

[Einer K. (Gast)]

Dr. Sommer schrieb:
> oder fufu's Lösung, welche praktisch x*8 auf die
> Adresse addiert statt x.

Suchbegriff: "C Zeigerarithmetik"



Alternativ:

for(uint32_t x=0; x<length; x++)
{
  processValue(x[(uint64_t*)startAddress]);
}

[Stefan F. (Gast)]

> uint64_t* adress

Das ist ein Zeiger auf eine 64bit große Integer Zahl.

> for(uint32_t x=0; x<length; x++)
> {
>  uint64_t* adresse = (uint64_t*)(startAddress+x);
>  processValue(*adress);
> }

Hier versuchst du offensichtlich, über die Bytes zu iterieren. Dann 
sollte der Zeiger aber auch die dazu passende Größe haben. Hier mal drei 
Beispiele:

#include <stdio.h>
#include <stdint.h>

char testDaten[]="Hello World";

void process(uint8_t byte)
{
    printf("%02x=%c\n",byte,byte);
}

int main(int argc, char** argv)
{
    uint8_t* zeiger=(void*)&testDaten;
    for (int i=0; i<5; i++)
    {
        process(zeiger[i]);
    }
    
    zeiger=(void*)&testDaten;
    for (int i=0; i<5; i++)
    {
        process(*zeiger++);
    }
    
    zeiger=(void*)&testDaten;
    for (int i=0; i<5; i++, zeiger++)
    {
        process(*zeiger);
    }
}

[Stefan F. (Gast)]

Hier noch ein Beispiel fpr 63bit Zahlen, falls du das wolltest:

#include <stdio.h>
#include <stdint.h>

uint64_t testDaten[]={111,222,333,444,555};

void process(uint64_t zahl)
{
    printf("%lu\n",zahl);
}

int main(int argc, char** argv)
{
    uint64_t* zeiger=testDaten;
    for (int i=0; i<5; i++)
    {
        process(zeiger[i]);
    }
    
    zeiger=testDaten;
    for (int i=0; i<5; i++)
    {
        process(*zeiger++);
    }
    
    zeiger=testDaten;
    for (int i=0; i<5; i++, zeiger++)
    {
        process(*zeiger);
    }
}

[Stefan F. (Gast)]

Stefanus F. schrieb:
> &testDaten

Misst, das "&" gehört da nicht hin. Funktioniert komischerweise 
trotzdem. Warum eigentlich?