Array um kopieren

Danke für eure schnelle Antwort!

Das Problem ist jedoch, das ich mit keinen Schleifen und keinem memcpy arbeiten darf!

Aufgabenstellug:

"Übersetzen Sie die Typdefinition und die Prozedur in gleichwertige Datentypen und Routinen in C. Verwenden Sie keine Schleifen und kein memcpy. Beachten Sie, dass Zuweisungen an Variablen vom Typ Feld vorkommen."

Ist eine alte Klausuraufgabe gewesen!

Mit freundlichem Gruß

David R.

c.rackwitz

ähm, "Feld" als klasse anlegen und eine tauschfunktion reinimplementieren. intern (in der klasse) werden dann einfach nur die pointer (des eigenen objekts und eines per by reference übergebenen) vertauscht.

net 0

PAD schrieb:

Methode 1 Schnell braucht aber ein zusätzliches Feld

int tausche(int *feld1, int *feld2, int AnzElem);
{
int *temp
temp=malloc(aizeof(int)*AnzElem); // Fehlerbehandlung wegen der Übersichtlichlkeit weggelassen, muß aber sein
memcpy(temp,feld1,AnzElem);
memcpy(feld1,feld2,AnzElem);
memcpy(feld2,temp,AnzElem);
}

schnell? das glaube ich nicht.
'memcpy' macht jedesmal 'AnzElem' schleifendurchläufe und das drei mal.
auch wenn's AnzElem/4 durchläufe + ein bisschen mehr braucht, weil's dwords kopiert, ist es bestimmt langsamer als die version mit nur einer schleife

c.rackwitz schrieb:

ähm, "Feld" als klasse anlegen und eine tauschfunktion reinimplementieren. intern (in der klasse)

OK, ich würde sagen so würde das funktionieren, aber es soll keine Klasse implementiert werden! Das ganze soll nicht in C++ realisiert werden.

Mit freundlichem Gruß

David R.

rüdiger

@net
so ein Blödsinn, der Sinn von memcpy ist es ja, dass man in C bzw. C++ leicht Prozessor Befehle zum schnellen kopieren von Daten aufrufen kann. Nichts mit Schleifen, Geschwindigkeit pur.

PAD

Um es ohne Schleifen und memcopy zu lösen, muss man dann mit pointern auf pointer arbeiten und dort die Adressen auf die Felder austauschen.

PAD schrieb:

Um es ohne Schleifen und memcopy zu lösen, muss man dann mit pointern auf pointer arbeiten und dort die Adressen auf die Felder austauschen.

Das habe ich mir auch schon gedacht. Hatte das dann so in der Art ausprobiert:

void tausch(Feld *f1, Feld *f2) {

  Feld ** temp;
  temp = &f1;
  f1 = f2;
  f2 = *temp;
}

Klappt aber auch nur in der Prozedur selbst, die übergebenen Felder Variablen f1 und f2 bleiben jedoch nach dem Aufruf unverändert! Ist es aber nicht auch so das ich mit

temp = &f1;

ich die Adresse des auf dem Stack liegenden Variable speicher würde?

net 0

kingruedi schrieb:

@net
so ein Blödsinn, der Sinn von memcpy ist es ja, dass man in C bzw. C++ leicht Prozessor Befehle zum schnellen kopieren von Daten aufrufen kann. Nichts mit Schleifen, Geschwindigkeit pur.

nö, dann wär's ja prozessorabhängig. da kann man ja gleich den dma-controller bemühen o.ä.
eine variante von memcpy sieht z.b. so aus:

/* Sample implementation of memcpy */ 

   void *memcpy(void *s1, const void *s2, size_t n); 
           char * t1 = s1; 
           const char * t2 = s2; 
           while(n-- > 0) *t1++ = *t2++; 
           return s1; 
   }

mit schleife. stammt aus 'True 64 UNIX'

interpreter

kingruedi schrieb:

@net
so ein Blödsinn, der Sinn von memcpy ist es ja, dass man in C bzw. C++ leicht Prozessor Befehle zum schnellen kopieren von Daten aufrufen kann. Nichts mit Schleifen, Geschwindigkeit pur.

memcpy ohne Schleife? Das würde doch nur auf Vektorprozessoren gehen.

Windalf

@ Windalf, wäre es nicht günstiger, das n nur einmal vor der Schleife zu erhöhen ?

öhm ja

@David1403
meinst du so?

void tausch(int **f1, int **f2){int *temp=*f1;*f1 = *f2;*f2 = temp;} 

int main(){

	int a[]={1,2,3,4,5,6,7,8,9,10};
	int b[]={10,9,8,7,6,5,4,3,2,1};
	int *c,*d;
	c=a;
	d=b;

	ausgeben(c,10);
	ausgeben(d,10);
	tausch(&c,&d);
	printf("\n\n\n");
	ausgeben(c,10);
	ausgeben(d,10);

}