Array als Rückgabetyp ??

  • C++

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Array als Rückgabetyp ??

    Hallo FSB-ler,

    Ich habe mal versucht eine Funktion zu schreiben, mit der man eine
    Zahl Ziffer für Ziffer in ein Array einlesen kann. Soweit so gut, nur
    wenn ich jetzt auf die Funktion zugreifen möchte gibt das Probleme.
    Ich möchte auch, dass die Funktion "inArray" "swapArray" zurück
    an main gibt (dass da "return 0" steht ist natürlich falsch), wobei
    "swapArray[i]" die in ein Array umgewandelte Zahl ist und "i" die
    Anzahl der Ziffern. Ich bin jetzt soweit, dass ich rausgefunden habe,
    dass mein Vorhaben nur mit einem Zeiger funktioniert, was für
    mich ein Problem darstellt.
    Vielleicht kann mir ja jemand den Code korrigieren und es so
    schreiben, dass "swapArray[i]" an main übergeben wird.

    Übrigens bekomme ich folgende Fehlermeldung an der Stelle,
    wo in main() auf die Funktion "in Array()" zugegriffen wird:

    "cannot convert `int*' to `int (*)[10]' for argument `2' to `int inArray(int, int (*)[10])' "

    PHP-Quellcode

    1. #include <iostream>
    2. #include <conio.h>
    3. using namespace std;
    4. int inArray (int zahl, int (*array)[10])
    5. {
    6. int b=0, c=0, i=0, d=0;
    7. do
    8. {
    9. b = zahl / 10;
    10. b *= 10;
    11. *array[c] = zahl-b;
    12. zahl /= 10;
    13. c++;
    14. }
    15. while (zahl != 0);
    16. i=c-1;
    17. int swapArray[i];
    18. do
    19. {
    20. swapArray[d] << *array[i];
    21. i--;
    22. d++;
    23. }
    24. while (i >= 0);
    25. return 0;
    26. }
    27. int main ()
    28. {
    29. int a=0, ar[10];
    30. cout << "Bitte geben Sie eine Zahl zwischen 0 und 2.1 Mrd. ein : ";
    31. cin >> a;
    32. inArray (a, &ar[10]);
    33. getch();
    34. return 0;
    35. }
    Alles anzeigen
  • Mmh,

    int ar[10] ist keine richtiger Typ. Entweder du übergibst nur int* oder eine andere Variante: Du verwendest für das Array eine Klasse und übergibts dann
    der Funktion "inArray" eine Referenz auf die neu erzeugte Klasse (call by reference). In der Funktion kannst du dann das Array nach belieben ändern.

    class Arrayclass
    {
    int ar [10];
    }

    int inArray (int zahl, Arrayclass& ar)
    {
    ...
    ar.ar[c] = zahl-b;
    ...
    }
    der Funktionsaufruf kann dann so erfolgen
    Arrayclass myarray;
    inArray(a,&myarray);

    Man kann sich auch an der Stelle einen eigenen << operator für die Arrayclass vorstellen oder direkt mit dem Container "vector" arbeiten.

    Gruß Ricci123456
  • Habe das jetzt mal mit der Klasse versucht, bekomme jetzt aber noch mehr Fehlermeldungen: "13 new types may not be defined in a return type "

    Ich bin mit den Klassen auch noch nicht so vertraut und Zeiger sowie Refernzen bringen mich immer durcheinander. Ich poste den Code jetzt nochmal, vielleicht kann mir noch jemand einen Tipp geben und das mit dem Rückgabetyp ist auch noch nicht gelöst.
    Danke für die Mühe.

    PHP-Quellcode

    1. #include <iostream>
    2. #include <conio.h>
    3. using namespace std;
    4. class Arrayclass
    5. {
    6. public:
    7. int ar [10];
    8. }
    9. int inArray (int zahl, Arrayclass& ar)
    10. {
    11. int b=0, c=0, i=0, d=0;
    12. do
    13. {
    14. b = zahl / 10;
    15. b *= 10;
    16. ar.ar[c] = zahl-b;
    17. zahl /= 10;
    18. c++;
    19. }
    20. while (zahl != 0);
    21. i=c-1;
    22. int swapArray[i];
    23. do
    24. {
    25. swapArray[d] << *array[i];
    26. i--;
    27. d++;
    28. }
    29. while (i >= 0);
    30. return 0;
    31. }
    32. int main ()
    33. {
    34. int a=0;
    35. cout << "Bitte geben Sie eine Zahl zwischen 0 und 2.1 Mrd. ein : ";
    36. cin >> a;
    37. Arrayclass myarray;
    38. inArray(a, &myarray);
    39. getch();
    40. return 0;
    41. }
    Alles anzeigen
  • Bin mehr in Vb.net unterwegs hab aber auch einige Kentnisse in c++. Ich will dir mal versuchen zu helfen.:D

    Wenn du mit einer Funktion etwas zurück gibst dann musst du immer ein Töpfchen aufhalten :D:D:D
    Also nochmal bisschen besser erklärt in deiner main musst du eine Variable deklarieren und dem den rückgabewert der Funktion zuweisen.

    PHP-Quellcode

    1. array=inArray (a, &ar[10]);

    Ich beziehe mich auf den code den du zuerst gepostet hast.
  • Habe es nun geschafft. Danke.
    Nur jetzt habe ich ein weiteres Problem: Und zwar möchte ich in der Funktion "swapArray()" das Array "ar[]" umdrehen. Nur bekomme ich beim Funktionsaufruf folgende Fehlermeldung:
    44 cannot convert `int*' to `int**' for argument `1' to `int swapArray(int**, int*)'

    PHP-Quellcode

    1. #include <iostream>
    2. #include <conio.h>
    3. using namespace std;
    4. int swapArray(int *array[], int *index)
    5. {
    6. int d=*index;
    7. int swapper[d], e=0;
    8. do
    9. {
    10. swapper[e] << *array[d];
    11. e++;
    12. d--;
    13. }
    14. while (d >= 0);
    15. return swapper[e];
    16. }
    17. int inArray (int *ar, int *zahl)
    18. {
    19. int b=0, c=0, i=0;
    20. do
    21. {
    22. b = *zahl / 10;
    23. b *= 10;
    24. ar[c] = *zahl-b;
    25. *zahl /= 10;
    26. c++;
    27. }
    28. while (*zahl != 0);
    29. *zahl = c;
    30. swapArray (ar, &c);
    31. return ar[i], *zahl;
    32. }
    33. int main ()
    34. {
    35. int a=0, myarray[10];
    36. cout << "Bitte geben Sie eine Zahl zwischen 0 und 2.1 Mrd. ein : ";
    37. cin >> a;
    38. inArray(myarray, &a);
    39. for (int j=0; j<a; j++)
    40. {
    41. cout << myarray[j];
    42. }
    43. getch();
    44. return 0;
    45. }
    Alles anzeigen

    Was soll ich tun ?

    Danke an alle, die mir versuchen zu helfen.

    Mit freundlichen Grüßen

    Mr Crown

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Mr Crown ()

  • Vorweg: Dies ist die Lösung des Problems:

    int swapArray(int array[], int *index)
    {
    array[d];

    e++;
    d--;px"> swapper[e] << array[d];

    e++;
    d--;

    }
    while (d >= 0);

    return swapper[e];px"> int d=*index;
    int swapper[d], e=0;

    do
    {
    array[d];

    e++;
    d--;px"> swapper[e] << array[d];

    e++;
    d--;

    }
    while (d >= 0);

    return swapper[e];

    }


    Kurze Erklärung: Ein Array ist in C sowas wie ein Zeiger. Angenommen, du hast ein Array int myArray[10] deklariert.

    Um die Speicheradresse des 1. Elements von myArray[] zu bekommen, kannst du schreiben:


    int *ptr = &myArray[0];


    myArray[0] gibt dabei den Inhalt der Speicheradresse des 1. Elementes an; das &-Zeichen wiederum gibt uns die Referenz, also die Speicheradresse selbst vom 1. Element zurück.

    Anstelle dessen gibts für das 1. Element auch die Kurzschreibweise

    int *ptr = myArray;


    Merke: Der Bezeichner eines Arrays ohne alles gibt die Speicheradresse des 1. Elementes an!

    Um auf das 4. Element zugreifen zu können, kannst du mittels Zeigerarithmetik schreiben:

    int *ptr = myArray + 3;


    oder halt kurz in Arrayschreibweise:

    int *ptr = &myArray[3];



    Ergo: es ist also egal, ob in einer Funktion als Parameter ein Zeiger oder ein Array definiert wird:


    void foo(int myArray[]) ~= void foo(int *ptrArray)


    Du hast jedoch geschrieben:

    int swapArray(int *array[], int *index)


    also einen Zeiger auf einen Zeiger(!) definiert (es macht an manchen Stellen durchaus Sinn, sowas zu tun, nur leider nicht hier ;) )

    denn:


    int swapArray(int *array[], int *index) ~= int swapArray(int **ptrArray, int *index)


    Und weil der Aufruf von swapArray bei Dir mit

    swapArray (ar, &c);


    erfolgt, übergibst Du (unwissentlich) nur einen Zeiger auf das Array ar, jedoch nicht wie fälschlich deklariert, einen Zeiger auf einen Zeiger. Deshalb beschwert sich der Compiler.


    Hoffe, das war verständlich. Weiterhin viel Erfolg,

    quappo

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von quappo ()

  • Was du tun sollst? Verstehen was das du da programmiert hast.
    Das geht nämlich komplett in die Hose. Deine "geswapptes" Array löst sich nach dem Funktionsaufruf in Luft auf.

    int swapArray(int *array[], int *index)
    {
    int d=*index;
    int swapper[d], e=0;

    ...
    return swapper[e]; <- swapper gibt nur den int an der Stelle e zurück nicht das Array swapper
    }
    ...
    swapArray (ar, &c);
    ...
    "ar" ist ein zeiger auf int und wenn du diesen Zeiger weitergeben willst muss die Funktion auch einen Typ int* aktzeptieren. Das ist bei dir nicht der Fall. "array[]" ist in deinem Fall ein int* und mit "int* array[]" wäre das int**. Deswegen meckert der Compiler.

    return ar, *zahl; <-das geht auch nicht.

    Ich setze mich morgen mal an meinen Compiler und versuchs noch mal dir zu helfen.

    MFG Ricci123456

    PS: Um einfach nur die Zahlen in umgekehrter Reihenfolge auszugeben kannst du auch die Schleife rückwärts laufen lassen.
  • nichts für ungut, Ricci, aber mit der Änderung aus meinem Post funktioniert sein Code. Es gibt sicherlich einen eleganteren Stil, aber wichtig ist das Verständnis, warum etwas funktioniert oder halt auch nicht funktioniert.

    edit:

    ich habs unter osx mit XCode kompiliert und da geht alles einwandfrei. Hab gar nicht auf diese merkwürdige return ar, *zahl; Geschichte geachtet -> warum meckert der Compiler da nicht?! DAS verstehe ICH grad nicht.

    Also nochmal @Crown:

    int myFunction(int param1, int *array) {

    param1 = 1; // aendert nichts ausserhalb von myFunction
    array[0] = 2; // setzt auch ausserhalb von myFunction das 1. Element = 2
    return 3; // ist der eigentliche Rueckgabewert der Funktion (int)

    }

    das return statement bezieht sich auf den Rückgabewert der Funktion (der ist hier int). Ein Rückgabewert ist ein [I]Einzelwert
    , kein Tupel! Mehrere Rückgabewerte können in einem struct verpackt werden oder halt in den Parametern.

    Letztere Variante ist unter C die gebräuchliche Variante. Der int-Rückgabewert wird nur benutzt, um anzuzeigen, ob ein Fehler in der Methode aufgetreten ist, oder nicht. Dadurch, dass der zweite Parameter ('array') ein Zeiger ist, wirkt sich alles, was du innerhalb der Methode an der Variable veränderst auch außerhalb der Methode auf (du schreibst ja direkt in die Speicherstelle rein!).

    Die erste Variante wiederum setzt den Wert von param1 innerhalb von myFunction auf 1, sobald die Methode verlassen wird, hat dies aber keine Auswirkungen mehr auf den Rest.

    Gute n8!

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von quappo () aus folgendem Grund: muss doch noch etwas eingestehen

  • Danke erstmal für die Antworten. Ich glaube, dass ich da wirklich ein sehr vernetztes und unübersichtliches Feld von Zeigern erschaffen habe.
    Dank quappo meckert mein Compiler nicht mehr, aber wie Ricci123456 schon gesagt hat wird nicht das Array swapper zurückgegeben.
    Ich habe das ganze Problem nun mit <vector> aus der STL gelöst, nachdem ich darauf aufmerksam gemacht worden bin. Die ist viel einfacher, da ein vector ein sich anpassendes array ist, aber das wisst ihr wahrscheinlich schon.

    PHP-Quellcode

    1. #include <iostream>
    2. #include <conio.h>
    3. #include <vector>
    4. using namespace std;
    5. int inArray (vector<int> *vec, int *zahl)
    6. {
    7. int b=0, c=0, i=0;
    8. do
    9. {
    10. b = *zahl / 10;
    11. b *= 10;
    12. (*vec).push_back( *zahl-b );
    13. *zahl /= 10;
    14. c++;
    15. }
    16. while (*zahl != 0);
    17. reverse((*vec).begin(), (*vec).end());
    18. }
    19. int main ()
    20. {
    21. int a=0;
    22. vector<int> myvector;
    23. cout << "Bitte geben Sie eine Zahl zwischen 0 und 2.1 Mrd. ein : ";
    24. cin >> a;
    25. inArray(&myvector, &a);
    26. vector<int>::iterator k;
    27. for ( k=myvector.begin() ; k < myvector.end(); k++ )
    28. {
    29. cout << *k;
    30. }
    31. getch();
    32. return 0;
    33. }
    Alles anzeigen


    Trotzdem würde ich das Problem auch gerne mit Arrays lösen, also wenn jemand weiß wie, immer her damit. Ansonsten reicht es mir im Moment auch dieses Problem mit <vector> gelöst zu haben, da man so weit ich weiß einen Vector auch in ein Array umwandeln kann.
    Vielen Dank für eure Hilfe

    Mit freundlichen Grüßen

    Mr Crown
  • Irgendwie ist es ärgerlich, wenn man sich hier nen Wolf schreibt und Du nicht mal probierst, Deinen Code zu verstehen. :confused:

    daher ohne Kommentar:

    PHP-Quellcode

    1. #include <iostream>
    2. using namespace std;
    3. int inArray (int *ar, int zahl)
    4. {
    5. int idx = 0;
    6. while (zahl > 0) {
    7. ar[idx++] = zahl % 10;
    8. zahl /= 10;
    9. }
    10. return idx; // Länge der Zahl in Zeichen
    11. }
    12. int main ()
    13. {
    14. int myarray[10];
    15. int zahl = 0;
    16. int len = 0;
    17. cout << "Bitte geben Sie eine Zahl zwischen 0 und 2.1 Mrd. ein : ";
    18. cin >> zahl;
    19. len = inArray(myarray, zahl);
    20. for (int i=0; i<len; i++) cout << myarray[i];
    21. getchar();
    22. return 0;
    23. }
    Alles anzeigen
  • Sorry wenn es falsch rüber gekommen ist. war keine Absicht. Hab das alles ohne Compiler hingeschnuddelt.

    Hier noch meine getestete Variante.

    C-Quellcode

    1. #include <iostream>
    2. #include <vector>
    3. #include <functional>
    4. #include <algorithm>
    5. using namespace std;
    6. int inVector (vector<int>& iv, int zahl)
    7. {
    8. const int zehn=10;
    9. modulus<int> x;
    10. do
    11. {
    12. iv.push_back (x(zahl,zehn));
    13. zahl/= zehn ;
    14. }
    15. while (zahl != 0);
    16. return iv.size();
    17. }
    18. ostream& operator<< (ostream & os, vector <int>& v)
    19. {
    20. for (vector <int>::iterator i1 = v.begin( ) ; i1 != v.end( ) ; ++i1 )
    21. os << " " << *i1;
    22. return os;
    23. }
    24. int main()
    25. {
    26. cout << "Bitte geben Sie eine Zahl zwischen 0 und 2.1 Mrd. ein : ";
    27. int a=0;
    28. cin >> a; // hier nur Zahlen eingeben
    29. vector<int> vx;// leerer int-vector
    30. vector<int> vy(inVector (vx, a));// inVector füllt vx und gibt die Anzahl der Einträge an den Constructor von vy
    31. reverse_copy ( vx.begin( ), vx.end( ), vy.begin( ));// Function aus der standardlibary
    32. cout << "original: " << vx << std::endl;// Ausgabe der Originalwerte
    33. cout << "reverse : " << vy << std::endl;// Ausgabe in umgekeherter Reihenfolge
    34. cin >> std::ws;
    35. return 0;
    36. }
    Alles anzeigen

    Grüße Ricci123456

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Broken Sword ()

  • quappo schrieb:

    Irgendwie ist es ärgerlich, wenn man sich hier nen Wolf schreibt und Du nicht mal probierst, Deinen Code zu verstehen. :confused:



    Tut mir leid, wenn Du das denkst und es so rüberkommt, aber ich hänge mich voll rein. Meine Zeit ist gerade etwas begrenzt, darum kann ich das jetzt nicht sofort durcharbeiten, denke aber das ich mich morgen mal damit ausgibig beschäftigen werde.
    Wie gesagt Zeiger sind nicht so mein Ding und deshalb war es nötig, dass ihr mir etwas auf die Sprünge helft. Danke.
    Ich habe ja auch geschrieben, dass ich das Problem auch gerne mit Arrays gelöst hätte und darum werde ich mich jetzt ein Bisschen und morgen ausgibig damit beschäftigen um alles das zu verstehen was ihr geschrieben habt. Erstmal vielen vielen Dank für die tolle Hilfe und entschuldigung, dass es so rüberkommt als würde ich nicht mal versuchen meinen Code zu verstehen.
    Mit freundlichen Grüßen

    Mr Crown
  • Fands nur etwas komisch, dass Du nach einer konkreten Sache fragst, dann aber mit keinem Wort drauf eingehst und hier einen "egal, ich hab jetzt was ganz anderes gemacht" Post reinstellst. Da machts dann keinen Sinn, Fragen zu beantworten.

    Aber das ist wohl falsch rübergekommen, also Schwamm drüber :bier1:

    Mal Titten auf den Tisch: Wofür brauchst Du das? Eigeninteresse oder Schul-/Uniaufgabe? Einzelfragen beantworte ich immer gern, aber mal eben (C-)Programmieren beibringen klappt nicht.

    Schnapp Dir ein gutes c++-Buch und arbeite es durch. Es soll ja Cracks geben, die drei Tutorials querlesen und dazu die API-Doku und damit loszaubern können. Ich kanns leider nicht.:( Du wahrscheinlich auch nicht ;)

    Ein guter Tipp: :read: "Einstieg in C++" von Arnold Willemer / ISBN 3-89842-649-1 :read:

    Dazu dann noch irgendwas über grafische Programmierung je nach Gusto vielleicht Visual C++ oder Qt oder ... -> die Erfolgserlebnisse motivieren ungemein, wenn die "Hallo Welt"-Programme plötzlich nicht mehr in der Konsole sondern in nem Fenster auftauchen ;)

    Was Dein Problemchen hier angeht: Konkrete Fragen beantworte ich gerne weiter.

    Auf gutes Gelingen,

    Quappo
  • Am Anfang war es wirklich nur eine Konkrete Frage. Ich dachte, ich hätte bei diesem komplizierten Problem einen kleinen Denkfehler, dabei war das ganze gar nicht so einfach wie ich dachte.
    Natürlich sollte und soll das nicht darauf hinauslaufen, dass mir hier irgendwer Nachhilfe in C++ geben soll.
    Ich habe schonmal einen großen Teil des Buches "C++ für Dummies" durchgearbeitet und ab und zu mal hier ein Tutorial mal dort. Dann habe ein Jahr Pause gemacht und vor einem Monat wieder angefangen. Aber ich mich jetzt fast nur mit Mathematischen Sachen beschäftigt, bei denen man hauptsächlich Schleifen und Modulo (%) braucht.
    Jetzt fiel mir ein, es wäre praktisch, wenn man mal eine Funktion hätte, die Zahlen zerlegt (ihr wisst was ich meine) und so bin ich zu diesem Problem gekommen.

    Ich glaube ich bräuchte ein Buch, in dem es nach jedem Kapitel ein paar aufgaben gibt, damit ich mein neu Erlerntes gleich auf die Probe stellen kann.:read:
    Dieses Buch sollte für Einsteiger sein, aber nicht unbedingt von Hello World an. Und es sollte viel über OOP drin sein. Also ich schau ob ich was finde.
    Ist bestimmt besser als überall was falsches aufzuschnappen (nicht im FSB natürlich) und dann mit so einem Problem wie diesem hier irgendwelche Experten zu nerven, die wahrscheinlich besseres zu tun haben.
    Viele Dank für Euer Verständnis
    Morgen versuche ich noch mal meinen Ursprungscode zu überarbeiten.

    Was für ein Roman:D

    Mr Crown
  • Ich habe das POroblem jetzt gelöst. Ich habe eure Beiträge gelesen, verstanden und in meinen Code mit eingebracht. Das Problem mit den Zeigern war nach dem Beitrag von quappo erledigt. Danke.
    Ich poste jetzt einfach mal meinen gesamten Code, wobei ich nur Änderungen in der Funktion "swapArray()" unternommen habe:

    PHP-Quellcode

    1. #include <iostream>
    2. #include <conio.h>
    3. using namespace std;
    4. int swapArray(int array[], int *index)
    5. {
    6. int d=*index;
    7. int swapper[d], e=0;
    8. do
    9. {
    10. swapper[e] = array[d-1]; //Das Array "array[]" wird umgedrht in das
    11. //das Array "swapper[]" geschriben
    12. e++;
    13. d--;
    14. }
    15. while (d >= 0);
    16. for (int j=0; j<=(*index); j++) //In dieser Schleife wird das Array "swapper[]"
    17. { //in das Array "array[]" zurückgeschrieben
    18. array[j] = swapper[j];
    19. }
    20. }
    21. int inArray (int *ar, int *zahl)
    22. {
    23. int c=0, i=0;
    24. do
    25. {
    26. ar[c] = *zahl % 10;
    27. *zahl /= 10;
    28. c++;
    29. }
    30. while (*zahl != 0);
    31. *zahl = c;
    32. swapArray (ar, &c);
    33. }
    34. int main ()
    35. {
    36. int a=0, myarray[10];
    37. cout << "Bitte geben Sie eine Zahl zwischen 0 und 2.1 Mrd. ein : ";
    38. cin >> a;
    39. inArray(myarray, &a);
    40. for (int j=0; j<a; j++)
    41. {
    42. cout << myarray[j];
    43. }
    44. getch();
    45. return 0;
    46. }
    Alles anzeigen


    Jetzt ist das vielleicht alles etwas umständlich, aber der Lerneffekt war groß (jedenfalls bei mir) und es klappt so, wie ich es mir am Anfang vorgestellt habe und mein Compiler scheint auch ganz zufrieden zu sein.

    Danke nochmal für eure großartige Hilfe.

    Mit freundlichen Grüßen

    Mr Crown