identische arrays vertauschen < C/C++ < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
Hallo!
Ich habe in C/C++ zwei gleich große 2D-Arrays
float alt[1000][1000];
float neu[1000][1000];
Ich möchte damit iterativ ein Feld berechnen. Das heißt, ich berechne aus einem vorgegebenen Feld ein neues, um aus diesem das nächste zu berechnen usw.
Ich dachte, das ginge mit swap(alt, neu), womit mein Code auch funktioniert. Allerdings habe ich feststellen müssen, daß dabei die Inhalte der Arrays vertauscht werden und NICHT die Pointer alt und neu. Das ist natürlich sehr... unperformant.
Ich hab allerlei Versuche unternommen, die Pointer selbst zu tauschen, aber C stört sich offensichtlich daran, Pointer für 2D-Arrays zu tauschen, weil ihm dann die Größe der zweiten Dimension verloren geht.
Hat da wer ne Idee, wie man sowas generell sauber löst? Mir fallen immer mehr Frickel-Lösungen ein, die einfach nicht schön sind, und auch nicht compilieren.
|
|
| |
|
| Status: |
(Antwort) fertig  | | Datum: | 23:28 Fr 23.05.2014 | | Autor: | felixf |
Moin!
> Ich habe in C/C++ zwei gleich große 2D-Arrays
>
> float alt[1000][1000];
> float neu[1000][1000];
>
> Ich möchte damit iterativ ein Feld berechnen. Das heißt,
> ich berechne aus einem vorgegebenen Feld ein neues, um aus
> diesem das nächste zu berechnen usw.
>
> Ich dachte, das ginge mit swap(alt, neu), womit mein Code
> auch funktioniert. Allerdings habe ich feststellen müssen,
> daß dabei die Inhalte der Arrays vertauscht werden und
> NICHT die Pointer alt und neu. Das ist natürlich sehr...
> unperformant.
Ja, das ist so. Hier sind alt und neu schliesslich zwei Objekte der Groesse 1000*1000*sizeof(float). Und anders kann man die schlecht tauschen. (Dass Arrays gleichzeitig Zeiger sind ist halt so ein C-Überbleibsel...)
In C++11 kannst du das eleganter lösen, indem du etwa
| 1: |
| | 2: | std::unique_ptr<std::array<std::array<float, 1000>, 1000>> alt(new std::array<std::array<float, 1000>, 1000>());
| | 3: | std::unique_ptr<std::array<std::array<float, 1000>, 1000>> neu(new std::array<std::array<float, 1000>, 1000>());
|
schreibst; dann kannst du mit
| 1: |
| | 2: | (*alt)[1][2] = 5;
| | 3: | std::cout << (*neu)[3][6] << "\n";
|
auf die Elemente zugreifen. Vertauschen kannst du die beiden per
| 1: |
| | 2: | std::swap(alt, neu);
|
Alternativ kannst du eine Klasse (Template) schreiben oder verwenden (z.B. eine Matrix-Klasse, wie die aus den Bibliotheken eigen2 oder eigen3), die zweidimensionale Arrays intern durch einen Pointer repräsentiert. Solche Klassen kann man effizient swappen (passender Code dafür vorausgesetzt).
> Ich hab allerlei Versuche unternommen, die Pointer selbst
> zu tauschen, aber C stört sich offensichtlich daran,
> Pointer für 2D-Arrays zu tauschen, weil ihm dann die
> Größe der zweiten Dimension verloren geht.
Ja. Und alt und neu sind keine echten Pointer, du kannst also ihren Wert nicht setzen.
Was du machen könntest, wenn du das ganze in plain old C machen willst:
| 1: |
| | 2: | float alt_[1000][1000];
| | 3: | float neu_[1000][1000];
| | 4: |
| | 5: | typedef float array1[1000];
| | 6: | typedef array1 * array;
| | 7: |
| | 8: | array alt = alt_;
| | 9: | array neu = neu_;
| | 10: |
| | 11: | alt[5][6] = 7;
| | 12: |
| | 13: | array tmp = alt;
| | 14: | alt = neu;
| | 15: | neu = tmp;
|
Das ist zwar auch eine Frickellösung, aber soweit ich weiss C99-kompatibel 
Und sie hat den Vorteil, dass die Daten auf dem Stack liegen und keine dynamische Speicherverwaltung benötigt wird.
LG Felix
|
|
|
| |
|
Hi!
Danke für die Antwort.
Naja, ich muß sagen, so vom programmieren und Lesen her sind die ersten Lösungen nicht so elegant. Ggf. sind das die richtigen Ansätze, aber da braucht man ja Ewigkeiten, die erstmal zu verstehen 
Deine letzte Lösung gefällt mir am besten.
Letztendlich ist das ganze Programm nur ein popliger 20-Zeiler gewesen, um mal eben was zu rechnen.
Da das Problem meist bei dem 2D-Charakter liegt, hatte ich auch daran gedacht, ein 1D-Array zu machen, und das mit dem 2D per hand zu machen. Da hätte ich auch einige Ideen gehabt, wie es geht. Aber das ist auch nicht so toll...
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 22:02 So 25.05.2014 | | Autor: | felixf |
Moin!
> Naja, ich muß sagen, so vom programmieren und Lesen her
> sind die ersten Lösungen nicht so elegant. Ggf. sind das
> die richtigen Ansätze, aber da braucht man ja Ewigkeiten,
> die erstmal zu verstehen
Eine bessere Version:
| 1: |
| | 2: | std::vector<std::array<float, 1000> > alt(1000);
| | 3: | std::vector<std::array<float, 1000> > neu(1000);
| | 4: |
| | 5: | alt[1][2] = 3;
| | 6: | alt[4][5] = 6;
| | 7: |
| | 8: | std::swap(alt, neu);
|
> Deine letzte Lösung gefällt mir am besten.
>
> Letztendlich ist das ganze Programm nur ein popliger
> 20-Zeiler gewesen, um mal eben was zu rechnen.
>
>
> Da das Problem meist bei dem 2D-Charakter liegt, hatte ich
> auch daran gedacht, ein 1D-Array zu machen, und das mit dem
> 2D per hand zu machen. Da hätte ich auch einige Ideen
> gehabt, wie es geht. Aber das ist auch nicht so toll...
Wie schon gesagt, eine Matrix-Klasse wär da am besten für
Mit eigen geht das z.B. so:
| 1: |
| | 2: | #include <eigen3/Eigen/Dense>
| | 3: |
| | 4: | int main()
| | 5: | {
| | 6: | Eigen::Matrix<float, 1000, 1000> alt, neu;
| | 7: | alt(1, 2) = 3;
| | 8: | neu(4, 5) = 6;
| | 9: | alt.swap(neu);
| | 10: | }
|
LG Felix
|
|
|
|
