führende "0" aus zeichenkette entfernen <meinung gefragt>



  • hi,

    ich versuche aus einer zeichenkette führende 0en (NULLen) zu entfernen und hab dazu folgenden code entworfen.

    strncpy(camd3_config.port,"00011",5);
    
    	printf("Davor: %s\n", camd3_config.port);
    
    	char sero[6];
    	strncpy(sero, camd3_config.port, 5);
    	strncpy(camd3_config.port, "", 5);
    	unsigned i = 0;
    	unsigned t = 0;
    	for (; i<sizeof(sero)-1; i++)
    	{
    		if ( sero[i] != '0' && sero[i] != '\0' || t>0 )
    		{
    			printf("%c\n", sero[i]);
    			camd3_config.port[t] = sero[i];
    			t++;
    		}
    		else if (sero[i] == '\0')
    			camd3_config.port[t] = '\0';
    	}
           printf("Danach: %s\n", camd3_config.port);
    

    er erfüllt seinen zweck, doch glaube ich, dass ich mich viel zu umständlich angestellt habe 😃
    in perl geht das einfacher 😉



  • Ohne deinen Code gelesen zu haben - lol:

    #include <string>
    #include <stdio>
    
    bool isinstr(char const& c, char * delims, unsigned int const& delimlen)
    {
        for(unsigned int i=0; i<delimlen; ++i)
            if(c == delims[i]) return true;
    
        return false;
    }
    
    void trim(char* alt, char* neu, char* delims)
    {
        while(isinstr(*alt, delims, strlen(delims))) ++alt;
        strcpy(neu, alt);
    }
    
    int main(int argc, char* argv[])
    {
        char alt[] = "00xx0x0Hex-Zahl: 0x8AB";
        char delims[] = "0x";
        char neu[20];
    
        trim(alt, neu, delims);
    
        printf("%s", neu);
    
        getchar();
    
        return 0;
    }
    

    Auf jeden Fall schon mal kürzer



  • FireFlow schrieb:

    Ohne deinen Code gelesen zu haben - lol:

    bool isinstr(char const& c, char * delims, unsigned int const& delimlen)
    {
        for(unsigned int i=0; i<delimlen; ++i)
            if(c == delims[i]) return true;
    
        return false;
    }
    

    Auf jeden Fall schon mal kürzer

    jo.
    strchr macht's noch kürzer.



  • ist das nicht c++ code?

    also mein compiler "gcc (GCC) 3.3.2 (Mandrake Linux 10.0 3.3.2-6mdk)" mag diesen code nicht.

    ich wollte jedoch die aufgabe in c erledigen und nicht in c++.



  • volkard schrieb:

    jo.
    strchr macht's noch kürzer.

    Das hab ich gesucht, mir ist es nur nicht eingefallen *hrhr*



  • also wenn ich mich nicht völlig irre, dann entfernt dein code nicht nur die führenden sondern alle nullen!

    wenn du aber wirklich nur die führenden nullen enfernen willst, dann würd ichs so machen:

    #include <string.h>
    
    strcpy(camd3_config.port,camd3_config.port+strspn(camd3_config.port,"0"));
    

    oder die sichere variante

    #include <string.h>
    
    char *cp;
    
    cp=camd3_config.port+strspn(camd3_config.port,"0");
    memmove(camd3_config.port,cp,strlen(cp));
    

    strspn(char *str, char *spn) gibt die position des ersten zeichens in str zurück, das nicht in spn enthalten ist. oder die länge von str, falls str kein zeichen aus spn enthält.

    EDIT
    ich depp 🤡 muß natürlich strspn() anstelle von strcspn() heißen...



  • @Konfusius: also dein code klappt nicht, die zeichenkette ist nach wie vor unverändert!



  • hab den code korrigiert. müsste jetzt gehen.



  • Ich hatte die C++ Header eingebunden die aber auch die alten C-Funktionen enthalten. So geht es:

    #include <cstring>
    void trim(char const* source, char* target, char const* delims)
    {
        while(strchr(delims, *source)) ++source;
        strcpy(target, source);
    }
    

    Schicker Zweizeiler 🙂 Aufruf wie oben. Gut dass volkhard nochmal an strchr() erinnert hat.



  • char * strip(char * src){
            char * tmp = src;
            while(*tmp=='0' && strlen(tmp)) tmp++;
            return memmove(src, tmp,strlen(tmp)+1);
    

    Kurz reingehackt, nicht getestet, nichtmal wirklich nachgedacht... happy debugging 😉



  • #include <stdio.h>
    
    void rem(char *arr);
    
    int main(int argc,char **argv)
    {
    	char arr[] = "0fuehrende 0 weg im text0bleibt sie";
    	rem(arr);
    
    	puts(arr);
    
    	return (0) ;
    }
    
    void rem(char *arr)
    {
    	int x=0;
    
    	while(arr[x]) 
    	{ 
    		if(arr[x]=='0'&&x==0) arr[x]=' ';
    		else if(arr[x]=='0'&&arr[x-1]==' ')	arr[x]=' ';
    		x++;
    	}
    }
    

    mfg hohesC



  • Also ich meine eine führende char(0) oder auch '\0'. Soll laud Thread beides weg.



  • aso hab mir nicht ganz durch gelesen!

    mfg hohesC

    [edit]er schrieb aber von "0" so einer null!!! naja egal..[/edit]



  • Höö? Ist doch egal ob char oder int oder long ode double oder bool... 0=false

    int main()
    {
        char test = '\0';
        if(test)
        {
            printf("%s", "true");
        }
        else
        {
            printf("%s", "false :P");
        }
    }
    

    🕶

    edit:

    if ( sero[i] != '0' && sero[i] != '\0' || t>0 )
    

    Ist aus seinem Source...



  • Du blickst es nicht! 😃

    Ich habs überflogen und dachte er wollte die

    char c='0';
    

    nullen raushaben!!!
    und die liefert nicht null sondern den int wert 48!!!

    mfg hohesC :p



  • Er will beides raus.



  • hab ich jetzt auch bemerkt 😉



  • FireFlow schrieb:

    Er will beides raus.

    Wollen kann man viel. Ob's sinnvoll ist, ist eine andere Sache. ( wir sprechen von Zeichenketten, ofmals auch 0-terminierte char-arrays genannt ).
    Kurt



  • char *kill_the_nulls (char* s)
    {
        while (*s && *s == '0')
            s++;
        return s;    
    }
    
    int main()
    {
        char *s = "000102";
        printf("%s\n", kill_the_null(s)); 
    }
    


  • Na wenn Du einfach Vornullen aus ´nem "Char*" entfernen willst um ein "int" zu kriegen, sollte es eigentlich "atoi(char*)" machen. Wenn du´s später wieder wandeln willst, gibt´s ´ne Menge Möglichkeiten
    "itoa()", "sprintf()" .
    Letztes formatiert es Dir dann auch wieder.


Anmelden zum Antworten