Necesito ayuda con un ejercicio que se basa en quitar los espacios en blancos del principio de un fichero, lo he intentado con este codigo pero en el fichero auxiliar solo me salen ÿ, por todos lados.
#include <stdio.h>
#include <string.h>
#define filelenght
void borrarespacio(FILE *f);

int main() {
   char nombre[filelenght+1];
   FILE *f;
   
   printf("Introduce el nombre del fichero: \n");
   fflush(stdin);
   scanf("%s", nombre);
   
   f=fopen(nombre, "r");
   
   if(f==NULL){
      printf("No se ha podido abrir el fichero. \n");
      return;
   }
   
   borrarespacio(f);
   
   system("pause");
   return 0;
}

void borrarespacio(FILE *f){
   FILE *fborrar;
   char leido;
   fborrar=fopen("borrar.txt", "w");
   leido=fgetc(f);
   
   
   while(!feof(f)){
      if(leido==' '){
         fputc('\0',fborrar);
      }
      else{
         fputc(leido,fborrar);
         while(leido!='\n'){
            leido=fgetc(f);
            fputc(leido,fborrar);
         }   
      }
      leido=fgetc(f);
   }
}

Alguien me podria ayudar con este codigo y a poder ser también con la busqueda de una palabra que aparece varias veces en mi código y necesito indicar la linea y la posicion en la que aparece. Muchas gracias!!!

A ver, no se si tiene mucho interes quitar los espacios del principio del fichero, pero yo contribuyo a resolver la ultima parte del mensaje


Primero el ejemplo de ejecución: buscar "en el código" (o cualquier fichero de texto en general) las apariciones de una palabra "perror" (o cualquier palabra) indicando linea y columna.

Entrada


(Creo que la segunda falla, porque el editor emacs que uso mete \t para dar formato al texto C...pero ya no sigo a corregirlo.)

Salida

Y ahora el código... Se trata del algoritmo más trivial de este estilo, con una complejidad theta(N*M), siendo N el numero de caracteres del archivo y M la longitud (mayor que 0) del patron a buscar. (Está claro que los google engines nunca utilizarán este algoritmo  )

/* 
  Naive string matching on file .
  Theta(N*M) ,
  N (length of contents)
  M (length of pattern)
*/
 
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <assert.h>
 
#include <string.h>
 
 
/*
 
 I : lineno = #i : 0 <= i <= n : V[i]='\n'
     column = max p : 0<= p <= n and AllesNotRet(V,p,n)   : n-p
     buf[0..min(n,m))=V[max(n-m,0),n)
 
  Invariant snapshot
 
0                                        n=7
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|  a  |  b  |  c  | \n  |  s  |  e  |  r  |  a  |     |     |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 
              buf= "\nser"
	      lineno=1	
	      colum=3
	      pattern=sera
	      m = 4
*/
 
 
// IO
void searchPattern(FILE *f, const char pattern[])
{
  int n,lineno,column;
  const int m = strlen(pattern);
  char *buf ;
  if (!(buf=(char *)calloc(m,sizeof(char))))
    {
      perror("calloc");
      exit(EXIT_FAILURE);
    }
  for(lineno=column=n=0 ; !feof(f) ; n++)
    {
      char chr=fgetc(f);
      if (ferror(f))
	{
	  perror("fgetc");
	  exit(EXIT_FAILURE);
	}
      int i;
      for(i=0; i<m-1 ; i++) buf[i]=buf[i+1]; // shift window
      buf[m-1]=chr;
      if (strncmp(buf,pattern,m)==0)
	printf("%d:%d\t%s\n",lineno+1,column-m+1,pattern);
      lineno += (chr=='\n');
      column =  (chr =='\n')?0:(column+1);
    }
  free(buf);
  return;
}
 
 
int main (void)
{
  FILE *f;
  int n,N;
 
#define MAX 10000
  char path[MAX];
  char word[MAX];
  scanf("%s %s",path,word);
  if (!(f = fopen(path,"r")))
    {
      perror("fopen");
      exit(EXIT_FAILURE);
    };
  searchPattern(f,word);
  fclose(f);
  return 0;
}
 
/*
Note : Formal Specification is done referring to V[0..N)/(POS[0..P))
       instead of file stream (f)/(stdin)
       
P : M > 0
Q : P = #i : 0 <= i < N : buf[0..m)=V[i,min(i+m,N))
    \forall i : 0 <= i < P : V[POS[i]..POS[i]+m)=pattern[0..m)
                             V[POS[i]-COLUMN[i]-1]=\n and
                             LINE[i]=#i : 0 <= i < POS[i] : V[i]=\n
*/