int a[42];
// ... Elemente in a belegen ...
int b[42];
b = a; // kopieren

Stimmt das?

Wie siehts aus, wenn das Array in einem Struct drin ist?

struct A
{
    int v[42];
}

int main()
{
    A foo;
    foo.v[0] = 123; // usw.

    A bar = foo;
}

Enthält bar nun eine Kopie des Arrays aus foo? Oder teilen die sich gar einen Speicherbereich? Wie standardkonform ist das ganze?

Danke

http://www.cplusplus.com/reference/clibrary/cstring/memcpy/

memcpy(b, a, sizeof(int) * sizeof(a))

Das funktioniert allerdings nur bei Arrays von POD-Typen. Wenn du ein Array von ausgewachsenen Objekten hast, fliegst du damit gewaltig auf die Nase.

theliquidwave schrieb:

memcpy(b, a, sizeof(int) * sizeof(a))

Das funktioniert allerdings nur bei Arrays von POD-Typen.

Nicht mal das. das sizeof(int)* hat da nämlich nichts zu suchen. So einfach kann's gehen, mit dem sich-in-den-Fuß-schießen.

std::array<int, 42> a; 
// ... Elemente in a belegen ... 
std::array<int, 42> b; 
b = a; // kopieren

Die Arrays verwende ich in der Form nicht freiwillig, sie sind durch das Interface einer externen Lib vorgegeben, auf die ich keinen Einfluss habe.

Die Arrays verwende ich in der Form nicht freiwillig, sie sind durch das Interface einer externen Lib vorgegeben, auf die ich keinen Einfluss habe.

Wage ich zu bezweifeln. Zeig mal das Interface, du kannst außerhalb des Interface alles andere benutzen...

Wer verwendet noch ernsthaft Arrays?

std::array<int, 42> a; 
// ... Elemente in a belegen ... 
std::array<int, 42> b; 
b = a; // kopieren

Endlich wieder einmal einer, der nicht sofort std::vector voschlägt.

Wer verwendet noch ernsthaft Arrays?

std::array<int, 42> a; 
// ... Elemente in a belegen ... 
std::array<int, 42> b; 
b = a; // kopieren

C++0x-Features darf ich leider nicht verwenden. Okay ... Man könnte Boost.Array nehmen

pumuckl schrieb:

berndbernd schrieb:

Die Arrays verwende ich in der Form nicht freiwillig, sie sind durch das Interface einer externen Lib vorgegeben, auf die ich keinen Einfluss habe.

Wage ich zu bezweifeln. Zeig mal das Interface, du kannst außerhalb des Interface alles andere benutzen...

Lib-Header:

struct A
{
    int v[42];
    // ... weitere variablen ...
};

void libFunc1(A* a);
void libFunc2(A* a);

Mein Code:

int main()
{
    A foo;
    foo.v[0] = 123; // usw.

    A bar = foo;

    libFunc1(&foo);
    libFunc2(&bar); // Aufruf mit Kopie von foo, da A sowohl Eingangs- als auch Ausgangsdaten beinhaltet

    // ... weitere Dinge mit foo und bar tun ...
    return 0;
}

//Edit: Fixed Adressoperator

(Außerdem: Gibt es tatsächlich jemanden, dessen Libraries solche Array-Structs verwenden?)

Und das geht so durch den Compiler? Die Funktionen erwarten einen Zeiger auf die struct, du übergibst ihnen aber die struct(s) selbst per Wert.

Natürlich nicht. Tippfehler. Habs gefixt. :p

CStoll schrieb:

(Außerdem: Gibt es tatsächlich jemanden, dessen Libraries solche Array-Structs verwenden?)

Ja (Lib stammt aus dem C-Umfeld)

C++0x-Features darf ich leider nicht verwenden. Okay ... Man könnte Boost.Array nehmen

Oder std::tr1::array . Auch selbst schreiben wäre noch besser, sobald man die Funktionalität ein paar Mal braucht