Wie kann ich dereferenzieren auf Größe basieren?

Question

Ich versuche, der Wert auf die durch eine Adresse zu drucken, aber das Problem ist, ich brauche diesen Zeiger dereferenzieren auf der Größe basiert, die mir übergeben wird. So etwas von dieser Art:

void print(Address addr, Int size) {
...
}

Ich bin ein wenig verwirrt darüber, wie dies zu erreichen. Kann jemand Punkt mich in die richtige Richtung?

EDIT: Ok, so denke ich:

char p[80];
memset(p, '\0', 80);
memcpy(p, addr, size);

Und dann dereferenzieren als * p. Wenn es ein besserer Weg, oder eine richtige Art und Weise ist, lassen Sie es mich wissen,

Answer 1

Ihre Frage ist sehr unklar. Wenn Sie meinen, Sie beliebige binäre Daten von der Adresse weitergegeben Dump wollen, möchten Sie so etwas wie:

void print(const unsigned char *addr, size_t size)
{
    while (size--) printf("%.2x", *addr++);
}

Oder wenn Sie meinen Sie Zeichendaten drucken möchten, die nicht nullterminierten, versuchen Sie:

void print(const char *addr, int size)
{
    printf("%.*s", size, addr);
}

Answer 2

Wenn es eine Zahl ist, die ich nehme an, es ist, werden Sie so etwas wie dieses brauchen:

int n=0;
if (size>sizeof(int)) { return; //int is too small };
for (int i=0;i<size;i++) {
  ((char*)(&n))[sizeof(int)-(i+1)] = ((char*)addr)[size-(i+1)];
}
printf("%d",n);

Answer 3

Sie können eine switch-Anweisung in der Routine verwendet werden:

switch (size) {
   case 1: print( *(char*)pointer); break;
   case 2: print( *(short*)pointer); break;
   case 4: print( *(long *)pointer); break;
   case 8: print( *(__int64*)pointer); break;
   default: puts( "unsupported);
}

( "print" ist eine Routine ganze Zahlen in verschiedenen Größen zu drucken, vielleicht C ++ Polymorphismus)

Eine anspruchsvolle Lösung zu verwenden ist eine C ++ Vorlage z.B. Verwendung eines Parametertyp Integer, die durch den Istgröße Typen beim Aufruf substituiert wird. Diese Routine kann dann wirken auf die Größe von Integer Variablen (die von 1 bis 8 oder mehr variieren können, wenn Sie mehr ganze Zahlen selbst implementieren). Dieser Nachteil dieses Ansatzes besteht darin, dass der Compiler für jede Art von Argument einer Routine-Instanz erzeugt und Logik abhängig von der Größe für einige Tests auf „immer wahr“ Bedingungen führen wird. Ein einfacher Ausweg ist immer den längsten Typen zu verwenden integer man erwarten würde.