VerständnisProblem

myouness27

hallo zusammen,
habe das folgende Programm geschrieben:

1. #include<stdio.h>
2. #include<string.h>
3. #include <stdlib.h>
4. int main()
5. {
6. #define sample 10
7. short buffer[sample] = {1,2,3,4,5,6,7,8,9,10};
8. short *pt1 ;
9. for(pt1=buffer;pt1<buffer+sample;pt1++)
10. printf("Bufferinhalt = %d\n",*pt1);
11. }

es soll mir einfach den Ihnalt vom buffer ausgeben
das tut es auch, obwohl ich der Meinung bin, dass Zeile 9 falsch ist denn pt1 ist vom Typ short ( short hat eine bytegrösse von 2) deswegen habe ich am Anfang : for(pt1=buffer;pt1<buffer+2*sample;pt1++) aber das hat nicht das erwartet Ergebnis geliefert hat jemand eine Erklärung dafür ??
ich habe noch eine kleine Frage und zwar möchte ich wissen , ob ich den inhalt von buffer mit memcpy() kopieren kann ? normallerweise dient memcpy zum kopieren von zeichenketten das verwirt mich ein wenig.

Vielen dank

Borgolte

myouness27 schrieb:

1. #include<stdio.h>
2. #include<string.h>
3. #include <stdlib.h>
4. int main()
5. {
6. #define sample 10
7. short buffer[sample] = {1,2,3,4,5,6,7,8,9,10};
8. short *pt1 ;
9. for(pt1=buffer;pt1<buffer+sample;pt1++)
10. printf("Bufferinhalt = %d\n",*pt1);
11. }

Den Code kann keine Sau lesen

MFK

myouness27 schrieb:

hat jemand eine Erklärung dafür ??

Ja.

Stichwort "Zeigerarithmetik".

...wenn sich sonst keiner erbarmt

memcpy heisst memcpy, weil man damit was tun kann?
richtig! mem kopieren!

Doch doch, zeile 9 ist richtig.
Du hast 10 short Elemente, pt1 = buffer zeigt bei Beginn auf das erste Element.
Der Zeiger kann jetzt noch 9 mal um zwei Byte erhöht werden, damit er gültig bleibt.
Das erreichst du korrekt mit pt1<buffer+sample.
Die Anweisung pt1++ lässt den Zeiger automatisch jeweils um zwei Byte vorrücken,
weil der Compiler automatisch "weiß", das short 2 Byte hat.

Jo, und mit memcpy kannst du alles kopieren, was drinsteht.
Siehe Deklaration von memcpy:
void *memcpy( void *dest, const void *src, size_t count );
Du kannst dir dest und src auf den gewünschten Zeigertypen casten.

Gruß,
p.

nur eine bemerkung am rande: short ist nicht immer 2 bytes... ändert natürlich nix am code, wollt ich nur anmerken... *klugscheiß,duck,weg*

proggingmania schrieb:

Die Anweisung pt1++ lässt den Zeiger automatisch jeweils um zwei Byte vorrücken,
weil der Compiler automatisch "weiß", das short 2 Byte hat.

Das ist mir neu, dachte das geht nur mit Char-Variablen (da die 1Byte groß sind).
Ist nun pt1++; im Falle von short äquivalent mit pt1+=1; oder mit pt1+=2;?

short schrieb:

nur eine bemerkung am rande: short ist nicht immer 2 bytes... ändert natürlich nix am code, wollt ich nur anmerken... *klugscheiß,duck,weg*

Ich dachte int wäre das "Problem", auf 32Bit-Architekturen so groß wie long und auf 16Bit-Architekturen so groß wie short? Wie sieht das eigentlich bei C++ && C# aus, mit der größe von int?

Nicht "int" ist das Problem, sondern dass der C und auch C++ Standard nur Verhältnisse festlegt bei den Datentypen, also short <= int <= long wobei int in aller Regel so groß ist wie die Prozessorbreite - heute meistens noch 32 Bit. Theoretisch gibts auch die Möglichkeit dass short/int/long alle gleich groß sind. Wäre standardkonform. Deshalb ist bei Pointerarithmetik das ++ so definiert das wirklich die richtige Größe benutzt wird, weil sonst solch ein Code zwischen verschiedenen Plattformen unwartbar wäre.

C#, bzw. .Net dagegen definieren wirklich feste Datentypen Int16, Int32, Int64 wo die Größe festgelegt ist.

onoz schrieb:

proggingmania schrieb:

Die Anweisung pt1++ lässt den Zeiger automatisch jeweils um zwei Byte vorrücken,
weil der Compiler automatisch "weiß", das short 2 Byte hat.

Das ist mir neu, dachte das geht nur mit Char-Variablen (da die 1Byte groß sind).
Ist nun pt1++; im Falle von short äquivalent mit pt1+=1; oder mit pt1+=2;?

Allgemein gilt: Hat ein Zeiger vom Typ foo die Adresse 0x0, dann ist foo+1 = 0x0 + sizeof(foo). Im Fall eines 2-byte-Short also 0x2.

onoz schrieb:

short schrieb:

nur eine bemerkung am rande: short ist nicht immer 2 bytes... ändert natürlich nix am code, wollt ich nur anmerken... *klugscheiß,duck,weg*

Ich dachte int wäre das "Problem", auf 32Bit-Architekturen so groß wie long und auf 16Bit-Architekturen so groß wie short? Wie sieht das eigentlich bei C++ && C# aus, mit der größe von int?

Ein short wird üblicherweise 2 Byte groß sein. Es gibt aber z.B. Architekturen, bei denen ein Byte nicht 8 Bit breit ist, sondern vielleicht 24 Bit. Dann wäre ein char 1 Byte groß, ein short dürfte aber auch ein Byte groß sein, da 2^24-1 ausreichend groß ist um die Vorderungen des Standards (minimaler Wertebereich) zu erfüllen. Betrifft die wenigsten. Ist halt so Wissen mit dem man ganz toll posen kann.

onoz schrieb:

Das ist mir neu, dachte das geht nur mit Char-Variablen (da die 1Byte groß sind).
Ist nun pt1++; im Falle von short äquivalent mit pt1+=1; oder mit pt1+=2;?

Hast du z.B. einen Zeiger pt auf long double, und ist long double auf deinem Rechner 10 Bytes lang, dann zeigt der Zeiger nach Ausführung von pt++
auf die nachsten 10 Byte. Der Compiler kennt die Länge seiner Datentypen.
Siehe auch Kommentar von TactX.

Gruß,
p.