Come posso concatenare due variabili di tipo struct in c ++? [chiuso] - c ++, c, puntatori, struct, memcpy

Ho cercato per un po 'di concatenare alcune variabili di tipo struct (ho definito) in una più grande. Quello che ho ottenuto è fondamentalmente così:

Ho una struttura e due variabili di tipostruct **. Dichiaro una terza struct C e voglio concatenare A e B in C. Quello che ho provato è qualcosa di simile a questo (non ho il codice di fronte a me in questo momento, quindi scriverò qualcosa di molto simile con alcuni nomi modificati perché non li ricordo.

struct** A, B;
struct** C;

(Conosco A e B mentre li ricevo chiamando un'altra funzione)

Alloco memoria per C in questo modo.

C = (struct**)malloc(sizeof(A)+sizeof(B));

E muovo A e B con memcpy come questo.

memcpy(&C, &A, sizeof(A));
memcpy(&C + sizeof(A), &C, sizeof(B));

È ovvio che quello che ho fatto non è correttocome sembra, dopo tutto questo C contiene solo A. Sono abbastanza sicuro che il problema sia da "**", non riesco a gestire bene i puntatori ai puntatori. Qualcuno può darmi qualche consiglio riguardo al mio problema? Anche io non voglio usare Handles, devo usare memcpy / memmove.

---

[aggiorna dal commento:]

Le mie strutture sono tutte dello stesso tipo.

risposte:

3 per risposta № 1

Hai già un struct A a; e a struct B b; definito da qualche parte. Per concatenarli in a struct C tu lo fai:

struct A a;
struct B b;

struct C{
struct A a;
struct B b;
};

struct C c;
c.a = a;
c.b = b;

Nessun puntatore o memcpy necessario.

Modifica: dal a e b sono dello stesso tipo, puoi in qualche modo accorciarlo a questo:

struct Something a, b;

struct C{
struct Something[2];
};

struct C c;
c[0] = a;
c[1] = b;

In C ++ si farebbe qualcosa del genere:

using C = std::array<Something, 2>;
C c{a, b};

---

1 per risposta № 2

Basta usare un array.

assumendo struct A è definito un array sullo stack

struct A a1 = {...}; /* some initialisation here */
struct A a2 = {...}; /* more initialisation here */

struct A a[2];
a[0] = a1;
a[1] = a2;

o assegnarlo dinamicamente:

struct A * pa = malloc(2 * sizeof *pa);
if (NULL != pa)
{
pa[0] = a1;
pa[1] = a2;

/* use pa */

free(pa);
}
else
{
/* handle malloc error */
}

---

0 per risposta № 3

Bene, per prima cosa, il tuo codice ha un bug:

memcpy(&C, &A, sizeof(A));
memcpy(&C + sizeof(A), &C, sizeof(B));

Probabilmente dovrebbe essere

memcpy(&C, &A, sizeof(A));
memcpy(&C + sizeof(A), &B, sizeof(B));

Stavi copiando C in C piuttosto che in B.

Secondo, se ti trovi mai a giocare coni puntatori come questo probabilmente hanno un problema di progettazione da qualche parte lungo le linee: se si vuole REALMENTE unire due strutture insieme, perché la struct C non contiene semplicemente entrambe le struct A e B?

Se davvero vuoi che la struct C non abbia niente botprimitivi, amico, basta fare il lavoro per assegnare ogni campo individualmente. È davvero tanto lavoro? Immagino che abbia senso generalizzarlo se ti aspetti che questi campi cambino molto. Ma questa sorta di "codice intelligente" è il tipo esatto di cose che ti morderanno nel culo in seguito.

---