Copy af char[3000] til struct

kommer an på opbygningen af din text streng. hvordan er den ?
hvis den er 1:1 kan du bruge memcpy, ellers er sscanf en løsning.

den er 1:1 men jeg får fejl de gange jeg har forsøgt med memcpy, vil du ikke komme med memcopy og struct/streng

#include <string.h>
#include <iostream.h>
#include <stdio.h>

struct T
{
    char navn[10];
    char nummer[5];
};
   
int main(int argc, char* argv[])
{
    char test[15] = { 'A', 'R', 'N', 'E', 0, 0, 0, 0, 0, 0, '1', '0', 0, 0, 0 };

    T t;

    memcpy( &t, test, sizeof(T) );

    cout << t.navn << endl << t.nummer << endl;

    return 0;
}

struct svars x1;
char x2[3000];
memcpy(&x1,x2,3000);

bør virke !

Men måske var:

struct svars *x3 = (struct svars)x2;

smartere ?

hvad mener du med den sidste kommentar arne ?

Fordi du så kan bruge x3->kundeid og x3->fejlnr
fuldstændigt ligesom du ellers ville kunne
have brugt x1.kundeid og x1.fejlnr men:
  - du undgår at have 2 gange 3000 bytes i memory
    med samme data (sparer memory)
  - du undgår at kopiere 3000 bytes (sparer CPU tid)

Jeg ked jeg ikke forstår : så her et eksempel :

char tekst[30]
struct besked
{
  char fejlnr[10];
  char felktxt[20];
} fejlrec;

strcpy(tekst,"0123456789Der er sket en fejl");  // simulering af tekststreng

memcpy (&fejlrec,tekst,sizeof(fejlrec);

printf("Nr : %s ",fejrec.nr);

Dette viker ikke, Jeg er ikke med på hvad du helt mener med det sidste, men vil meget gerne lærem så hvis du vil komme med eks.
På forhånd tak

du kan ikke gøre det sådan, der skal også være en nul terminering. dvs.
"streng\0DDDstreng2\0DDDDDDDDDDDDD"

hvor D er en dummy byte for at få offsets til at passe

\0 svarer til en byte med værdien 0 og skal regnes med når der skal afsættes plads.

Der er ikke nogen nul i enden af fejlnr.

Hvis du prøver med:

strcpy(tekst,"012345678"); // kun 9 der skal være plads til nul byte
strcpy(tekst+10,"Der er sket en fejl"); // max. 19 tegn igen p.g.a. nul byte

memcpy (&fejlrec,tekst,sizeof(fejlrec));

printf("%s %s\n",fejlrec.nr,fejlrec.fejltxt);

Så bør du få korrekt svar ud.

Dvs man kan ikke tage en streng og "ligge ovenpå" en structur i c ?

Problemet er at den streng der skal føres over i structuren kommer fra et eksternt program. Er jeg nødsaget til at lave en funktion der splitter strengen up og flytter data)

Mit alternative forslag er:

struct besked *fejlrec_p;

strcpy(tekst,"012345678"); // kun 9 der skal være plads til nul byte
strcpy(tekst+10,"Der er sket en fejl"); // max. 19 tegn igen p.g.a. nul byte

fejlrec_p = (struct besked *)tekst;

printf("%s %s\n",fejlrec_p->nr,fejlrec_p->fejltxt);

Du kan godt ligge data oveni en struct.

Men det virker ikke godt nul byten på den
måde du gerne vil gøre det.

Jeg vil nok anbefale noget i retning af:

strcpy(fejlrec.nr, tekst);
strcpy(fejlrec.fejltxt, tekst+10);

i dit tilfælde.

Og så gøre de 2 felter så store, at der altid
er plads til en nul byte (som strcpy i modsætning til
memcpy sætter ind for dig).

Så jeg bliver nødsaget til på den ene eller anden måde at selv styre og sørge for der kommer 0 terminering i stregen eller i mine felter

det externe program, bestemmer du selv streng indholdet (altså formatet) ?

det er et retursvar fra cpr, som hvist returneres som en buffer på 3000 bytes

du har ikke et eksempel af det den returnerer ? altså alle 3000 tegn ?

nej desværre ikke

Den har sikkert en eller anden for for token så du kan skille de forskellige strenge fra hinanden (f.eks endline). Er det tilfældet, kan du bruge strtok til at skille dem fra hinanden med.

det vil jeg undersøge.... vender tilbage i næste uge, tak for hjælpen pt

Jeg tror dine problemer skyldes at du overfører en struct i en streng. I C er alle strenge (jo) termineret med chr(0) - dvs. alle funktioner i C (og dermed faktisk også i Windows kernen) lavet sådan at de stopper behandlingen af strengen når de når til første chr(0). ('\x0') I dit eksempel betyder det omvendt at printf("Fejl nr. : %s", fejlrec.nr) *IKKE* stopper udskriften når de 10 tegn der egentlig er fejlteksten, er skrevet - men derimod først når den når til chr(0).

Du kan godt får det du har lavet til at fungere (jeg synes i den forbindelse også du skal bruge arne_v's løsning med blot at definere en pointer, og så sætte den til at pege på din string):

#include <stdio.h>

typedef struct
{
  char nr[10];
  char tekst[30];
}      defFejlRec;

int main(void)
{
  char fejlMessage[30] = "0123456789Dette er så teksten";
  defFejlRec *ptrFejlRec = (defFejlRec *)&fejlMessage;

  printf("Fejl nr: %.*s = \'%.*s\'", sizeof(pFejlRec->Nr), pFejlRec->Nr,
                                    sizeof(pFejlRec->Tekst), pFejlRec->Tekst);
  return 0;
}

Bemærk den lille krølle omkring format-specifier til printf ('%.*s') - punktum + stjernen betyder at der maksimalt udskrives det antal bytes fra strengen som angives i parameteren *FØR* selve strengen, altså sizeof(). Herved får du kun skrevet den del af strengen ud, som rent faktisk indeholder henholdvis nr og tekst. (Det er i øvrigt god, defensiv kodeteknik der medvirker til at undgå memory-overskrivninger.)

frostholm - har du fået løst problemet ?