Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Textfilter per Konsole...finde den Fehler nicht :(

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 < [ 2 ]
000
05.01.2004, 15:36 Uhr
~MarsKlaus73
Gast


Hallo Zusammen...

Ich möchte (muss :-\) einen Textfilter schreiben der einen string nach ent. vorgaben auswertet. Zum besseren Verständnis paste ich mal kurz die Aufgabenstellung:

Zitat:

Schreiben Sie einen Filter, der eine Zeichenkette (Textdatei)
über stdin einliest und diese je nach KommandozeilenParameter
unterschiedlich verarbeitet. Die Verarbeitung soll dabei
zeichenweise erfolgen (getchar() und putchar()).
• Wird kein Parameter angegeben, so bleiben die Daten
unverändert und werden direkt auf stdout ausgegeben.
• Wird der Parameter u angegeben, so sollen nur alle
Großbuchstaben ausgegeben werden.
• Wird der Parameter l angegeben, so sollen nur alle
Kleinbuchstaben ausgegeben werden.
• Ist zusätzlich zu u oder l noch der Parameter c angegeben
worden, so sollen alle Buchstaben in das entsprechende Format
konvertiert werden (Groß/Kleinschreibung).




Sobald ich das programm ausführe bekomme ich speicherfehler en mase,
das liegt wohl an der Art und weise wie ich versuche auf argv zuzugreifen...aber ich frimmel schon den halben Tag daran rum und es bessert sich nichts vielleicht könnt ihr mir ja helfen...hier mein quellcode


C++:
#include "stdio.h"
#include "ctype.h"
#include "conio.h"

main(int argc,char **argv)
{
if (argv[1][0] = '-') // Sucht nach dem Bindestreich , welcher Indikator für die Option (u oder l) ist
{
     switch (argv[1][1]) // Geht auf die nächste Stelle nach dem Bindestreich um die Option zu prüfen
     {
     case 'u':
        while(argv[2][0]!='\0') //...solange er nicht die abschliesende 0 des Strings findet
        { int zaehler_u=0;
            if (isupper(argv[2][zaehler_u])) //...sucht zeichenweise nach Grossbuchstaben...
            { putchar(argv[2][zaehler_u]); //...und gibt diese aus
            zaehler_u++;}
        }
        break;

     case 'l':
        while(argv[2][0]!='\0')
        { int zaehler_l=0;
            if (islower(argv[2][zaehler_l])) //dasselbe Spiel wie bei 'u' nur mit is lower
            { putchar(argv[2][zaehler_l]);
            zaehler_l++;}
        }
        break;

     default:

    puts(argv); // wenn keine Arugmente angegeben werden, wird der String direkt wieder ausgegeben
    break;
     }

}
     getch();
}

 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
05.01.2004, 16:02 Uhr
(un)wissender
Niveauwart


Mach mal int main(int argc, char*args[]), dann testest du mit argc, bevor du auf args zugreifst!
In deinen Schleifen fragst du konstante Bedingungen ab, immer ein Fehler!
(Zumindest wenn du die Schleife nicht anders verlässt, mit z.B. break, return, throw)
Vorschlag:

C++:
if(argc > 2)
for(int zaehler = 0; args[2][zaehler]´!= '\0'; ++zaehler) {
  if (isupper(args[2][zaehler])) //...sucht zeichenweise nach Grossbuchstaben...
   putchar(argv[2][zaehler]);
}


--
Wer früher stirbt ist länger tot.

Dieser Post wurde am 05.01.2004 um 16:06 Uhr von (un)wissender editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
05.01.2004, 16:05 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)


auf den parser hab ich gerade kein bock....
ohne das zu testen filter sollte so gehen...

C++:
void filter(char* text,int l,int u,int c){

    for(char*p=text;*p;++p)
        if(isalpha(*p)){
            if(c&&l)putchar(tolower(*p));
            if(c&&u)putchar(toupper(*p));
            if(!c&&u&&isupper(*p))putchar(*p);
            if(!c&&l&&islower(*p))putchar(*p);
        }
        else putchar(*p);

}

int main(){
char text[]="Ich wohne in 12345 Berlin";
filter(text,0,1,1);
printf("\n");
}


--
...fleißig wie zwei Weißbrote
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
05.01.2004, 16:17 Uhr
(un)wissender
Niveauwart


DER Windalf mal wieder, du Querolant!
Leerzeichen sind noch konstenlos, auch wenn ihr BWLer das bestimmt bald ändert
Frohes neues Jahr habe ich dir, glaube ich, noch nicht gewünscht, sei es hier mit nachgeholt.
--
Wer früher stirbt ist länger tot.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
05.01.2004, 16:20 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)



Zitat:

Leerzeichen sind noch konstenlos, auch wenn ihr BWLer das bestimmt bald ändert


hehe, gute Idee darauf einen Preis einzuführen....
Absofort bekomme ich von jedem der in seinen Posts Leerzeichen verwendet für jedes ein virtuelles ...


Zitat:

Frohes neues Jahr habe ich dir, glaube ich, noch nicht gewünscht, sei es hier mit nachgeholt.


Wünsch ich dir auch verspätet und allen anderen die ich vergessen habe
--
...fleißig wie zwei Weißbrote
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
05.01.2004, 17:18 Uhr
(un)wissender
Niveauwart


Ich als Meta-BWLer würde mir einfach die Rechte an allen virtuellen (Weizen-)Bieren sichern und dann müßtest du zahlen, bis der Gerichtsvollzieher kommt.
Außerdem lasse ich mir konstenlos patentieren, kostenlos kann jeder!
--
Wer früher stirbt ist länger tot.

Dieser Post wurde am 05.01.2004 um 17:22 Uhr von (un)wissender editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
05.01.2004, 17:38 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)


Dann lass ich mir die Idee sich virtuelles WeizenBier patentieren zu lassen Patentieren und dann müsstest du mir wieder was zahlen... (und von ihrer Väter Väter ... und von ihrer Väter Väter Väter... und von ihrer *plonk* Danke reicht genauer brauchen wirs nicht)
--
...fleißig wie zwei Weißbrote
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
05.01.2004, 17:42 Uhr
Hans
Library Walker
(Operator)



C++:
#include <stdio.h>
#include <ctype.h>
#include <conio.h>

Das hier:
C++:
#include "stdio.h"
#include "ctype.h"
#include "conio.h"
sollte so aussehen|CPP||also die Anführungszeichen durch spitze Klammern ersetzt. Sonst könnte der Compiler nämlich meinen, Du hättest eigene Dateien mit diesen Namen, und sucht danach. Dabei ignoriert er die Standardmässig vorhandenen.

Hans
--
Man muss nicht alles wissen, aber man sollte wissen, wo es steht. Zum Beispiel hier: Nachdenkseiten oder Infoportal Globalisierung.

Dieser Post wurde am 05.01.2004 um 17:46 Uhr von Hans editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
12.01.2004, 23:09 Uhr
~MarsKlaus
Gast


Hallo, ich wieder!

Erst einmal Danke für die Antworten und sorry das ich so lange keine Rückmeldung gegeben habe, musste noch ein bischen Arbeit dazwischen schieben.

Ich habe das Programm von Grund auf neu beschrieben, bekomme aber immer noch einen Speicherfehler...vielleicht seht ihr es euch mal an evt. kompiliert es sogar damit ihr den Fehler sehen könnt...wenn nicht kann ich euch auch die Meldung des debuggers posten...


C++:
#include <stdio.h>
#include <ctype.h>
//#include <conio.h>

main(int argc,char *argv[]) //Argumente kommen von der shell
{
int uflag=0;
int lflag=0;
int cflag=0;
int zaehler=0;
int argc2=argc; // Ich sichere den Argument Counter
int argc_mark=argc; //Hier dasselbe...
while(argc2!=0)    //Solange der argv noch nicht auf 0 runtergezaehlt wurde
{
        if (argv[argc2][0] == '-') // Sucht nach dem -
            {    
            
                argc_mark=argc2;    //Das hier ist dann die spätere Obergrenze für die Textverarbeitung
                                    //das erklärt sich wie folgt: argc wird von oben runtergezaehlt (siehe argc2--)
                                    //sobald er auf einem - trift ist klar das die darunter liegenden Argumente alle nur
                                    //noch die Verarbeitungsparameter ala -c -u etc. sein können (Davon wird hier einfach ausgegangen
                                    //Also haben wir fuer spaeter die Grenze ab wo die Verarbeitungsparameter aufhoeren und wo die
                                    //Textparameter anfangen. Ich hoffe das war verständlich :)

                switch (argv[argc2][1]) // Wird wird geugt welcher Verarbeitungsparameter eigentlich vorhanden ist.
                    {
    
                case 'u': uflag=1;  //
                    break;            //
                case 'l': lflag=1;  //Ich denke das hier ist soweit klar
                    break;            //
                case 'c': cflag=1;  //
                    break;            //
                    }                
    
            }
    argc2--;            //wie oben erwähnt wird hier dann der counter runtergezaehlt.    
    }


argc2=argc;            //Hier setze ich den argc2 wieder zurueck.




if ((uflag==1 && cflag==0 && uflag==0))            //Hier werden in den folgenden if schleifen geprueft ob die obrige schleife eine der flags ent. gesetzt hat
    {
        while(argc_mark!=argc )                    //Solange der argc Zaehler hier nicht den wert des eigentlich Argument counters hat                                    
        {
            if (isupper(argv[argc_mark][zaehler]))        // hier wird zeichenweise ueberprueft ob das zeichen gross geschrieben ist                        
            {
                putchar(argv[argc_mark][zaehler]);                                // und bei bedarf ausgegeben
            }
            zaehler++;                                    // Hier wir der Seperate Zaehler fuer die 2. Array stelle erhoert damit wird durch den string laufen koennen
            if (argv[argc_mark][zaehler]=='\0' )        //Diese Schleife hat den Zweck damit man das argument erhoehen kann...also die erste stelle des arrays
            {
                argc_mark++;
                zaehler=0;
            }
        }
    }
                                            // bei den anderen Schleifen ist nur die bearbeitung ent. abgewandelt...
if ((uflag==0 && cflag==1 && uflag==0))
    {
        while(argc_mark!=argc )                                        
        {
            if (islower(argv[argc_mark][zaehler]))                                
            {
                putchar(argv[argc_mark][zaehler]);                                
            }
            zaehler++;
            if (argv[argc_mark][zaehler]=='\0' )
            {
                argc_mark++;
                zaehler=0;
            }
        }
    }

if ((uflag==1 && cflag==0 && uflag==1))
    {
        while(argc_mark!=argc )                                        
        {
            if (islower(argv[argc_mark][zaehler]))                                
            {
                toupper(argv[argc_mark][zaehler]);
                                                
            }
            putchar(argv[argc_mark][zaehler]);
            zaehler++;
            if (argv[argc_mark][zaehler]=='\0' )
            {
                argc_mark++;
                zaehler=0;
            }
        }
    }
if ((uflag==0 && cflag==1 && uflag==1))
    {
        while(argc_mark!=argc )                                        
        {
            if (isupper(argv[argc_mark][zaehler]))                                
            {
                tolower(argv[argc_mark][zaehler]);
                                                
            }
            putchar(argv[argc_mark][zaehler]);
        
            zaehler++;
            if (argv[argc_mark][zaehler]=='\0' )
            {
                argc_mark++;
                zaehler=0;
            }
        }
    }
if ((uflag==1 && lflag==1))
        {
        puts("Bitte u ODER l als Verarbeitungsoperand benutzen. Nicht beide!");
        }

    // getch();
}



Der Debugger bricht bei :

C++:
if (argv[argc2][0] == '-') // Sucht nach dem -


mit diesem Fehler

Code:
argv    0x00320c38    char * *
0x00320c4c "uebung7_work.exe"    char *
117 'u'    char
------------
argv[argc2]    0x00000000 <Schlechtes Ptr>    char *
CXX0030: Fehler: Ausdruck kann nicht ausgewertet werden    char


ab...

Vielleicht findet ja jemand den knackpunkt ich finde ihn nicht...

yours
klaus
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
13.01.2004, 11:31 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)


meinst du so?...

C++:
#include <stdio.h>
#include <ctype.h>

void filter(char* text,int l,int u,int c){
    for(char*p=text;*p;++p)
        if(isalpha(*p)&&(l||u||c)){
            if(c&&l)putchar(tolower(*p));
            if(c&&u)putchar(toupper(*p));
            if(!c&&u&&isupper(*p))putchar(*p);
            if(!c&&l&&islower(*p))putchar(*p);
        }
        else putchar(*p);
}

main(int argc,char *argv[]){

int j,i,uflag=0,lflag=0,cflag=0;
char buffer[5000];//sollte hoffentlich reichen...

for(i=argc-1;argv[i][0]!='-'&& i>0;--i);

for(j=i;j>0;--j){
    if(argv[j][1]=='u')uflag=1;
    if(argv[j][1]=='l')lflag=1;
    if(argv[j][1]=='c')cflag=1;
}
for(*buffer=0,++i;i<argc;++i)sprintf(buffer,"%s%s ",buffer,argv[i]);
filter(buffer,lflag,uflag,cflag);
return 0;
}


--
...fleißig wie zwei Weißbrote

Dieser Post wurde am 13.01.2004 um 11:37 Uhr von Windalf editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 < [ 2 ]     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: