[C/C++] Prob mit Array Übergabe/ Pointer auf Array(Vermut ich zumindest)

Dieses Thema im Forum "Programmierung & Entwicklung" wurde erstellt von thecoolman4rr, 8. November 2006 .

Status des Themas:
Es sind keine weiteren Antworten möglich.
  1. Diese Seite verwendet Cookies. Wenn du dich weiterhin auf dieser Seite aufhältst, akzeptierst du unseren Einsatz von Cookies. Weitere Informationen
  1. #1 8. November 2006
    Prob mit Array Übergabe/ Pointer auf Array(Vermut ich zumindest)

    Also... ich hatte vor ein einfaches Programm zu schreiben was einfach nur den Anfangsbuchstaben eines Wortes behält und alle anderen Buchstaben durch einander würfelt.
    Soweit so gut. Ich hab das ganze dann erstmal einfach so geschrieben ohne groß drüber nach zu denken. Lief auch (nach ner Zeit). Nur das ich für jede weitere stelle den Code vergrößern musste:
    bitte nach ganz rechts scrollen ich hatte keine Lust die ganzen Einrückungen raus zu machen, bzw. danach sah es noch schlimmer aus.
    Code:
    for(int o = 0; o < Anzahl; o++)
     {
     if(bLetterInUse[o] == false && Anzahl >= 6)
     {
     //cout << endl << Buchstabe1 << cBuchstabenRest[c] << cBuchstabenRest[y] << cBuchstabenRest[k] << cBuchstabenRest[o];
     bLetterInUse[o] = true;
     for(int cl = 0; cl < Anzahl; cl++)
     {
     if(bLetterInUse[cl] == false && Anzahl >= 7)
     {
     //cout << endl << Buchstabe1 << cBuchstabenRest[c] << cBuchstabenRest[y] << cBuchstabenRest[k] << cBuchstabenRest[l] << cBuchstabenRest[o] << cBuchstabenRest[cl];
     //RausGehts << endl << Buchstabe1 << cBuchstabenRest[c] << cBuchstabenRest[y] << cBuchstabenRest[k] << cBuchstabenRest[l] << cBuchstabenRest[o] << cBuchstabenRest[cl];
     bLetterInUse[cl] = true;
     for(int ql = 0; ql < Anzahl; ql++)
     {
     if(bLetterInUse[ql] == false)
     {
     cout << endl << Buchstabe1 << cBuchstabenRest[c] << cBuchstabenRest[y] << cBuchstabenRest[k] << cBuchstabenRest[l] << cBuchstabenRest[o] << cBuchstabenRest[cl] << cBuchstabenRest[ql];
     RausGehts << endl << Buchstabe1 << cBuchstabenRest[c] << cBuchstabenRest[y] << cBuchstabenRest[k] << cBuchstabenRest[l] << cBuchstabenRest[o] << cBuchstabenRest[cl] << cBuchstabenRest[ql];
     }
     }
     bLetterInUse[cl] = false;
     }
     else
     {
     cout << endl << Buchstabe1 << cBuchstabenRest[c] << cBuchstabenRest[y] << cBuchstabenRest[k] << cBuchstabenRest[l] << cBuchstabenRest[o] << cBuchstabenRest[cl];
     RausGehts << endl << Buchstabe1 << cBuchstabenRest[c] << cBuchstabenRest[y] << cBuchstabenRest[k] << cBuchstabenRest[l] << cBuchstabenRest[o] << cBuchstabenRest[cl];
     }
     }
     bLetterInUse[o] = false;
     }
    
    Wie man hier vll sieht ist das System relativ einfach.
    Es wird einfach geguckt, ob der Buchstabe bereits benutzt wurde, und wenn nicht wird er als Benutz makiert und dasselbe mit dem nächsten Buchstaben gemacht der macht dann wieder das nächste usw usw usw und am Ende wird dann in all den Schleifen praktisch einmal das komplette wort ausgegeben.

    Nun dachte ich... ok das ist umständlich... wie geht das besser und hab es dann "einfach" mit einer rekursiven Schleife gemacht. Und da ist nun mein Problem. Ich bin nämlich zu doof um char-array-pointer weiterzugeben. Wenn das funktionieren würde liefe vermutlich alles.
    Hier mein bisheriger Code:
    Code:
    /*
     * A little "Bruteforcer"
     * Written by thecoolman4rr
     * published because of needing help ^^
     *
     */
    
    #include <cstdlib>
    #include <iostream>
    
    using namespace std;
    
    void Brute(char *pErsterBuchstabe, char (*RestBuchstaben)[50], bool (*InUse)[50], int *pAktBstb, int *pBuchstabenAnzahl);
    
    int main(void)
    {
     cout << "\n<<<<<<<<< Test >>>>>>>>>>\n"; // Normaler Weise sollte hier eigentlich eine Usereingabe erfolgen aber so gehts einfacher zum Testen...
     char *pFirstLetter = new char; // Hier wird jetzt erstmal für den ganzen shice Speicherreserviert
     char RestBuchstaben[50];
     bool InUseOrNot[50];
     int *pAktBstb = new int;
     int *pBuchstabenAnzahl = new int;
     *pFirstLetter = 'A'; // Einfache Zuweisung... wie gesagt normal durch Eingabe
     *pBuchstabenAnzahl = 5;
     RestBuchstaben[0] = 'e';
     RestBuchstaben[1] = 'b';
     RestBuchstaben[2] = 'd';
     RestBuchstaben[3] = 'n';
     *pAktBstb = 0;
     for(int i = 0; i < 50; i++)
     {
     InUseOrNot[i] = false;
     }
     Brute(pFirstLetter, &RestBuchstaben, &InUseOrNot, pAktBstb, pBuchstabenAnzahl); // Übergabe an die Funktion Brute ^^
     int irgentwas; // nur damit das Fenster nicht direkt wieder zu geht
     cin >> irgentwas;
     delete(pFirstLetter); // sämtlichen Speicher wieder freigeben
     delete(pAktBstb);
     delete(pBuchstabenAnzahl);
     return 0;
    }
    
    void Brute(char *pErsterBuchstabe, char (*pRestBuchstaben)[50], bool (*pInUse)[50], int *pAktBstb, int *pBuchstabenAnzahl)
    {
     for(int i = 0; i < *pBuchstabenAnzahl; i++) // So oft durchlaufen bis jeder Buchstabe einmal "vorne" war
     {
     if(*pInUse[i] == false) // Wenn der Buchstabe noch nicht benutzt wurde
     {
     cout << *pRestBuchstaben[i] << "args" << *pInUse[i]; // Ausgeben
     *pInUse[i] = true; // Ihn als "benutzt" ausweisen
     *pAktBstb++; // Zählvariable wegen maximaler Wortlänge addieren
     Brute(pErsterBuchstabe, pRestBuchstaben, pInUse, pAktBstb, pBuchstabenAnzahl); // erneutes Aufrufen
     *pInUse[i] = false; // Nach dem Aufrufen natürlich wieder als "unbenutzt" ausweisen
     }
     if(*pAktBstb >= *pBuchstabenAnzahl) // Sobald die maximale Wortlänge erreicht wurde neue Zeile und ersten Buchstaben ausgeben
     {
     cout << endl << *pErsterBuchstabe;
     }
     }
    }
    Ihr könnts ja auch mal testen... der Pointer macht irgentwie immer scheiß. Sobald in der Funktion Brute i größer 0 ist, geht alles daneben, weil plötzlich dann die Arrays nicht mehr "normal" reagieren und einfach irgentwelche wilden Werte liefern.

    ick hoffe ihr habt ne nette Lösung für das Problemchen denn dann wäre alles wölkchen...

    mfg thecoolman4rr
     

  2. Anzeige
  3. #2 9. November 2006
    AW: Prob mit Array Übergabe/ Pointer auf Array(Vermut ich zumindest)

    Hi, habe das Prblem versucht anders anzugehen.

    Du schreibst, bei nem eingegebenen Wort soll der erste Buchstabe bleiben, und der rest durcheinandergewürfelt werden(zufällig)

    Schau dir mal folgenden Quellcode an ob das deinen Vorstellungen entspricht.

    Code:
    
    /*
     * Wordwrapper
     * 
     * From Apfelbusch 4 RR
     *
     */
    
    #include <iostream>
    using namespace std;
    #include <time.h>
    //////////////////////////////////////////////////////////////////////
    // Konstruktion/Destruktion
    //////////////////////////////////////////////////////////////////////
    
    
    int main(void){
     char* wort = new char;
     //Eingabe des Wortes
     cout << "Wort: "; cin >> wort;
     cout << "Originalwort: " << wort << endl;
     //Wortlänge herausfinden
     int laenge=1;
     while(wort[laenge]!='\0'){laenge++;}
     //benutzt-Variable kreieren, startwert == 0
     bool * benutzt=new bool[laenge];
     for(int i=0;i<laenge;i++){benutzt[i]=0;}
     //Anzahl noch nicht vertauschter Buchstaben
     int free=laenge-1;
     //Dummyvariable initialisieren die später zum Tauschen gebraucht wird
     char dummy='D'; 
    
     int x1=0;
     //int x1 = Random(laenge-1)+1;
     for(int j=1;j<laenge;j++){
     //Buchstabe wurde noch nicht vertauscht, es sind noch genug Buchstaben zum tauschen da...
     if (benutzt[j]==0 && free>0){
     //Random initialisieren
     srand (time(NULL));
     do{
     // Initialiesiert Zufallszahl x1 mit 1 < x1 < Wortlänge
     x1 = (rand()%(laenge-1))+1;
     }while(benutzt[x1]==1);
     //Vertauschen der gewählten elemente
     benutzt[j]=1;
     benutzt[x1]=1;
     dummy=wort[j];
     wort[j]=wort[x1];
     wort[x1]=dummy;
     free-=2;
     }
     }
     //Ausgabe des verdrehten wortes
     for(int k=0;k<laenge;k++){
     cout << wort[k];
     }
     cout << endl;
     //Stoppen des Programms
     int irgendwas;
     cin >> irgendwas;
     return 1;
    }
    
    Wenns okay ist, wäre Bewertung ganz nett, sonst nice try^^

    ciao - Apfelbusch
     
  4. #3 9. November 2006
    AW: Prob mit Array Übergabe/ Pointer auf Array(Vermut ich zumindest)

    hmm das ist nicht ganz das was ich möchte... ich möchte nämlich keine zufällige Ausgabe sondern praktisch eine geordnetet, das z.B. bei 8 Buchstaben, die ersten 6 erstmal stehen bleiben und nur die letzten beiden vertauscht werden. Dann wird innerhalb der letzten 3 getauscht und mit einem neuen dritten Buchstaben wird dann widerum innerhalb der letzt 2 getauscht usw.
    Hier mal ein Beispiel wie es mein bisheriges Prog auswirft(Ausschnitt bis der 2. Buchstabe verändert wurde, das richtige Wort wäre Kompiler gewesen):
    Code:
    Koplrmie
    Koplrmei
    Koplrime
    Koplriem
    Koplremi
    Koplreim
    Koplmrie
    Koplmrei
    Koplmire
    Koplmier
    Koplmeri
    Koplmeir
    Koplirme
    Koplirem
    Koplimre
    Koplimer
    Koplierm
    Kopliemr
    Koplermi
    Koplerim
    Koplemri
    Koplemir
    Kopleirm
    Kopleimr
    Koprlmie
    Koprlmei
    Koprlime
    Koprliem
    Koprlemi
    Koprleim
    Koprmlie
    Koprmlei
    Koprmile
    Koprmiel
    Koprmeli
    Koprmeil
    Koprilme
    Koprilem
    Koprimle
    Koprimel
    Koprielm
    Koprieml
    Koprelmi
    Koprelim
    Kopremli
    Kopremil
    Kopreilm
    Kopreiml
    Kopmlrie
    Kopmlrei
    Kopmlire
    Kopmlier
    Kopmleri
    Kopmleir
    Kopmrlie
    Kopmrlei
    Kopmrile
    Kopmriel
    Kopmreli
    Kopmreil
    Kopmilre
    Kopmiler
    Kopmirle
    Kopmirel
    Kopmielr
    Kopmierl
    Kopmelri
    Kopmelir
    Kopmerli
    Kopmeril
    Kopmeilr
    Kopmeirl
    Kopilrme
    Kopilrem
    Kopilmre
    Kopilmer
    Kopilerm
    Kopilemr
    Kopirlme
    Kopirlem
    Kopirmle
    Kopirmel
    Kopirelm
    Kopireml
    Kopimlre
    Kopimler
    Kopimrle
    Kopimrel
    Kopimelr
    Kopimerl
    Kopielrm
    Kopielmr
    Kopierlm
    Kopierml
    Kopiemlr
    Kopiemrl
    Kopelrmi
    Kopelrim
    Kopelmri
    Kopelmir
    Kopelirm
    Kopelimr
    Koperlmi
    Koperlim
    Kopermli
    Kopermil
    Koperilm
    Koperiml
    Kopemlri
    Kopemlir
    Kopemrli
    Kopemril
    Kopemilr
    Kopemirl
    Kopeilrm
    Kopeilmr
    Kopeirlm
    Kopeirml
    Kopeimlr
    Kopeimrl
    Kolprmie
    Kolprmei
    Kolprime
    Kolpriem
    Kolpremi
    Kolpreim
    Kolpmrie
    Kolpmrei
    Kolpmire
    Kolpmier
    Kolpmeri
    Kolpmeir
    Kolpirme
    Kolpirem
    Kolpimre
    Kolpimer
    Kolpierm
    Kolpiemr
    Kolpermi
    Kolperim
    Kolpemri
    Kolpemir
    Kolpeirm
    Kolpeimr
    Kolrpmie
    Kolrpmei
    Kolrpime
    Kolrpiem
    Kolrpemi
    Kolrpeim
    Kolrmpie
    Kolrmpei
    Kolrmipe
    Kolrmiep
    Kolrmepi
    Kolrmeip
    Kolripme
    Kolripem
    Kolrimpe
    Kolrimep
    Kolriepm
    Kolriemp
    Kolrepmi
    Kolrepim
    Kolrempi
    Kolremip
    Kolreipm
    Kolreimp
    Kolmprie
    Kolmprei
    Kolmpire
    Kolmpier
    Kolmperi
    Kolmpeir
    Kolmrpie
    Kolmrpei
    Kolmripe
    Kolmriep
    Kolmrepi
    Kolmreip
    Kolmipre
    Kolmiper
    Kolmirpe
    Kolmirep
    Kolmiepr
    Kolmierp
    Kolmepri
    Kolmepir
    Kolmerpi
    Kolmerip
    Kolmeipr
    Kolmeirp
    Koliprme
    Koliprem
    Kolipmre
    Kolipmer
    Koliperm
    Kolipemr
    Kolirpme
    Kolirpem
    Kolirmpe
    Kolirmep
    Kolirepm
    Koliremp
    Kolimpre
    Kolimper
    Kolimrpe
    Kolimrep
    Kolimepr
    Kolimerp
    Kolieprm
    Koliepmr
    Kolierpm
    Koliermp
    Koliempr
    Koliemrp
    Koleprmi
    Koleprim
    Kolepmri
    Kolepmir
    Kolepirm
    Kolepimr
    Kolerpmi
    Kolerpim
    Kolermpi
    Kolermip
    Koleripm
    Kolerimp
    Kolempri
    Kolempir
    Kolemrpi
    Kolemrip
    Kolemipr
    Kolemirp
    Koleiprm
    Koleipmr
    Koleirpm
    Koleirmp
    Koleimpr
    Koleimrp
    Korplmie
    Korplmei
    Korplime
    Korpliem
    Korplemi
    Korpleim
    Korpmlie
    Korpmlei
    Korpmile
    Korpmiel
    Korpmeli
    Korpmeil
    Korpilme
    Korpilem
    Korpimle
    Korpimel
    Korpielm
    Korpieml
    Korpelmi
    Korpelim
    Korpemli
    Korpemil
    Korpeilm
    Korpeiml
    Korlpmie
    Korlpmei
    Korlpime
    Korlpiem
    Korlpemi
    Korlpeim
    Korlmpie
    Korlmpei
    Korlmipe
    Korlmiep
    Korlmepi
    Korlmeip
    Korlipme
    Korlipem
    Korlimpe
    Korlimep
    Korliepm
    Korliemp
    Korlepmi
    Korlepim
    Korlempi
    Korlemip
    Korleipm
    Korleimp
    Kormplie
    Kormplei
    Kormpile
    Kormpiel
    Kormpeli
    Kormpeil
    Kormlpie
    Kormlpei
    Kormlipe
    Kormliep
    Kormlepi
    Kormleip
    Kormiple
    Kormipel
    Kormilpe
    Kormilep
    Kormiepl
    Kormielp
    Kormepli
    Kormepil
    Kormelpi
    Kormelip
    Kormeipl
    Kormeilp
    Koriplme
    Koriplem
    Koripmle
    Koripmel
    Koripelm
    Koripeml
    Korilpme
    Korilpem
    Korilmpe
    Korilmep
    Korilepm
    Korilemp
    Korimple
    Korimpel
    Korimlpe
    Korimlep
    Korimepl
    Korimelp
    Korieplm
    Koriepml
    Korielpm
    Korielmp
    Koriempl
    Koriemlp
    Koreplmi
    Koreplim
    Korepmli
    Korepmil
    Korepilm
    Korepiml
    Korelpmi
    Korelpim
    Korelmpi
    Korelmip
    Korelipm
    Korelimp
    Korempli
    Korempil
    Koremlpi
    Koremlip
    Koremipl
    Koremilp
    Koreiplm
    Koreipml
    Koreilpm
    Koreilmp
    Koreimpl
    Koreimlp
    Komplrie
    Komplrei
    Komplire
    Komplier
    Kompleri
    Kompleir
    Komprlie
    Komprlei
    Komprile
    Kompriel
    Kompreli
    Kompreil
    Kompilre
    Kompiler <--------- Hier ist es richtig (hab ich nachträglich reingeschrieben)
    Kompirle
    Kompirel
    Kompielr
    Kompierl
    Kompelri
    Kompelir
    Komperli
    Komperil
    Kompeilr
    Kompeirl
    Komlprie
    Komlprei
    Komlpire
    Komlpier
    Komlperi
    Komlpeir
    Komlrpie
    Komlrpei
    Komlripe
    Komlriep
    Komlrepi
    Komlreip
    Komlipre
    Komliper
    Komlirpe
    Komlirep
    Komliepr
    Komlierp
    Komlepri
    Komlepir
    Komlerpi
    Komlerip
    Komleipr
    Komleirp
    Komrplie
    Komrplei
    Komrpile
    Komrpiel
    Komrpeli
    Komrpeil
    Komrlpie
    Komrlpei
    Komrlipe
    Komrliep
    Komrlepi
    Komrleip
    Komriple
    Komripel
    Komrilpe
    Komrilep
    Komriepl
    Komrielp
    Komrepli
    Komrepil
    Komrelpi
    Komrelip
    Komreipl
    Komreilp
    Komiplre
    Komipler
    Komiprle
    Komiprel
    Komipelr
    Komiperl
    Komilpre
    Komilper
    Komilrpe
    Komilrep
    Komilepr
    Komilerp
    Komirple
    Komirpel
    Komirlpe
    Komirlep
    Komirepl
    Komirelp
    Komieplr
    Komieprl
    Komielpr
    Komielrp
    Komierpl
    Komierlp
    Komeplri
    Komeplir
    Komeprli
    Komepril
    Komepilr
    Komepirl
    Komelpri
    Komelpir
    Komelrpi
    Komelrip
    Komelipr
    Komelirp
    Komerpli
    Komerpil
    Komerlpi
    Komerlip
    Komeripl
    Komerilp
    Komeiplr
    Komeiprl
    Komeilpr
    Komeilrp
    Komeirpl
    Komeirlp
    Koiplrme
    Koiplrem
    Koiplmre
    Koiplmer
    Koiplerm
    Koiplemr
    Koiprlme
    Koiprlem
    Koiprmle
    Koiprmel
    Koiprelm
    Koipreml
    Koipmlre
    Koipmler
    Koipmrle
    Koipmrel
    Koipmelr
    Koipmerl
    Koipelrm
    Koipelmr
    Koiperlm
    Koiperml
    Koipemlr
    Koipemrl
    Koilprme
    Koilprem
    Koilpmre
    Koilpmer
    Koilperm
    Koilpemr
    Koilrpme
    Koilrpem
    Koilrmpe
    Koilrmep
    Koilrepm
    Koilremp
    Koilmpre
    Koilmper
    Koilmrpe
    Koilmrep
    Koilmepr
    Koilmerp
    Koileprm
    Koilepmr
    Koilerpm
    Koilermp
    Koilempr
    Koilemrp
    Koirplme
    Koirplem
    Koirpmle
    Koirpmel
    Koirpelm
    Koirpeml
    Koirlpme
    Koirlpem
    Koirlmpe
    Koirlmep
    Koirlepm
    Koirlemp
    Koirmple
    Koirmpel
    Koirmlpe
    Koirmlep
    Koirmepl
    Koirmelp
    Koireplm
    Koirepml
    Koirelpm
    Koirelmp
    Koirempl
    Koiremlp
    Koimplre
    Koimpler
    Koimprle
    Koimprel
    Koimpelr
    Koimperl
    Koimlpre
    Koimlper
    Koimlrpe
    Koimlrep
    Koimlepr
    Koimlerp
    Koimrple
    Koimrpel
    Koimrlpe
    Koimrlep
    Koimrepl
    Koimrelp
    Koimeplr
    Koimeprl
    Koimelpr
    Koimelrp
    Koimerpl
    Koimerlp
    Koieplrm
    Koieplmr
    Koieprlm
    Koieprml
    Koiepmlr
    Koiepmrl
    Koielprm
    Koielpmr
    Koielrpm
    Koielrmp
    Koielmpr
    Koielmrp
    Koierplm
    Koierpml
    Koierlpm
    Koierlmp
    Koiermpl
    Koiermlp
    Koiemplr
    Koiemprl
    Koiemlpr
    Koiemlrp
    Koiemrpl
    Koiemrlp
    Koeplrmi
    Koeplrim
    Koeplmri
    Koeplmir
    Koeplirm
    Koeplimr
    Koeprlmi
    Koeprlim
    Koeprmli
    Koeprmil
    Koeprilm
    Koepriml
    Koepmlri
    Koepmlir
    Koepmrli
    Koepmril
    Koepmilr
    Koepmirl
    Koepilrm
    Koepilmr
    Koepirlm
    Koepirml
    Koepimlr
    Koepimrl
    Koelprmi
    Koelprim
    Koelpmri
    Koelpmir
    Koelpirm
    Koelpimr
    Koelrpmi
    Koelrpim
    Koelrmpi
    Koelrmip
    Koelripm
    Koelrimp
    Koelmpri
    Koelmpir
    Koelmrpi
    Koelmrip
    Koelmipr
    Koelmirp
    Koeliprm
    Koelipmr
    Koelirpm
    Koelirmp
    Koelimpr
    Koelimrp
    Koerplmi
    Koerplim
    Koerpmli
    Koerpmil
    Koerpilm
    Koerpiml
    Koerlpmi
    Koerlpim
    Koerlmpi
    Koerlmip
    Koerlipm
    Koerlimp
    Koermpli
    Koermpil
    Koermlpi
    Koermlip
    Koermipl
    Koermilp
    Koeriplm
    Koeripml
    Koerilpm
    Koerilmp
    Koerimpl
    Koerimlp
    Koemplri
    Koemplir
    Koemprli
    Koempril
    Koempilr
    Koempirl
    Koemlpri
    Koemlpir
    Koemlrpi
    Koemlrip
    Koemlipr
    Koemlirp
    Koemrpli
    Koemrpil
    Koemrlpi
    Koemrlip
    Koemripl
    Koemrilp
    Koemiplr
    Koemiprl
    Koemilpr
    Koemilrp
    Koemirpl
    Koemirlp
    Koeiplrm
    Koeiplmr
    Koeiprlm
    Koeiprml
    Koeipmlr
    Koeipmrl
    Koeilprm
    Koeilpmr
    Koeilrpm
    Koeilrmp
    Koeilmpr
    Koeilmrp
    Koeirplm
    Koeirpml
    Koeirlpm
    Koeirlmp
    Koeirmpl
    Koeirmlp
    Koeimplr
    Koeimprl
    Koeimlpr
    Koeimlrp
    Koeimrpl
    Koeimrlp
    Kpolrmie
    Kpolrmei
    
    Des weiteren möchte ich praktisch am Anfang nur das durcheinander gewürfelte Wort haben, es durch das Prog laufen lassen und dann alle Möglichkeiten haben wie das Wort richtig aussehen könnte.
    Meines Erachtens ist das mit deinem Vorschlag nicht realisierbar (oder bin ich nur nicht durchgestiegen!?).
    Dein Code vertauscht einfach alle Buchstaben (außer den ersten ok) aber ohne System.
    Hast aber natürlich trotzdem Punkte für deinen Vorschlag bekommen =)

    mfg thecoolman4rr

    PS: da das vollständige ergebnis zu lang war (46216 Zeichen das max liegt bei 20000) hab ichs bei xup hochgeladen. *Klick misch*
     
  5. #4 9. November 2006
    AW: Prob mit Array Übergabe/ Pointer auf Array(Vermut ich zumindest)

    Hallo!

    Habe mich ein wenig im Netz umgeschaut und folgenden Code gefunden, der zuerst nur mit Integer lief nun aber auch Strings bearbeitet, handelt sich um ein einfaches Permutationsprogramm, welches alle möglichen Kombinationen eines eingegebenen Wortes auflistet.

    Code:
    /*
     * Permutation
     * Idefix!4RR
     *
     */
    
    #include <stdio.h>
    #include <iostream>
    
    using namespace std;
    
    void print(const char *v, const int size)
    {
     if (v != '\0') {
     for (int i = 0; i < size; i++) {
     //printf("%4d", v[i] );
     cout << v[i];
     }
     //printf("\n");
     cout << endl;
     }
    } // print
    
    
    void permute(char *v, const int start, const int n)
    { 
     if (start == n-1) {
     print(v, n);
     }
     else {
     for (int i = start; i < n; i++) {
     char tmp = v[i];
     
     v[i] = v[start];
     v[start] = tmp;
     permute(v, start+1, n);
     v[start] = v[i];
     v[i] = tmp;
     }
     }
    }
    
    main()
    {
     char v[] = "Test";
     permute(v, 1, (sizeof(v)-1)/sizeof(char));
     int variable;
     cin >> variable;
    }
    ich hoffe mal es ist in etwa das was du suchtest.

    Gruß - Idefix!
     
  6. #5 9. November 2006
    AW: Prob mit Array Übergabe/ Pointer auf Array(Vermut ich zumindest)

    soweit ich weiß, müssen die Parameter anders sein. 1. der Name eines Arrays ist in c++ automatisch ein pointer auf das erste element. deswegen ist das (*pRestBuchstaben)[50] doppel gemoppelt. das würde soweit ich weiß heißen, dass du einen pointer auf einen Array voller pointer auf char hast.. und das ist ja falsch.. so wird der buchstabe wahrscheinlich als adresse interpretiert... und deswegen läuft alles drunter und drüber.. als Lösung würde ich vorschlagen, die 50 per zusätzlichem parameter zu übergeben und das array anzupassen.. also:

    void Brute(char *pErsterBuchstabe, char *pRestBuchstaben, bool *pInUse, int *pAktBstb, int *pBuchstabenAnzahl, int *pRestBuchstabenAnzahl, int *pInUseAnzahl)


    alles untested, aber ich hoffe es hilft..
     
  7. #6 10. November 2006
    AW: Prob mit Array Übergabe/ Pointer auf Array(Vermut ich zumindest)

    thx ihr beiden... der Code von Idefix! macht genau das was ich wollte... seeeehr nett.. ich bin im moment noch dabei zu verstehen wie und warum aber das ist ja egal.
    Den Vorschlag von P4n1k hab ich bis jetzt noch nicht ausprobiert aber ich hab inzwischen ähnliches gelesen und kann mir daher gut vorstellen das es funktioniert =))

    Somit ist das Thema erledigt und ich schließe es.

    mfg thecoolman4rr
     

  8. Videos zum Thema
Die Seite wird geladen...