[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 .

Schlagworte:
Status des Themas:
Es sind keine weiteren Antworten möglich.
  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
     
  3. 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. 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. 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. 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. 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. Video Script

    Videos zum Themenbereich

    * gefundene Videos auf YouTube, anhand der Überschrift.