Pointer-Array in C++

[Bastel B. (luoc)]

Hi,
aus Gründen möchte ich mehrere Arrays oder wie im Beispiel zwei mit 
einem Array aus Pointern zusammenfassen. Allerdings gelingt mir die 
Umsetzung nicht. Hat jemand eine Idee wo der Fehler liegt?

Ich möchte alle Arrays in einer Schleife abarbeiten und dabei möglichst 
auf if-Abfragen verzichten (also genau die Ausdrücke, dich bei der 
Zuweisung / Ausgabe verwendet habe). Ist es also generell möglich sowas 
zu machen oder bin ich auf dem Holzweg?

Danke schonmal im Vorraus ;)

#include <iostream>

int main() {

  int s = 3;
  int *a = new int[s];
  int *b = new int[s];
  int *c = new int[2*s];

  // Arrays zuweisen
  for(int i=0; i<2*s; i++) {
    if(i<s) {
      c[i] = a[i];
    } else {
      c[i] = b[i-s];
    }
  }

  // Ausgangsarrays mit werten füllen
  for (int i=0; i<s; i++) {
    a[i] = i;
    b[i] = i+s;
  }

  // Ausgabe
  std::cout << "i\tist\tsoll" << std::endl;
  for(int i=0; i<2*s; i++) {
    std::cout << i << ":\t" << c[i] << '\t';

    if(i<s) {
      std::cout << a[i];
    } else {
      std::cout << b[i-s];
    }

    std::cout << std::endl;
  }

  return 0;
}

Bei der Zuweisung werden die Werte momentan direkt und nicht als Zeiger 
übergeben, dementsprechend sind alle Ausgaben 0.

Ausgabe:

i  ist  soll
0:  0  0
1:  0  1
2:  0  2
3:  0  3
4:  0  4
5:  0  5

[Klaus W. (mfgkw)]

Sowohl deine Beschreibung als auch dein Quelltext erscheint mir etwas 
wirr,  aber eventuell willst du statt der beiden Felder a und b nur 
eines nehmen,  das doppelt so groß ist.  Dann machst du dir statt b nur 
einen Zeiger auf a[3]. Jetzt kannst du die oberen drei wahlweise als 
a[3] bis a[5] oder als b[0] bis b[2] ansprechen.
Mit einer Schleife über die sechs Elemente von a erreichst du also erst 
deine drei des bisherigen a und dann die drei von b.

Bei Bedarf kannst du entsprechend das Feld noch größer machen (12 
Elemente)  und c auch gleich mit unterbringen.  c wäre dann nur noch ein 
Zeiger auf a[6]. Ein Schleife über die 12 Elemente überstreicht dann 
deine 3 bisherigen a, dann die 3 b und dann die 6 c.

[Eric (Gast)]

Du füllst erst dein Array c mit den Werten aus a und b und schreibst 
dann erst die Werte in a und b. Kein wunder, dass du dann nicht die 
neuen Werte in c hast.

Ich bin mir nicht sicher was du erreichen willst, aber auf jeden fall 
sind a, b und c int-Arrays (bzw Zeiger auf int, was aufs gleiche 
hinausläuft), du hast nirgendwo Arrays aus Pointern.

Ein Array aus Pointern wäre z.B.

int **c

oder

int *c[]

[Bastel B. (luoc)]

@ Klaus Wachtler
Natürlich lässt sich mein Beispiel stark vereinfachen, ich möchte 
allerdings grundsätzlich klären, ob das so wie ich es mir vorstelle 
möglich ist. Den konkreten Anwendungsfall will ich jetzt nicht im Detail 
erklären, das sprengt den Rahmen.
Ich habe Daten unterschiedlicher Quellen, jeweils in einem eigenen 
Array. Der Einfachheit und der Performance halber will ich sie in der 
bearbeitenden Funktion aber als ein(!) Array darstellen und 
manipulieren, sie dabei aber am Ursprünglichen Speicherort belassen.

@ Eric
Das mein ursprünglich geposteter Code nicht das gewollte macht ist klar, 
habe ich ja auch dazugeschrieben ;). Allerdings läuft er.

Im Folgenden habe ich versucht ein Array mit Pointern vom Heap 
anzufordern, bekomme aber eine Fehlermeldung. Was mache ich falsch?

#include <iostream>

int main() {
  int s = 3;
  int *a = new int[s];
  int *b = new int[s];
  int **c = new *int[2*s]; // Fehlermeldung in dieser Zeile

  // Arrays zuweisen
  for(int i=0; i<2*s; i++) {
    if(i<s) {
      c[i] = &a[i];
    } else {
      c[i] = &b[i-s];
    }
  }

  // Ausgangsarrays mit werten füllen
  for (int i=0; i<s; i++) {
    a[i] = i;
    b[i] = i+s;
  }

  // Ausgabe
  std::cout << "i\tist\tsoll" << std::endl;
  for(int i=0; i<2*s; i++) {
    std::cout << i << ":\t" << c[i] << '\t';

    if(i<s) {
      std::cout << a[i];
    } else {
      std::cout << b[i-s];
    }

    std::cout << std::endl;
  }

  return 0;
}

[Yalu X. (yalu) (Moderator)]

Statt diesem

  int **c = new *int[2*s]; // Fehlermeldung in dieser Zeile

dieses

  int **c = new int *[2*s]; // Fehlermeldung weg

Hier wird der Zeiger auf das jeweilige Element ausgegeben:

    std::cout << i << ":\t" << c[i] << '\t';

Willst du stattdessen den Inhalt, muss du "*" davor schreiben:

    std::cout << i << ":\t" << *c[i] << '\t';

[Bastel B. (luoc)]

Manchmal ist es so einfach,
vielen lieben Dank Yalu X.

[Yalu X. (yalu) (Moderator)]

Du kannst die Arrays (bzw. die Speicherbereiche, auf die die drei
Pointer zeigen) auch folgendermaßen überlagern:

  int *c = new int [2*s];
  int *a = c;
  int *b = c + s;

Danach sind ist a[i] äquivalent mit c[i] und b[i] äquivalent mit c[s+i].

Die Frage ist allerdings, ob solche Array-Zugriffe "um die Ecke herum"
guter Stil sind. In alten Fortran-Programmen findet man dieses Konzept
recht häufig. In C++ gibt es dafür aber, je nach Anwendungsfall, evtl.
bessere Möglichkeiten.

[Mark B. (markbrandis)]

Was spricht konkret dagegen, die in C++ typischen Standard-Konstrukte 
wie z.B. <array> oder <vector> zu verwenden?

Klar, man kann sowas auch von Hand ausprogrammieren. Eben so wie man es 
in C machen würde. Aber in C++ muss man das oftmals nicht. Wenn die 
Sprache mächtigere und weniger fehleranfällige Konstrukte bietet, dann 
sollte man diese auch verwenden.

l. o. schrieb:
> aus Gründen

Ach so, ja dann! ;-)