Wie Arrays kopieren (ohne C-Funktionen)?

int Number[]={1,2,3,4,5}; 
int NewNumber[5];

sollen ins NewNumber[5] übertragen werden.

NewNumber[0]=Number[0] //1
NewNumber[1]=Number[1] //2
...
NewNumber[4]=Number[4] //5

Wie macht man das?

SG1

Mit einer Schleife.

Ah super, vielen Danke. Hat geklappt.
Dass ich nicht darauf kam und lieber jedes Element ohne Schleife einzel zuordnen wollte ...

for(index=0; index<5;index++){
NewNumber[index]=Number[index];
}

Wenn Number[] mindestens so gross ist wie NewNumber[]:

memcpy(NewNumber,Number,sizeof(NewNumber));

Tschau
Uwe

Sorry, ich hatte "ohne C-Funktionen" zu spät gesehen...

Tschau
Uwe

Wutz

typedef struct {int x[5];} T;
int Number[]={1,2,3,4,5};
int NewNumber[5];

*(T*)NewNumber = *(T*)Number;

Wutz schrieb:

typedef struct {int x[5];} T;
int Number[]={1,2,3,4,5};
int NewNumber[5];

*(T*)NewNumber = *(T*)Number;

Es geht noch einfacher

typedef struct{	int x[5];}T;
T Number = {{1,2,3,4,5}};
T NewNumber;

NewNumber = Number;

Und damits jeder nachvollziehen kann - auch Anfänger - hier ein complierbares Progrämmchen:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct
{
	int x[5];
}T;
int main(void) 
{
	T Number = {{1,2,3,4,5}};
	T NewNumber = {{5,4,3,2,1}};
	printf("%d\n", NewNumber.x[0]);
//	
	NewNumber = Number;
//
	printf("%d\n", NewNumber.x[0]);
	return 0;
}

Wutz

lol.
Trottel.
Du hast weder die Fragestellung noch meine Lösung verstanden.
Du plapperst nur irgendwo aufgeschnapptes Halbwissen nach und glaubst mit diesem Unsinn andere Leute beglücken zu müssen.
Scheint momentan mal wieder Hochzeit für solche "Beglücker" zu sein.

__jb__

Wutz schrieb:

typedef struct {int x[5];} T;
int Number[]={1,2,3,4,5};
int NewNumber[5];

*(T*)NewNumber = *(T*)Number;

Ist den immer sizeof(T) == sizeof(Number) gegeben?
Ich frage wegen dem Speicher-Alignment nach, nicht dass das struct größer ist als der eigentliche Speicherbereich. Oder andersherum gefragt, ist das Array Number[] auch dem Speicher-Alignment "unterworfen"?

Wutz schrieb:

lol.
Trottel.
Du hast weder die Fragestellung noch meine Lösung verstanden.
Du plapperst nur irgendwo aufgeschnapptes Halbwissen nach und glaubst mit diesem Unsinn andere Leute beglücken zu müssen.
Scheint momentan mal wieder Hochzeit für solche "Beglücker" zu sein.

Vielleicht könnte seine Heiligkeit Wutz wenigstens dazuschreiben was falsch ist damit wir Normalsterblichen etwas lernen...

name42 schrieb:

Vielleicht könnte seine Heiligkeit Wutz wenigstens dazuschreiben was falsch ist damit wir Normalsterblichen etwas lernen...

Ist doch ziemlich offensichtlich, dass da jetzt zwei struct T benutzt werden, statt zwei int[5] .

Wutz

jb schrieb:

Ist den immer sizeof(T) == sizeof(Number) gegeben?
Ich frage wegen dem Speicher-Alignment nach, nicht dass das struct größer ist als der eigentliche Speicherbereich. Oder andersherum gefragt, ist das Array Number[] auch dem Speicher-Alignment "unterworfen"?

sizeof hat mit Alignment nichts zu tun.
int[] und struct können prinzipiell unterschiedliche Alignments haben, aber nicht in meiner o.g. Lösung da garantiert ist, dass das Alignment einer struct nie kleiner ist als das des größten Member-Alignments.
Und da mein struct nur ein Element hat, nämlich int[] ist gesichert, dass bei dem Zeigercast nebst anschließender Dereferenzierung kein UB auftreten kann.
Aber du hast recht mit dem Hinweis denn viele C-Programmierer casten Zeiger einfach so OHNE dabei ans Alignment (und damit UB) zu denken.

volkard

Wutz schrieb:

int[] und struct können prinzipiell unterschiedliche Alignments haben, aber nicht in meiner o.g. Lösung da garantiert ist, dass das Alignment einer struct nie kleiner ist als das des größten Member-Alignments.
Und da mein struct nur ein Element hat, nämlich int[] ist gesichert, dass bei dem Zeigercast nebst anschließender Dereferenzierung kein UB auftreten kann.
Aber du hast recht mit dem Hinweis denn viele C-Programmierer casten Zeiger einfach so OHNE dabei ans Alignment (und damit UB) zu denken.

Aber kann beim = was passieren? Falls T größere aligned ist. Dann könnte der = sich vielleicht drauf verlassen, und der Compiler vielleicht auf Itanium ein Fließkommaregister mißbrauchen, was nur mit dem großen Alignment klappt, oder?

Wutz

Links steht das gleiche Alignment wie rechts, ebenso ist beiderseits von = die gleiche Speicherplatzgröße vorhanden, da geht nichts schief.
Bei reinen Zuweisungen mit = spielt Alignment keine Rolle (mehr), UB in Folge von missalignten (schreibt man das so?) Adressauflösungen kommt nur bei Zeiger-Dereferenzierung vor, und die ist in diesem Fall schon zuvor durchlaufen worden.
UB bei reinen Zuweisungen kann nur durch Zugriff auf undefinierten Speicherbereich vorkommen:

typedef struct{int i[1];} T1;
typedef struct{int i[2];} T2;
T1 t1;
T2 t2;
*(T2*)&t1 = t2; /* UB durch undef. Speicherzugriff, da alle struct-Zeiger immer kompatibel sind und UB somit nicht verursachen können */

Der Klassiker für UB ist aber wie schon gesagt das Alignment bei Zeigerdereferenzierung, und ein Missalignment lässt sich entgegen landläufiger Meinung niemals durch einen Zeiger-Cast bereinigen (es müsste der Zeigerwert d.h. die Adresse geändert werden). Oft geht UB durch Missalignment aber mit UB durch undef. Speicherzugriff einher aber wie schon erwähnt erst anschließend:

char c;
double d;
*(double*)&c = d; /* UB durch Alignment (char* vs double*) UND Speicherzugriff */

Wenn man Glück hat, erhält man zur Laufzeit einen Buserror o.ä. bei solchen durch Zeigercasts erzeugten Alignment-Inkompatibilitäten.