In einer Funktion Arraygröße definieren und Array füllen



  • Hallo Leute,

    ich habe eine Konsolenanwendung mit .NET geschrieben.

    Dabei erstelle ich in meinem Hauptprogramm einen Array. Die Elemente sind von einer mir definierten Struktur abgeleitet. Die Elementanzahl des Arrays ist mir noch nicht bekannt.

    Beim Aufruf einer Funktion wird die Adresse des Arrays übergeben. In der Funktion möchte ich nun die Größe des Arrays festlegen und die Arrayelemente mit Werten füllen.

    Nach der Rückkehr ins Hauptprogramm soll er den Array ausgeben.

    Der Code dazu sieht wie folgt aus:

    struct myStructure 
    {
    	int A;
    	int B;
    	int C;
    };
    
    int FillArray(myStructure* ArrayAdr);
    
    int _tmain()
    {
        myStructure* myArray = new myStructure[];
    
    	//Adresse des Arrays uebergeben und Array fuellen lassen
    	int iCoutElem = FillArray(&myArray);
    
    	//Ausgabe des Arrays
    	for (int i=0; i<iCoutElem; i++)
    	{
    		Console::WriteLine(S"Feld{0}:{1},{2},{3}",i.ToString(), (myArray[i].A).ToString(), (myArray[i].B).ToString(), (myArray[i].C).ToString());
    	}
    	return 0;
    }
    int FillArray(myStructure* ArrayAdr)
    {
       int iItemAnzahl = 10;
       //Anzahl der Elemente wird hier festgelegt bzw. bestimmt
       (*ArrayAdr) = new myStructure[iItemAnzahl];
    
       //Array wird gefuellt
       ArrayAdr->A = 5;
       ArrayAdr->B = 3;
       ArrayAdr->C = 1;
    
       //Anzahl der Elemente zurueckgeben
       return iItemAnzahl;
    }
    

    Leider gibt der Compiler mir immer wieder folgenden Fehler aus: "'FillArray': Konvertierung des Parameters 1 von 'myStructure ** ' in 'myStructure *' nicht möglich"

    Was mach ich Falsch? Wie kann ich das Problem beheben? Würde mich sehr über eine Antwort freuen!

    Viele Grüße
    Axel



  • //Array wird gefuellt
       ArrayAdr->A = 5;
       ArrayAdr->B = 3;
       ArrayAdr->C = 1;
    

    Bin mir nicht sicher aber musst Du hier nicht den Zeiger verwenden?

    //Array wird gefuellt
       *ArrayAdr->A = 5;
       *ArrayAdr->B = 3;
       *ArrayAdr->C = 1;
    


  • int FillArray(myStructure** ArrayAdr) 
    { 
       int iItemAnzahl = 10; 
       //Anzahl der Elemente wird hier festgelegt bzw. bestimmt 
       (*ArrayAdr) = new myStructure[iItemAnzahl]; 
    
       for(int i=0; i<iItemAnzahl; i++)
       {
         //Array wird gefuellt 
         ArrayAdr[i].A = 5; 
         ArrayAdr[i].B = 3; 
         ArrayAdr[i].C = 1; 
       }    
       //Anzahl der Elemente zurueckgeben 
       return iItemAnzahl; 
    }
    


  • Danke, euch Beiden für die Antworten. Leider geht es noch immer nicht.
    Ich habe jetzt die von Jochen modifizierte Funktion eingebaut.

    Dabei meckert aber der Compiler auf Zeile 10, 11, 12 (Zeilennummer bei Jochens Antwort) mit folgendem Fehler: "Der linke Teil von '.A' muss eine Klasse/Struktur/Union sein Typ ist 'myStructure *' Wollten Sie stattdessen '->' verwenden?"

    Zuerst habe ich dem Vorschlag des Compilers gefolgt. Doch dabei wird eine "System.NullReferenceException" (ebenfalls bei Zeile 10) gemeldet.

    Danach habe ich solicks Vorschlag gefolgt, indem ich den Zeiger nutze:

    (*ArrayAdr[i]).A = 5;
    (*ArrayAdr[i]).B = 3;
    (*ArrayAdr[i]).C = 1;
    

    Zeigeroperation ("->") geht in diesem Fall nicht. Leider kommt aber auch hier "NullReferenceException".

    Wisst ihr weiter?

    VG
    Axel



  • Du interpretierst ArrayAdr als Array von Zeigern auf struct, und holst Dir den n-ten Zeiger aus diesem Array. Du möchtest aber ArrayAdr als Zeiger auf ein Array von structs interpretieren. Deshalb wäre korrekt:

    (*ArrayAdr)[i].A = 5;
    

    Mit dieser Klammerung (s.o.) nimmst Du das n-te Element aus dem Array, auf das der Zeiger zeigt.

    Oder nutze Referenzen:

    int FillArray(myStructure*& ArrayAdr)
    {
       int iItemAnzahl = 10;
       //Anzahl der Elemente wird hier festgelegt bzw. bestimmt
       ArrayAdr = new myStructure[iItemAnzahl];
    
       for(int i=0; i<iItemAnzahl; i++)
       {
         //Array wird gefuellt
         ArrayAdr[i].A = 5;
         ArrayAdr[i].B = 3;
         ArrayAdr[i].C = 1;
       }    
       //Anzahl der Elemente zurueckgeben
       return iItemAnzahl;
    }
    
    myStructure* array;
    int length = FillArray(array);
    


  • Recht vielen Dank LordJaxom für die Erklärung und die Lösung des Problems!

    Viele Grüße
    Axel


Log in to reply