Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Übergabe ArrayPointer an Funktion

  • 1
  • 2

Werbeanzeige

NotGood

Frischling

  • »NotGood« ist der Autor dieses Themas

Beiträge: 31

  • Private Nachricht senden

1

27.12.2009, 13:33

Übergabe ArrayPointer an Funktion

Ich habe folgendes Problem, was vermutlich für euch Profis easy zu lösen wäre.

Ich würde gerne einen Pointer auf ein mehrdimensionales Array erzeugen und diesen an eine Funktion zum belegen weiterreichen. Ich wollte nämlich gerne die Felder von überall aus dem Programm ansprechen können, ohne den Array Global machen zu müssen und war der Meinung, dass ein Ansprechen über die Adresse, dann das beste wäre. Bevor ich aber jetzt mehr sage als nötig, hier mein Beispielcode:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <iostream>
using namespace std;

int fuellearray(int *pXarray);


int main()
{
    int Xarray[8][8];

    fuellearray(&Xarray); 

    for(int x = 0; x < 8; x++)
    {
        for (int y = 0; y < 8; y++)
        {
            cout << Xarray[x][y];
        } cout << endl;
    } 


    

    system("pause");
    return 0;

}

int fuellearray(int *pXarray)
{
    for(int x = 0; x < 8; x++)
    {
        for (int y = 0; y < 8; y++)
        {
            pXarray[x][y]=1;
        }
    } 
}


Kann mir jemand sagen, wie ich die obige Absicht in Kompilierfähigen Code umwandle bzw. welche bessere Methoden es dafür gibt? :cry:

Übrigens hier die Fehlermeldung:

Zitat


error C2664: 'fuellearray': Konvertierung des Parameters 1 von 'int (*)[8][8]' in 'int *' nicht möglich


Danke vorab für eure hilfreichen Antworten.

Jonathan_Klein

Community-Fossil

Beiträge: 3 820

  • Private Nachricht senden

2

27.12.2009, 13:40

Hier die bessere Methode: Vergiss Arrays und benutze mehrere Verschachtelte std::vector's. Die sind einfacher zu handhaben und weniger fehleranfällig.
Lieber dumm fragen, als dumm bleiben!

NotGood

Frischling

  • »NotGood« ist der Autor dieses Themas

Beiträge: 31

  • Private Nachricht senden

3

27.12.2009, 13:51

Danke für die Antwort. Mit den Vektoren werde ich es mal probieren, dennoch läßt mich die Neugier nicht los. Es muß doch auch mit mehrdimensionalen Arrays funktionieren. Nur wie?

Mit Eindimensionalen scheint das ja kein Problem zu geben:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#include <iostream>
using namespace std;

void fuelleArray(int* EinArray);

int main()
{
int array[8];

fuelleArray(array);


            for(int i = 0; i < 8; i++)
            { 
                 cout << array[i];
              
            }

cout << endl;

while (1);
return 0;
}

void fuelleArray(int* EinArray)
{
      for(int i = 0; i < 8; i++)
         {
         EinArray[i] = 9; 
         }
}


Sorry, für das unstrukturierte Layout. Habe es eben schnell aus einem meiner Beispiele rauskopiert :oops:

GR-PA

Treue Seele

Beiträge: 326

Wohnort: Daheim

Beruf: Faulenzer

  • Private Nachricht senden

4

27.12.2009, 14:12

So sähe dein Code aus, wenn er funktionsfähig wäre:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <iostream>
using namespace std;

void fuellearray(int *pXarray, int dim1, int dim2); // dim1 und dim2 sind die Dimensionen der mehrdimensionalen Arrays



int main()
{
    int Xarray[8][8];

    fuellearray(&Xarray[0][0],8,8); // Referenz auf erstes Element muss ermittelt (v[0] alternativ mögl.)


    for(int x = 0; x < 8; x++)
    {
        for (int y = 0; y < 8; y++)
        {
            cout << Xarray[x][y];
        } cout << endl;
    }


   

    system("pause");
    return 0;

}

void fuellearray(int *pXarray, int dim1, int dim2)
{
    for(int x = 0; x < dim1; x++)
    {
        for (int y = 0; y < dim2; y++)
        {
            pXarray[x*dim2+y] = 1; // Mehrdimensionale Arrays existieren nur im Quellcode!!

        }
    }
}


Die Übergabe der Dimensionen als Parameter macht den Code leichter änderbar, du kannst sie aber auch durch feste Werte ersetzen.
Mehrdimensionale Arrays existieren nur im Code! Im Speicher werden sie als einfache eindimensionale Arrays abgelegt. Deshalb der Zugriff mit [x*dim2+y]. Dieser ist unbedingt erforderlich, da der Compiler nicht weiß, dass der übergebene Zeiger ein Zeiger auf das erste Element eines Mehrdimensionalen Arrays ist (selbst wenn er das wüsste würde er die Dimensionen des Arrays nicht kennen).
Bei der übergabe an die Funktion musst du auch statt Xarray Xarray[0] bzw. &Xarray[0][0] übergeben.
Signaturen werden überbewertet

Nexus

Alter Hase

Beiträge: 713

  • Private Nachricht senden

5

27.12.2009, 14:39

Re: Übergabe ArrayPointer an Funktion

Zitat von »"NotGood"«

Ich wollte nämlich gerne die Felder von überall aus dem Programm ansprechen können, ohne den Array Global machen zu müssen
Ich würde mir an deiner Stelle überlegen, ob das nicht besser lösbar ist. Anfangs scheint es natürlich bequemer, wenn man sich nicht um Hierarchien und Zuständigkeiten kümmern muss, sondern alles global zugreifbar hat, aber spätestens bei grösseren Projekten kann das recht mühsam werden. Langfristig gesehen handelt man sich eine Menge Probleme ein, darunter unnötige Abhängigkeiten, nicht nachvollziehbare Zugriffe und erschwertes Debugging. Also versuche vielleicht in Zukunft, globale Variablen soweit möglich zu vermeiden.

Nur so als Tipp. ;)

NotGood

Frischling

  • »NotGood« ist der Autor dieses Themas

Beiträge: 31

  • Private Nachricht senden

6

27.12.2009, 15:13

@GR-PA

Hui, dass ist aber ein hübscher Brocken Code. Auf so eine Idee wäre ich niemals gekommen.

@Nexus
Werde das natürlich versuchen weitestgehend zu vermeiden. Aber da die Fähigkeiten zu Anfang ja sehr begrenzt sind (habe erst vor knapp 2 Monaten mit C++ und somit auch mit dem Programmieren angefangen) , wird das jetzt bei meinen ersten Gehversuchen nicht immer gut gelingen. Zumindest versuche ich dann solche Sachen mit Pointerzugriffen kenntlich zu machen :oops:

Vielen Dank an alle, für die schnellen und präzisen Antworten.

Großes Lob an euch und diese Seite.

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

7

27.12.2009, 15:39

Nur der Vollständigkeit halber: Du kannst ein mehrdimensionales Array auch normal an eine Funktion übergeben, ganz ohne irgendwelche Hacks ;)

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <iostream>
using namespace std;

void fuellearray(int array[8][8]);

int main()
{
  int Xarray[8][8]; 

  fuellearray(Xarray); 

  for(int x = 0; x < 8; x++)
  {
    for (int y = 0; y < 8; y++)
    {
      cout << Xarray[x][y];
    }
    cout << endl;
  }

  return 0;
}

void fuellearray(int array[8][8])
{
  for(int x = 0; x < 8; x++) 
  {
    for (int y = 0; y < 8; y++) 
    {
      array[x][y] = 1;
    }
  }
}
m4studios

GR-PA

Treue Seele

Beiträge: 326

Wohnort: Daheim

Beruf: Faulenzer

  • Private Nachricht senden

8

27.12.2009, 19:59

Zitat von »"dot"«

Nur der Vollständigkeit halber: Du kannst ein mehrdimensionales Array auch normal an eine Funktion übergeben, ganz ohne irgendwelche Hacks Wink

Aber nur wenn beide oder die 2. Dimension bei der Erstellung der Funktion bekannt sind. Das führt aber bei größerem Code schnell zu viel Arbeit, wenn sich die Anzahl der Dimensionen ändert. Außerdem schränkt es den Nutzwert einer solchen Funktion stark ein, da sie nur Arrays der vorgegebenen Größe verwenden kann.
Aber wie bereits von Jonathan_Klein gesagt: verwende besser std::vector, dann hast du diese und andere Probleme nicht.
Signaturen werden überbewertet

idontknow

unregistriert

9

28.12.2009, 11:56

Zitat von »"GR-PA"«

Zitat von »"dot"«

Nur der Vollständigkeit halber: Du kannst ein mehrdimensionales Array auch normal an eine Funktion übergeben, ganz ohne irgendwelche Hacks Wink

Aber nur wenn beide oder die 2. Dimension bei der Erstellung der Funktion bekannt sind. Das führt aber bei größerem Code schnell zu viel Arbeit, wenn sich die Anzahl der Dimensionen ändert. Außerdem schränkt es den Nutzwert einer solchen Funktion stark ein, da sie nur Arrays der vorgegebenen Größe verwenden kann.
Aber wie bereits von Jonathan_Klein gesagt: verwende besser std::vector, dann hast du diese und andere Probleme nicht.


das ganze mit dynamischen 2d arrays zu lösen sollte auch kein problem sein!

GR-PA

Treue Seele

Beiträge: 326

Wohnort: Daheim

Beruf: Faulenzer

  • Private Nachricht senden

10

28.12.2009, 13:21

Zitat von »"idontknow"«

das ganze mit dynamischen 2d arrays zu lösen sollte auch kein problem sein!

Der notwendige Quellcode wäre bis auf das erstellen des Arrays (und das delete) der gleiche... (auch mehrdimensionale dynamische Arrays existieren nur im Quellcode und nicht im Speicher)
Signaturen werden überbewertet

Werbeanzeige

  • 1
  • 2