2 Strings zusammenfügen -- wie String mit richtiger Größe anlegen?



  • 1. sizeof(char) == 1
    2. Warum so umständlich, es gibt auch noch strcpy.

    char* target = malloc(min + 1);
    strcpy(target, f1);
    strcat(target, f2);
    


  • Hi Leute!
    Beide eurer Beispiele gehen, nur leider bei mir nicht (heißt ich hab wahrscheinlich woanders den Hund begraben)

    Im unteren Teil des Codes habe ich Fett markiert was das Problem ist.

    Es sollen mit diesem Code include Anweisungen eingefügt werden.
    Er ersetzt mir im data (das ist das source file) die include Anweisungen und soll eben danach das filecontent oben einfügen.

    Nur da hakt es wo.
    Naja vllt macht sich ja wer die Mühe das mal kurz zu überfliegen.

    Ihr müsst das File speichern und zusätzlich 3 Files anlegen:

    1. source.txt
    source Inhalt
    zb:
    #include "sepp.h"
    #include "hugo.h"
    int a=10;
    blab
    blab
    ...

    2. sepp.h
    bin der sepp
    3. hugo.h
    bin der hugo

    Die doIt() Funktion ist die Hauptfunktion, alles andere nur Hilfen.

    Fehler ist zb:

    *** glibc detected *** /home/berni/workspace/Compiler/Debug/Compiler: malloc(): memory corruption: 0x0804b3c0 ***
    ======= Backtrace: =========

    danke

    #include <stdio.h>
    #include <stdlib.h>
    #include <stdbool.h>
    #include <string.h>
    #include <ctype.h>
    #include <fcntl.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    
    int pos=0;
    char *data;
    
    char *removeSubString(char *str, int first, int last){
    	int i=0; 
    	int j=0; 
    	int size = strlen(str); 
    
    	char *target = (char * )malloc (size * sizeof(char));
    
    	for (i = 0; i  < first; i++){
    		*(target+i) = *(str+i);
    	}
    
    	for (j = last; j  < size; j++){
    		*(target+i) = *(str+j);
    		i++; 
    	}
    	*(target+i) = '\0';
    	str = target; 
    	return str; 
    
    }
    char getCharacter(){
    	char s = *(data+pos);
    	pos++;
    	return s;
    }
    char look(){
    	char look; 
    	int lookahead = pos;
    	if(data[pos] != '\0'){
    		look = *(data+lookahead); 
    	}
    	return look;
    }
    
    int getFilesize(char *filename){
      int k=0,i=0;
      FILE *source; 
      source = fopen(filename, "r");
      if(source == NULL)
      {
         fprintf(stderr,"Fehler beim Oeffnen ...\n");
      }
      else
      {
        while ( (i = fgetc(source)) != EOF){
          k++;
        }
      }
      return k;
    }
    
    char * readFile(char *filename){
      char * data;
      int i=0,j=0;
      FILE *source; 
      source = fopen(filename, "r");
      if(source == NULL)
      {
         fprintf(stderr,"Fehler beim Oeffnen ...\n");
      }
      else
      {
        int k = getFilesize(filename);
        data = (char *) malloc(k*sizeof(char));
        while ( (i = fgetc(source)) != EOF){
          *(data+j) = i;  
          j++;
        }
        *(data+j) = '\0';
        fclose(source);
      }
      return data;
    }
    
    int isLetter(char c){
    	return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));	
    }
    
    int isDigit(char c){
    	return (c >='0' && c <= '9');	
    }
    
    char *lowercase(char *str){
       char *t;
       for (t = str; *t; t++)
       {
           (*t) = tolower(*t);
       }
       return (str);
    }
    int isWhitespace(char c){	
    	if(c == '\n'){
    		pos++;
    	}
    	return (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f');
    }
    
    void doIt (char *input, char *output){
    	data = readFile(input);	 	//read source code 
    
    	char c, l;
    	int j=0, k=0, first=0, last=0,includeOk=0; 
    	int size = strlen(data); 
    	char *filename = (char *) malloc (40 * sizeof(char)); 
    	char *wert = (char *) malloc (size * sizeof(char));
    
    	while (k < size){
    		includeOk=0;
    		j=0; 
        	c = getCharacter();
        	l = look();
        	if(c == '#'){
        		   first = pos-1; 
    				while(isLetter(l) || (isDigit(l))){
    			    	c = getCharacter();
    			    	l = look();
    			        *(wert+j) = c;  
    			        j++;
    			        k++;
    			   }
    			     *(wert+j) = '\0';
    			     if (strcmp(lowercase(wert),"include")==0){
    			    	 includeOk=1; 
    					 //printf("%s\n", wert);
    				}
    				j=0;
    				c = getCharacter();	
    				while(isWhitespace(c) == 1){
    						c = getCharacter();	
    						l = look();//"
    				}
    				if (includeOk ==1 && c == '"'){
    						do{	//liefert filename
    
    					    	c = getCharacter(); 
    					    	l = look();
    					        *(filename+j) = c;  
    					        j++;
    					        k++;
    					   }while(l != '"');
    						*(filename+j) = '\0';
    
    						last = pos+1; 					    	
    
    						//printf("Filename: %s\n",filename);
    
    						data = removeSubString(data,first,last);
    						printf("-----------------------------------\n");
    						printf("%s\n", data); 
    						printf("-----------------------------------\n");
    
    						char * filecontent = readFile(filename);
    						printf("***************************-\n");
    						printf("%s\n", filecontent); 
    						printf("***************************-\n");
    				[i]		[b]/*int min = strlen(data) + strlen(filecontent);
    						char *target = malloc(min + 1);
    
    						strcpy(target, "abc");
    						strcat(target, "asdfasdf");*/[/b][/i]
    
    						k=0; 
    						pos = 0;
    				}
    				else{
    					k++;
    				}				
        	}
        	else{
        		k++;
        	}
    	}
    	printf("--------------------------------\n"); 
    	printf("%s\n",data);
    	printf("--------------------------------\n"); 
    
    }	
    
    int main(int argc, char *abrgv[]){    
    	doIt("source.txt","output.txt");  
    	return 0;
    }
    


  • 1metal3 schrieb:

    int getFilesize(char *filename){
      int k=0,i=0;
      FILE *source;
      source = fopen(filename, "r");
      if(source == NULL)
      {
         fprintf(stderr,"Fehler beim Oeffnen ...\n");
      }
      else
      {
        while ( (i = fgetc(source)) != EOF){
          k++;
        }
      }
      return k;
    }
    

    schon mal was von 'fseek' und 'ftell' gehört?
    🙂



  • Nein aber werds mir mal ansehen 🙂



  • 1metal3 schrieb:

    Nein aber werds mir mal ansehen 🙂

    ja, sollteste mal machen.
    zu deinem eigentlichen problem:
    ist 'min' immer gross genug?
    wo ist das 'free' zum 'malloc'?
    du überprüfst den rückgabewert von malloc nicht.
    und: lass es im debugger single-steppen, dann wirst du den fehler sicherlich schnell finden.
    🙂



  • Offtopic, aber dein Programm betreffend:

    Du solltest die Datei besser zeilenweise verwalten (also ein char **), dann brauchst du nicht immer den gesamten Dateiinhalt kopieren, sondern nur einzelne Zeilen verändern.

    Und da du schon <ctype.h> eingebunden hast, könntest du auch gleich deren Funktionen benutzen, um die Charaktertypen abzufragen:
    - isalpha
    - isdigit
    - isspace
    - iscntrl



  • Hi

    @debugging-freak
    min müsste schon groß genug sein
    free fehlt in der tat noch

    Was genau kann ich mit 'fseek' und 'ftell' vereinfachen?

    thx



  • @Th69

    danke für die tipps



  • 1metal3 schrieb:

    Was genau kann ich mit 'fseek' und 'ftell' vereinfachen?

    das rauskriegen der dateigrösse, ungefähr so:

    long size;
    FILE *fp = fopen (...);
    fseek (fp, 0, SEEK_END);
    size = ftell (fp);
    fclose (fp);
    

    in 'size' steht dann die grösse des files.
    🙂



  • Bitte sehr -)

    Du kannst einfach mit fseek() zum Dateiende springen und mittels ftell() die Größe auslesen (ohne jedes Zeichen einzeln zu lesen):

    fseek(file, -1, SEEK_END);
    int nSize = ftell(file);
    


  • vielen lieben Dank das ist echt spitzen Support hier 👍


Anmelden zum Antworten