#include<iostream>

using namespace std;

// Feld erzeugen mit Zeiger auf Zeiger //

void feld_erzeugen (int **xy, int n)
{

 xy = new int* [n];
 srand (time(NULL));
 for (int i=0;i<n;i++)
*(xy+i)=rand()%100

  for (int i=0;i<n;i++)
         {if (!(i%10))
             cout<<endl;
          cout.width(4);
        cout<< *(xy+i);
}
// Feld ausgeben mit Zeiger auf Zeiger //

void feld_ausgeben(int **xy, int n)
{
     for (int i=0;i<n;i++)
         {if (!(i%10))
             cout<<endl;
          cout.width(4);
          cout<< *(xy+i);          
         }     
}

int main () 
{
  int *zeiger=0;    
  int  m=0;

  cout<<"Bitte groesse des Feldes eingeben"<<endl;
  cin>>m;
  feld_erzeugen (&zeiger,m);
  feld_ausgeben (&zeiger,m);  
 return 0;   
}

Meine Fragen: 1. Ist die Art wie ich das verusche überhaupt korrekt?
und 2. Wenn ja wo liegt der Fehler? ist es vll Syntax bedingt ?.

Vielen Dank schonmal für eure Hilfe. Ich warte gespannt .

Gruß Cid

cidburner schrieb:

void feld_erzeugen (int **xy, int n)
{
  xy = new int* [n];     // Erzeugt ein dyn. Array aus Zeigern
                         // --> nicht das, was Du willst
  srand (time(NULL));
  for (int i=0;i<n;i++)
     *(xy+i)=rand()%100; // *(xy+i) ist dasselbe wie xy[i]
  ...                    // aber xy[i] referenziert einen Zeiger auf int

Ich glaube, Du wolltest so etwas haben:

void feld_erzeugen (int **xy, int n)
{
  assert(xy != 0);
  *xy = new int [n];     // Erzeugt ein dyn. Array aus ints
                         // und speichert den Zeiger in *xy
  srand (time(NULL));
  for (int i=0;i<n;i++)
    (*xy)[i] = rand()%100;
  ...

Mit einer lokalen Referenz ist das vielleicht noch einfacher:

void feld_erzeugen (int **xy, int n)
{
  assert(xy != 0);
  int* & izref = *xy;
  izref = new int [n];   // Erzeugt ein dyn. Array aus ints
                         // und speichert den Zeiger in izref
  srand (time(NULL));
  for (int i=0;i<n;i++)
    izref[i] = rand()%100;
  ...

wobei "izref" für "int-zeiger-referenz" steht -- eine Referenz auf einen Zeiger auf int.

Nun noch damit ich das ganze auch verstehe

warum muss ich das so schreiben ?

*xy = new int [n];

Auch noch nicht ganz verstanden: Eventuell ne andere Erklärung ?
//
*(xy+i) ist dasselbe wie xy[i]
... // aber xy[i] referenziert einen Zeiger auf int
//

Und zu dem Problem zeiger auf Zeiger, wie es in der Aufgaben Stellung verlangt ist. Bedeutet das ich den einen Zeiger global anlegen muss oder ? . So wie ichs oben gemacht habe, ne andere Möglichkeit gibt es nicht ?. Unser Tutor meinte mal in einer e-mail, etwas von globale Zeiger wären unnötig, was genau er damit meinte ist mir wie gesagt nicht ganz klar, daher frag ich hier nochmal nach.

gruß Cid

warum muss ich das so schreiben ?

*xy = new int [n];

Weil sonst der geänderte Wert des Zeigers verloren geht. Siehe Call-by-Value (vs. Call-by-Reference. Wobei du kein CbR nimmst, obwohl es das in C++ gibt und hier verständlicher wäre.)

Und zu dem Problem zeiger auf Zeiger, wie es in der Aufgaben Stellung verlangt ist.

Wo ist das Problem?

Bedeutet das ich den einen Zeiger global anlegen muss oder ? . So wie ichs oben gemacht habe, ne andere Möglichkeit gibt es nicht ?.

global anlegen? wovon sprichst du?

P.S. zu jedem new[] gehört ein delete[]

also

int main ()

int *zeiger = ; // Ist also nicht global ?? //

ich habe am ende vom Programm delete [] zeiger; reicht das um das komplette Feld zu löschen ?

Zeiger auf Zeiger: hat sich geklärt

die sache mit speicherfreigabe, ist die ok ?

warum muss ich das so schreiben ?

*xy = new int [n];

Am besten malst Du es Dir mal auf, was wo wie im Speicher steht und von welchem Typ alles ist. Du rufst feld_erzeugen ja mit einem Zeiger auf einen Zeiger auf int auf, damit die Funktion den Zeiger auf int verändern kann. Der Zeiger auf int ist nunmal *xy, xy selbst ist der Zeiger auf Zeiger auf int.

cidburner schrieb:

Auch noch nicht ganz verstanden: Eventuell ne andere Erklärung ?
// *(xy+i) ist dasselbe wie xy[i]
// aber xy[i] referenziert einen Zeiger auf int

Zum ersten gibt es nicht viel zu erklären. Z[X] ist einfach eine Akbürzung für *(Z+X) , falls Z von einem "eingebauten" Typ (wie zB ein normaler Zeiger) ist. Da xz ein Zeiger auf Zeiger auf int ist, ist *xy ein Zeiger auf int. Damit ist xy[i] auch ein Zeiger auf int und nichts, in dem Du Ganzzahlen speichern kannst.

cidburner schrieb:

Und zu dem Problem zeiger auf Zeiger, wie es in der Aufgaben Stellung verlangt ist. Bedeutet das ich den einen Zeiger global anlegen muss oder ?

Nö, das hat damit nichts zu tun.

int main() {
  int   i  = 99;
  int*  z  = 0;
  int** zz = &z;
  * zz = &i;
  **zz += 1;
  cout << b << '\n';
}

ergibt 100 als Programmausgabe.

cout << b << '\n';

sollte i statt b sein

gruß cid