Struktur kopieren

[Stef (Gast)]

Hallo alle zusammen, ich habe ein Anfängerproblem und hoffentlich kann 
mehr jemand von euch helfen.

Ich habe eine Struktur, besser gesagt einen Zeiger darauf:

channel_t *pchn

nun muss ich aus verschiedenen Umständen heraus die Daten dieser 
Struktur, oder besser gesagt Teile davon, in eine andere Struktur 
kopieren.
Ich schreibe in C und weiß, dass es Anfängersachen sind, doch im Netz 
finde ich kein passendes Beispiel dafür und mein Buch ist zu ungenau.

Danke

[Scarface (Gast)]

int i;
channel_t *newp;


for(i = 0; i < SIZEOF(*pchn);i++)
{
*(newp+1) = *(pchn+i);
}

[Hans (Gast)]

Du musst einfach eine neue Struktur definieren und die Werte 
übergeben!!!

[Scarface (Gast)]

// So war es eigentlich gemein

int i;
channel_t *newp;


for(i = 0; i < SIZEOF(channel_t);i++)
{
*(newp+1) = *(pchn+i);
}

[stef (Gast)]

Nja, das mit den Wertenübergeben weiß ich eh Hans und
Danke an Scarface.


Mal sehen,ob es funzt

[AVR-User (Gast)]

wie wärs mit memcpy? Sollte am einfachsten sein...

[stef (Gast)]

Hallo nocheinmal,

könnte jemand das Beispiel vielleicht ein wenig genauer angeben???

[AVR-User (Gast)]

channel_t *pchnOriginal;
channel_t *pchnKopie;

... //Zeiger auf gültigem Speicherbereich zeigen lassen

memcpy(pchnKopie, pchnOriginal, sizeof(channel_t));

Siehe: 
http://www.galileo-press.de/openbook/c_von_a_bis_z/c_022_007.htm#RxxobKap02200704002B791F039198

[Karl H. (kbuchegg)]

Warum so kompliziert.
Strukturen können wie andere Datentypen auch (mit Ausnahme von
Arrays) zugewiesen werden:

  channel_t  original;
  channel_t  copy;

  copy = original;

Wenn du einen Pointer auf etwas hast, dann liefert dir ein *
vor dem Pointer die Daten:

  channel_t *newp;
  channel_t  copy;

  copy = *newp;

oder auch

  channel_t *newp;
  channel_t *copyp;

  copyp = malloc( sizeof( *copyp ) );
  *copyp = *newp;

oder

  channel_t original;
  channel_t *copyp;

  copyp = malloc( sizeof( *copyp ) );
  *copyp = original;

Alles völlig analog zu dem Fall dass du einen int Pointer hast. Kein
Grund da auf memcpy oder gar Schleifen auszuweichen.

[Karl H. (kbuchegg)]

Scarface wrote:
> // So war es eigentlich gemein
>
> int i;
> channel_t *newp;
>
>
> for(i = 0; i < SIZEOF(channel_t);i++)
> {
> *(newp+1) = *(pchn+i);
> }


Ist trotzdem Käse
* die Idee dahinter mag noch angehen, ist aber unnötig kompliziert
* das funktioniert so nicht.
  Hausaufgabe: Was wird durch  newp + 1 adressiert?
               Was wird durch  newp + i adressiert?
               (Hinweis: Es ist nicht das i-te Byte der Struktur)

[AVR-User (Gast)]

Manchmal sieht man halt vor lauter Bäumen den Wald nicht :D

[Karl H. (kbuchegg)]

Und ausserdem reden wir alle an der Frage des OP vorbei:

> nun muss ich aus verschiedenen Umständen heraus die Daten
> dieser Struktur, oder besser gesagt Teile davon

Teile davon.

typedef struct {
  int  WertA;
  int  WertB;
  int  WertC;
  char WertD;
  double WertE;
  char Text[20];
} channel_t;


...

  channel_t * pchn;
  channel_t   copy;

  ...

  copy.WertB = pchn->WertB;
  copy.WertD = pchn->WertD;
  strcpy( copy.Text, pchn->Text );

> und mein Buch ist zu ungenau.

Dann schmeiss es weg und kauf dir ein besseres :-)
Das sind wirklich Basics.

[Karl H. (kbuchegg)]

Karl heinz Buchegger wrote:
>

>   copy.WertB = pchn->WertB;
>   copy.WertD = pchn->WertD;
>   strcpy( copy.Text, pchn->Text );
>

>

Jetzt muesste vom OP eigentlich eine Frage kommen.
Ich nehm sie mal vorweg, weil mein Compilerlauf im
Hintergrund zuende geht und ich dann wieder an die
Arbeit muss.

Die Frage lautet:
Warum greift man einmal mit einem . und das andere mal
wieder mit einem -> auf Strukturelemente zu?

Nun. Grundsätzlich kann man immer mit einem . auf ein
Strukturelement zugreifen.

   copy.WertB

nur ist pchn ein Pointer, und dieser Pointer muss dereferenziert
werden, damit man an die Daten kommt auf die der Pointer zeigt.
Wie immer wird ein Pointer mit einem vorangestellten * derferenziert:

   *pchn.WertB

Jetzt gibt es da aber ein Problem: Die Operatorenpriorität in C
wurde so festgelegt, dass . eine höhere Priorität hat als ein *
Das heist aber auch, der Compiler sieht den letzten Ausdruck
als:

   *(pchn.WertB)

und das kann klarerweise nicht funktionieren, weil pchn ja ein
Pointer ist und ein Pointer hat nun mal keinen WertB. Man
muesste das also so schreiben:

   (*pchn).WertB

und in der Tat ist das die korrekte Syntax.
    pchn               Nimm den Pointer
   *pchn               dereferenziere ihn (das bringt uns zu Struktur)
   (*pchn).WertB       und aus der Struktur wähle den Member WertB

Nur: Das ist eine grausliche Syntax und schlecht zu tippen.
Daher hat man die Syntax um das 'Zeichen'  ->  erweitert.

    a->b    <==>   (*a).b

[Scarface (Gast)]

> Hausaufgabe: Was wird durch  newp + 1 adressiert?
 >              Was wird durch  newp + i adressiert?
 >              (Hinweis: Es ist nicht das i-te Byte der Struktur)

newp + 1 sollte newp + i heissen.

nein. Es ist nicht das i-te Byte sondern das (i-1)-te Byte der Struktur. 
---> Deshalb auch die Abfrage i < size und nicht i >= size...

[Karl H. (kbuchegg)]

Scarface wrote:
>> Hausaufgabe: Was wird durch  newp + 1 adressiert?
>  >              Was wird durch  newp + i adressiert?
>  >              (Hinweis: Es ist nicht das i-te Byte der Struktur)
>
> newp + 1 sollte newp + i heissen.
>
> nein. Es ist nicht das i-te Byte sondern das (i-1)-te Byte der Struktur.
> ---> Deshalb auch die Abfrage i < size und nicht i >= size...

Ist es nicht.
Du wärst gut beraten in einem Buch deiner Wahl über Pointerarithmetik
und wie das mit dem konkreten Pointertyp zusammenhängt nachzulesen.

[Scarface (Gast)]

>Ist es nicht.
>Du wärst gut beraten in einem Buch deiner Wahl über Pointerarithmetik
>und wie das mit dem konkreten Pointertyp zusammenhängt nachzulesen.

Wie so soll es nicht das (i-1)-te byte sein, bzw welches soll es denn 
sonst sein? Ich habe eine Adresse, in newp gespeichert, welcher ich ein 
offset hinzufüge, i, und mit * auf den Wert in dieser Adresse 
verweise...

[Scarface (Gast)]

>Ist es nicht.
>Du wärst gut beraten in einem Buch deiner Wahl über Pointerarithmetik
>und wie das mit dem konkreten Pointertyp zusammenhängt nachzulesen.

Wie so soll es nicht das (i-1)-te byte sein, bzw welches soll es denn 
sonst sein? Ich habe eine Adresse, in newp gespeichert, welcher ich ein 
offset hinzufüge, i, und mit * auf den Wert in dieser Adresse 
verweise...

Und ja, Pointerarithmetik habe ich nachgelesen, sollte stimmen.

[Rufus Τ. F. (rufus)]

Angenommen, Deine Struktur sei 0x10 Bytes groß.

channel_t *newp;

Dieser Pointer zeige nun auf eine Struktur an der Adresse 0x2000.

Wohin zeigt dann (newp + 1)?

NEIN, es zeigt NICHT auf die Adresse 0x2001, sondern auf die Adresse 
0x2010.

[Scarface (Gast)]

wieso nicht?


*(newp + 1) --> *(0x2000 + 1) -->*(0x2001) !!!

Was ergibt dann deiner Meinung nach 0x2000 + 1 ?? 0x2010??

[AVR-User (Gast)]

Der Pointer wird um eine Struktur bzw. Typengröße verschoben. Und 
channel_t ist nun mal nicht 1 Byte groß... Bei char mag das stimmen.

[Scarface (Gast)]

NEIN! newp repräsentiert eine Adresse, und diese wird um eins erhöht,

Ausführlicher beschrieben:

int x;

x = newp;
newp = x+1;

[Karl H. (kbuchegg)]

Scarface wrote:
> wieso nicht?

:-)
Weil sonst die ganze Arrayindizierung, so wie sie in C definiert
ist nicht mehr funktionieren würde.


  datatyp * pPtr;


  *( pPtr + Offset )  <==>
  *( (unsigned char*)pPtr + ( Offset * sizeof( datatyp ) ) )   <==>
  pPtr[Offset]

Mit anderen Worten

  channel_t * pPtr;

  *(pPtr + 4)   liefert dir die Daten der 5. Struktur deren
  Anfangsadresse bei pPtr liegt. Ist also äquivalent zu
  pPtr[4]
  (Wenn den das worauf pPtr zeigen würde auch wirklich ein
   Array aus channel_t Objekten wäre)

Daten der '5. Struktur', nicht das 5. Byte

Was du wolltest, müsstest du so schreiben:

  int i;
  channel_t *newp;

  for(i = 0; i < sizeof(channel_t); i++)
  {
    *( ( (unsigned char*)newp) + i) = *( ( (unsigned char*) pchn) + i );
  }

das geht, weil per Definition sizeof(unsigned char) gleich 1 ist.

[Karl H. (kbuchegg)]

Scarface wrote:
> NEIN! newp repräsentiert eine Adresse, und diese wird um eins erhöht,
>
> Ausführlicher beschrieben:
>
> int x;
>
> x = newp;
> newp = x+1;

Sorry für die rüden Worte.
Aber das ist Bullshit. Pointerarithmetik funktioniert nicht so
in C.

[Scarface (Gast)]

Ja, stimmt, das Typecasting ist mir irgendwie entfallen, auf meinen 
DSP's verwende ich eigentlich nur longs, da 32 Bit, daher bin ich dem 
Problem noch nie begegnet. Aber danke, doch noch was sinnvolles gelernt 
heute...