HIILLFFEEE

Hallo
Ich habe einen Algorithmus geschrieben, der einen String umdreht. Nun soll ich daraus ein Kommandozeilenprogramm entwickeln, das sich mit diesen Parametern steuern lässt. Ich möchte also über die Eingabeaufforderung ein Wort eingeben, welches umgedreht werden soll.
Kann mir vielleicht jemand sagen, wo im folgenden Quelltext der Fehler ist?
Das Problem muss in dr main -Fkt sein..
Ich wúrde hier in das Forum verwisen und hoffe, dass mir jemand helfen kann!
Das Programm ist wirklich wichtig für mich.
Leider bin ich noch nicht so gut, deshlab würde ich mich über ausführliche Antworten freuen.

Bedanke mich schon im vorraus

Eure Stephi

Code: 
# include <stdio.h> 
# include <string.h> 

int StringLaenge(string) 
{ 
   int laenge=0; 
   laenge = strlen(string); 
   return laenge; 

} 

char* StringUmdrehen(char string[81],int laenge) 
{ 
    int i; 
    int j=0; 
    char *pszstring; 
    char *psztemp; 
    char stringtemp[81]; 

    strcpy(stringtemp, string); 
    pszstring=string; 
    psztemp=stringtemp; 

    for (i = laenge-1; i >= 0; i--) 

    { 
    *(pszstring+j)=*(psztemp+i); 
    j++; 

    } 
    return stringtemp; 
} 

int main (int iArg, char *AszArg[]) 
{ 
    int iIndex = 0; 

    if (iArg<1) return 1; 

    while (iIndex<iArg) 
    { 
    printf("\n%i",iArg); 

    printf("\n%s",StringUmdrehen(AszArg[iIndex],iArg)); 

    printf("\n%s",AszArg); 

    iIndex++; 

    }

DarthZiu

Stephi# schrieb:

int StringLaenge(string) 
{ 
   int laenge=0; 
   laenge = strlen(string); 
   return laenge; 

}

Was bringt dir die Funktion? Es ist egal, ob du StringLaenge(char ) aufrufst, oder gleich strlen(char).

int main (int iArg, char *AszArg[]) 
{ 
    int iIndex = 0; 

    if (iArg<1) return 1; 

    while (iIndex<iArg) 
    { 
    printf("\n%i",iArg); 

    // wolltest du nicht die Länge des Strings übergeben?? iArg ist die Anzahl
    // der übergebenen Argumente
    printf("\n%s",StringUmdrehen(AszArg[iIndex],iArg));

    //printf("\n%s",AszArg); 
    // wohl eher so;
    printf("\n%s",AszArg[iIndex]); 

   iIndex++; 

    }

net 0

kannst es auch so machen

#include <stdio.h>

void rev (char *p)
{
   if (*p)
   {
      rev (p+1);
      putchar (*p);
   }
}

void main (int argc, char **argv)
{
   rev (argv[1]);
}

...ist viel weniger schreibarbeit

Perfekt! Danke!

Achja und zu weniger Schreibarbeit: Mein Skript in IT ist relativ mager. Heisst wie müssen uns mit ziemlich wenigen Mittel durch die Aufgaben hangeln. Dementsprechend würde mich jeder komisch anschauen, wenn ich plötzlich mit sowas relativ "unbekannten" ankäme wenn du weißt was ich meine..
Aber vielen Dank!!

stringtemp aus der Funktion StringUmdrehen() zurückzugeben ist illegal weil das Array nur lokal existiert. Wenn das so funktioniert ist das reiner Zufall.

Oh nein..

Dann geb ich einfach string zurück. Tut das "Gleiche". Also gibt gewissermaßen auch das aus, was ich haben möchte.
Warum ist das illegal? Weils nur eine Kopie ist?

GPC

ne, weil das Array am Ende der UmkehrFunktion wieder zerstört wird und dein Zeiger dann ins Nirvana zeigt.

Ich gebe ja nun in die EIngabeaufforderung z.B. "Programm.exe Hallo" ein.
Warum dreht er mir auch "Programm.exe" um? Wie sag ich ihm, dass er Programm.exe nicht auch noch umgedreht ausgeben soll?

net 0

Stephi# schrieb:

Ich gebe ja nun in die EIngabeaufforderung z.B. "Programm.exe Hallo" ein.
Warum dreht er mir auch "Programm.exe" um? Wie sag ich ihm, dass er Programm.exe nicht auch noch umgedreht ausgeben soll?

mach in der zeile "int iIndex = 0;" aus der 0 eine 1

Ach ja.
Und wenn ich jetzt einfach nichts in die Eingabeaufforderung eingebe und möchte, dass er beispielsweise "Fehlende Parameter" zurückgibt, warum kann ich dann nicht einfach

if (iArg<1) printf("Fehlende..

in den Quelltext eingeben?

net 0

du musst "argc < 2" abfragen. in argc steht die anzahl der startparameter+1. d.h.

argv[0] -> programmname oder was anderes
argv[1] -> erster parameter
argv[2] -> zweiter parameter
...usw...

Achso! Der Zeiger zeigt quasi immer auf einen ganzen Parameter!

Angenommen ich habe nun mehrere Funktionen. Beispielsweise eine die den String umdreht und einen andere, die die eingelesenen Strings nach Länge sortiert. Wie kann ich diese parametergesteuert ausführen? Hat mir jemand einen Tipp?

Swordfish

naja:

/*
 *	Include Files:
 */
#include <stdlib.h>     /* Standard library               */
#include <stdio.h>      /* Standard In-/Output routines   */
#include <string.h>     /* String processing routines     */

typedef enum arg {
    ARG_UNKNOWN = 0x00,
    ARG_HELP    = 0x01,
    ARG_VERSION = 0x02
} arg;

/*
 *	Argument Table:
 */

char arga_short[] = {
    'h',
    'v',
    '\0'
};

char *arga_long[] = {
    "help",
    "version",
    "\0"
};

char *arga_help[] = {
    "Displays this text",
    "Displays version information and exits",
    "\0"
};

/*
 *	Function Prototypes:
 */
char   *get_fname( char *str );
void    unknown_arg( char *arg );

void    cmdl_help( void );
void    cmdl_version( void );

int main( int argc, char **argv )
{
    char   *app_name = 0;
    char   *argn     = 0;
    arg     arg_num  = ARG_UNKNOWN;

    app_name = get_fname( *argv++ );

    if( !app_name )
        return EXIT_FAILURE;

    if( argc > 1 ) {

        while( !argv ) {

            argn = *argv;
            arg_num = ARG_UNKNOWN;

            if( ( argn[0] == '-' ) && ( argn[1] == '-' ) ) {

                argn += 2;

                for( ; arga_long[ arg_num ]; ++arg_num )
                    if( stricmp( argn, arga_long[ arg_num ] ) == 0 )
                        break;

                arg_num = !arga_long[ arg_num ] ? ARG_UNKNOWN : arg_num + 1;

            } else if( argn[0] == '-' ) {

                ++argn;

                for( ; arga_short[ arg_num ]; ++arg_num )
                    if(  ( ( argn[0] == arga_short[ arg_num ] )
                        || ( argn[0] == ( arga_short[ arg_num ] & ~0x20 ) ) )
                        && ( argn[1] == '\0' ) )
                        break;

                arg_num = !arga_short[ arg_num ] ? ARG_UNKNOWN : arg_num + 1;
            }

            switch( arg_num ) {

                case ARG_HELP:
                    cmdl_help( );
                    break;

                case ARG_VERSION:
                    cmdl_version( );
                    break;

                default:
                    unknown_arg( argn );
                    *argv = NULL;
                    break;

            } /* switch( arg_num ) */

            ++argv;

        } /* while( *argv ) */

    } /* if( argc > 1 ) */

    free( app_name );
    return EXIT_SUCCESS;
}

char*	get_fname( char *str )
{
	char	*last	= NULL;
	char	*fname	= NULL;

	do {
		++str;
		if( *str == '\\' ) {
			last = str;
			++str;
		}
	} while( !( ( *str == '\\' ) || ( *str == '\0' ) ) );

	if( !last )
		return NULL;

	++last;
	fname = ( char* ) malloc( strlen( last ) + 1 );

	if( !fname )
		return NULL;

	strcpy( fname, last );
	return fname;
}

void unknown_arg( char *arg )
{
    printf( "unknown argument \"%s\"!\n", arg );
}

void cmdl_help( void )
{
    int i = 0;

    cmdl_version( );

    printf( "\nCopyright (c) by you\n" );
    printf( "\nCommand line arguments:\n" );

    while( arga_short[ i ] ) {
        printf( "  -%c  -%s   %s\n", arga_short[i], arga_long[i], arga_help[i] );
        ++i;
    }
}

void cmdl_version( void )
{
    printf( "prog, version 0.1\n" );
}

so könnte man es sehr allgemein machen...

Greetz, Swordfish