Reading word by word from a file in c

A file is a repository of data that is stored in a permanent storage media, mainly in secondary memory. In order to use the files we should learn how to read information from a file and how to write information into a file.

A very important concept in C is the stream.The stream is a common logical interface to the various devices( files).A stream is linked to a file while using an open operation. A stream is disassociated from a file while using a close operation. The current location, also referred to as the current position, is the location in a file where the next file access will occur.There are two types of streams text and binary.

The following are some difference between text and binary files

The data format is usually line-oriented in text file. Here, each line is a separate command.
Binary file always needs a matching software to read or write it.(MP3 player Image Viewer)

Using files in C
There are four steps in using files

• Declare a file pointer variable
• Open a file using fopen() function
• Process the file using suitable functions
• Close the file using fclose() function

Declare a file pointer variable

To access any file, we need to declare a pointer to FILE structure and then associate it with the particular file. This pointer is referred to as file pointer.

Syntax for declaring file pointer

                                                                              FILE * fp;

A pointer to FILE structure contains information, such as
size, current file  position, type of file etc., to perform operation on
the file.Opening a file function

Open a file using fopen() function

The fopen() function takes two arguments, the name of the
file and the mode in which the file is to be opened. Mode specify the purpose
of opening the file i.e, whether for reading or writing.

Syntax for opening the file in C

        fp =
fopen(char *filename,char *mode);

When fopen() function opens a file in memory, it returns a
pointer to this particular file.If fopen() function can’t open the file then
it will return NULL.

Example for opening a text file for reading in C

       void main()

       {

              FILE *fp;

              fp = fopen(«file1.txt»,»r»);      //statement 1

              if(fp == NULL)

              {

                     printf(«nCan’t open
file or file doesn’t exist.»);

                     exit(0);

              }

In the above example, statement 1 will open an existing text file «file1.txt» in
read mode and return a pointer to file. If file will not open, an appropriate
message will be displayed.

File opening modes

Note: The complete path of the file must be specified, if
the file is not in the current directory. Most of the functions prototype for
file handling is mentioned in stdio.h.

Close the file using fclose() function

When the
reading or writing of a file is finished, the file should be closed properly
using fclose() function. The fclose() function does the following tasks:

Flushes any
unwritten data from memory.

Discards any
unread buffered input.

Frees any
automatically allocated buffer

Finally,
close the file.

Syntax for
closing the file in C

              int fclose( FILE* );

Example for
closing the file in C

       void main()

       {

              FILE *fp;

              fp =
fopen(«file1.txt»,»r»);

              if(fp == NULL)

              {

                     printf(«nCan’t open
file or file doesn’t exist.»);

                     exit(0);

              }

                    — — — — — — — — — —

                    — — — — — — — — — —

              fclose(fp);

       }

Note: A
stream’s buffer can be flushed without closing it by using the fflush() library function.The flushall() command flush all open
streams.pointer

Working with Text files

The
following functions provides facility for reading and writing files

Character Input and Output

Characters
or a line (sequence of characters terminated by a newline) can be written or
read from a file using following functions.

putc() / fputc() function

The library
function putc() writes a single character to a specified stream.Its prototype is

int putc(int
ch,FILE *fp);

Eg:

char c=’x’;

FILE
*fp=fopen(“abc.txt”,”w”);

putc(c,fp);
// fputc(c,fp) // char x is written to file abc.txt.

fputs() function

To write a
line of characters to a stream, the library function fputs() is used.Its
prototype is

char
fputs(char *str,FILE *fp);

Eg:

char
str[]=”cek”;

FILE
*fp=fopen(“abc.txt”,”w”);

fputs(str,fp);
// string cek is written into file abc.txt

getc() / fgetc() function

The function
getc() and fgetc() are identical and can be used interchangeably. They input a
single character from a specified stream.Its prototype is

int
getc(FILE *fp);

Eg:

FILE
*fp=fopen(“abc.txt”,”r”);

int c;

c=fgetc(fp);
// reads a character

fgets() function

fgets() is a
line oriented function for reading from a file.Its prototype is

char
*fgets(char *str,int n, FILE *fp);

Eg:

FILE
*fp=fopen(“abc.txt”,”r”);

char
line[60];

char *c;

c=fgets(line,60,fp);

The other
two file handling functions to be covered are fprintf() and fscanf().These
functions operate exactly like printf() and scanf() except that they work with
files.

Their prototypes are

int fprintf(FILE
*fp, const char *control-string,…);

int fscanf(FILE
*fp, const char *control-string,…);

Eg:

FILE *fp=fopen(«abc.txt»,»w»);
fprintf(fp,”%s”,”cek”);
FILE *fp=fopen(«abc.txt»,»r»);int n;
fscanf(fp,»%d»,&n);

putw() and getw() function
The putw() function is used to write integers to the file.
Syntax of putw() function

printf(«n%d»,num);

Sample Programs

Read and display a file character by
character using getc/fgetc function

#include
<stdio.h>

#include
<stdlib.h>

int main()

{

FILE *fp;

int ch;

fp=fopen(«a.txt»,»r»);

if(fp==NULL)

  {

  printf(«Error opening file..»);

  exit(1);

   }

while((ch=getc(fp))!=EOF) // can use ch=fgetc(fp) also

{

putchar(ch);

 }

fclose(fp);

}
vowels consonants digits and special characters in a file ( university question)
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *fp;
int ch,vowels=0,consonants=0,digits=0,specc=0,c=0;
fp=fopen(«a.txt»,»r»);
if(fp==NULL)
  {
  printf(«Error opening file..»);
  exit(1);
   }
while((ch=fgetc(fp))!=EOF)
{
   if(ch==’a’ || ch==’e’ || ch==’i’ ||
           ch==’o’ || ch==’u’ || ch==’A’ ||
           ch==’E’ || ch==’I’ || ch==’O’ ||
           ch==’U’)
        {
            ++vowels;
        }
        else if((ch>=’a’&& ch<=’z’) || (ch>=’A’&& ch<=’Z’))
        {
            ++consonants;
        }
        else if(ch>=’0′ && ch<=’9′)
        {
            ++digits;
        }
        else if (ch ==’ ‘ || ch ==’n’)
        {
            ++specc;
        }
c++;
 }
    printf(«Vowels: %d»,vowels);
    printf(«nConsonants: %d»,consonants);
    printf(«nDigits: %d»,digits);
    printf(«nSpecial characters: %dn», c-specc-vowels-consonants-digits);
fclose(fp);
}  
Reading line by line from a file using
fgets

#include
<stdio.h>

#include
<stdlib.h>

int main()

{

FILE *fp;

char * ch;

char
line[80];

fp=fopen(«a.txt»,»r»);

if(fp==NULL)

  {

  printf(«Error opening file..»);

  exit(1);

   }

while((fgets(line,80,fp)!=NULL)

{

 printf(«%s»,line);

}

fclose(fp);

int main() 

{ FILE *fp1, *fp2; //consider 40 character string to store filename 

char filename[40]; 

char c; int del_line, temp = 1; 

//asks user for file name

 printf(«Enter file name: «); 

//receives file name from user and stores in ‘filename’ 

scanf(«%s», filename); 

//open file in read mode 

fp1 = fopen(filename, «r»); 

c = getc(fp1); //until the last character of file is obtained 

while (c != EOF) 

{ printf(«%c», c); //print current character and read next character

 c = getc(fp1); 

} 

//rewind 

rewind(fp1);

 printf(» n Enter line number of the line to be deleted:»); 

//accept number from user. 

scanf(«%d», &del_line);

//open new file in write mode 

fp2 = fopen(«copy.c», «w»); 

c = getc(fp1); 

while (c != EOF) 

{ c = getc(fp1); 

if (c == ‘n’) temp++; //except the line to be deleted

if (temp != del_line) { //copy all lines in file copy.c putc(c, fp2); } } //close both the files. fclose(fp1); 

fclose(fp2); 

//remove original file 

remove(filename); 

//rename the file copy.c to original name 

rename(«copy.c», filename); 

printf(«n The contents of file after being modified are as follows:n»);

 fp1 = fopen(filename, «r»);

 c = getc(fp1); 

while (c != EOF) 

{ printf(«%c», c); 

   c = getc(fp1);

 } 

fclose(fp1); return 0; 

}
Write data to the file( as strings using fprintf)
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *fp;
fp=fopen(«a.txt»,»w»);
if (fp==NULL)
  {
    printf(«error opening file..n»);
    exit(1);
   }
else
  {
   fprintf(fp,»%s»,»Welcomen»);
   fprintf(fp,»%s»,»to file handling in Cn»);
   }
fclose(fp);
}

Counting number of lines, characters and
words in a file

#include
<stdio.h>

#include
<stdlib.h>

int main()

{

FILE *fp;

int ch;

int
nl=0,nc=0,nw=0;

fp=fopen(«a.txt»,»r»);

if(fp==NULL)

  {

  printf(«Error opening file..»);

  exit(1);

   }

ch=getc(fp);

while(ch!=EOF)

{

if
(ch==’n’) nl++;

if(ch==’ ‘)
nw++;

nc++;

ch=getc(fp);

}

fclose(fp);

printf(«Number
of lines=%d, Number of characters = %d,Number of words=%dn»,nl,nc,nw+nl);

}

Cheking whether two files are identical or
different

#include
<stdio.h>

#include
<stdlib.h>

int main()

{

FILE
*fp1,*fp2;

int ca,cb;

char
fname1[50],fname2[50];

printf(«Enter
the first file name…n»);

scanf(«%s»,fname1);

printf(«Enter
the second file name…n»);

scanf(«%s»,fname2);

fp1=fopen(fname1,»r»);

fp2=fopen(fname2,»r»);

if(fp1==NULL)

  {

  printf(«Error opening file1..»);

  exit(1);

   }

else
if(fp2==NULL)

   {

    printf(«Error opening file2..»);

    exit(1);

   }

else

{

ca=getc(fp1);

cb=getc(fp2);

while(ca!=EOF
&& cb!=EOF && ca==cb)

{

ca=getc(fp1);

cb=getc(fp2);

}

fclose(fp1);

fclose(fp2);

if(ca==cb)

printf(«Files
are identicaln»);

else if
(ca!=cb)

printf(«Files
are different n»);

}

}

Copy one file to another character by
character using getc and putc function( you can also use fgetc and fputc)

#include
<stdio.h>

#include
<stdlib.h>

int main()

{

FILE
*fp1,*fp2;

int ch;

char
fname1[50],fname2[50];

printf(«Enter
the source file name…n»);

scanf(«%s»,fname1);

printf(«Enter
the destination file name…n»);

scanf(«%s»,fname2);

fp1=fopen(fname1,»r»);

fp2=fopen(fname2,»w»);

if(fp1==NULL)

  {

  printf(«Error opening source
file..»);

  exit(1);

   }

else
if(fp2==NULL)

   {

    printf(«Error opening destination
file..»);

    exit(1);

   }

else

{

while((ch=fgetc(fp1))!=EOF)
   {
     fputc(ch,fp2);
   }

}

fclose(fp1);

fclose(fp2);

printf(«Files
succesfully copiedn»);

}

}
Copy one file to another after replacing lower case letters with corresponding uppercase letters.(university question)
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *fp1,*fp2;
int ch;
char fname1[50],fname2[50];
printf(«Enter the source file name…n»);
scanf(«%s»,fname1);
printf(«Enter the destination file name…n»);
scanf(«%s»,fname2);
fp1=fopen(fname1,»r»);
fp2=fopen(fname2,»w»);
if(fp1==NULL)
  {
  printf(«Error opening source file..»);
  exit(1);
   }
else if(fp2==NULL)
   {
    printf(«Error opening destination file..»);
    exit(1);
   }
else
{
    while((ch=fgetc(fp1))!=EOF)
   {
      if(islower(ch)) ch=toupper(ch);

     fputc(ch,fp2);
    }
fclose(fp1);
fclose(fp2);
printf(«Files succesfully copiedn»);
}
}

Write a C program to replace vowels in a text file with character ‘x’.(university question)

Copy one file to another line by line using
fgets and fputs function

#include
<stdio.h>

#include
<stdlib.h>

int main()

{

FILE
*fp1,*fp2;

int ch;

char
fname1[50],fname2[50],t[80];

printf(«Enter
the source file name…n»);

scanf(«%s»,fname1);

printf(«Enter
the destination file name…n»);

scanf(«%s»,fname2);

fp1=fopen(fname1,»r»);

fp2=fopen(fname2,»w»);

if(fp1==NULL)

  {

  printf(«Error opening source
file..»);

  exit(1);

   }

else
if(fp2==NULL)

   {

    printf(«Error opening destination
file..»);

    exit(1);

   }

else

{

while((fgets(t,sizeof(t),fp1)!=NULL))

{

fputs(t,fp2);

}

fclose(fp1);

fclose(fp2);

printf(«Files
succesfully copiedn»);

}

}
Merging the contents of two files into a third file(university question)
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *fp1,*fp2,*fp3;
char t[100];
fp1=fopen(«first.txt»,»r»);
fp2=fopen(«second.txt»,»r»);
fp3=fopen(«third.txt»,»w»);
if(fp1==NULL||fp2==NULL)
  {
  printf(«Error opening source file..»);
  exit(1);
   }
else if(fp3==NULL)
   {
    printf(«Error opening destination file..»);
    exit(1);
   }
else
{
while((fgets(t,sizeof(t),fp1)!=NULL))
{
fputs(t,fp3);
}
while((fgets(t,sizeof(t),fp2)!=NULL))
{
fputs(t,fp3);
}
fclose(fp1);
fclose(fp2);
fclose(fp3);
printf(«Files succesfully mergedn»);
}
}

Reading numbers from a file and separating
even and odd numbers into two different files

#include
<stdio.h>

#include
<stdlib.h>

int main()

{

FILE
*fp,*fpe,*fpo;

int n;

fp=fopen(«num.dat»,»r»);

fpe=fopen(«enum.dat»,»w»);

fpo=fopen(«onum.dat»,»w»);

if
(fp==NULL||fpe==NULL||fpo==NULL)

  {

    printf(«error opening file..n»);

    exit(1);

   }

else

  {

while(fscanf(fp,»%d»,&n)==1)

   {

    if (
n%2==0)

     fprintf(fpe,»%dn»,n);

  else

    fprintf(fpo,»%dn»,n);

   }

fclose(fp);

fclose(fpe);

fclose(fpo);

}

}
Note: this program can also be written using putw() getw() function

Write Palindrome words from a file to a new file

Reading
an array and writing to a file using fwrite and reading the file using fread

#include <stdio.h>

#include <stdlib.h>

#define SIZE 10

int main()

{

int i,a[SIZE],b[SIZE];

FILE *fp;

printf(«Enter 10 elements in
array a…n»);

for(i=0;i<10;i++)

 
scanf(«%d»,&a[i]);

fp=fopen(«num.dat»,»w»);

if(fp==NULL)

 {

 printf(«error opening file..n»);

 exit(1);

 }

fwrite(a,sizeof(int),SIZE,fp);

fclose(fp);

/*opening the file and reading to
array b*/

fp=fopen(«num.dat»,»r»);

if(fp==NULL)

 {

 printf(«error opening file..n»);

 exit(1);

 }

fread(b,sizeof(int),SIZE,fp);

printf(«array b is…n»);

for(i=0;i<10;i++)

 printf(«%dn»,b[i]);

fclose(fp);

} 
Program for writing struct
to file using fwrite
#include
<stdio.h>
#include
<stdlib.h>
#include
<string.h>
struct person

Programs to try 

1. Use std::ifstream to Read File Word by Word in C++
2. Use std::ispunct and std::string::erase Functions to Parse Punctuation Symbols in C++

This article will demonstrate multiple methods about how to read a file word by word in C++.

Use std::ifstream to Read File Word by Word in C++

The std::ifstream class can be utilized to conduct input operations file-based streams. Namely, the std::ifstream type is used to interface with file buffer and operate on it using the extraction operator. Note that, std::fstream type is also provided in the I/O library that’s compatible with both extraction (>>) and insertion operators (<<).

At first, we need to create an object of type ifstream by calling one of its constructors; in this case, only filename string is passed to the constructor function. Once the ifstream object is created, one of its methods — is_open should be called to verify that the call was successful and then proceed to read the file contents.

To read the file word by word, we call the extraction operator on ifstream object. We redirect it to the string variable, which automatically reads in the first word before the first space character is encountered. Since we need to read each word until the end of the file, we insert the extraction statement into a while loop expression. Additionally, we declared a vector of strings to store each word on every iteration and print later with a separate loop block.

#include <iostream>
#include <fstream>
#include <vector>

using std::cout; using std::cerr;
using std::endl; using std::string;
using std::ifstream; using std::vector;

int main()
{
    string filename("input.txt");
    vector<string> words;
    string word;
    
    ifstream input_file(filename);
    if (!input_file.is_open()) {
        cerr << "Could not open the file - '"
             << filename << "'" << endl;
        return EXIT_FAILURE;
    }

    while (input_file >> word) {
        words.push_back(word);
    }
    
    for (const auto &i : words) {
        cout << i << endl;
    }
    input_file.close();

    return EXIT_SUCCESS;
}

Use std::ispunct and std::string::erase Functions to Parse Punctuation Symbols in C++

The only downside of the previous method is that it stores the punctuation characters close to words in the destination vector. It would be better to parse each word and then store them into a vector container. We are using the ispunct function that takes a single character as int parameter and returns a non-zero integer value if the character is punctuation; otherwise — zero is returned.

Note that the behavior of ispunct function is undefined if the given argument is not representable as unsigned char; thus, it is recommended to cast the character to the corresponding type. In the following example, we implemented the two simple if conditions to check the first and last characters of each word. If the punctuation is found, we call a built-in string function — erase to remove the found characters.

#include <iostream>
#include <fstream>
#include <vector>

using std::cout; using std::cerr;
using std::endl; using std::string;
using std::ifstream; using std::vector;

int main()
{
    string filename("input.txt");
    vector<string> words;
    string word;
    
    ifstream input_file(filename);
    if (!input_file.is_open()) {
        cerr << "Could not open the file - '"
             << filename << "'" << endl;
        return EXIT_FAILURE;
    }

    while (input_file >> word) {
        if (ispunct(static_cast<unsigned char>(word.back())))
            word.erase(word.end()-1);
        else if (ispunct(static_cast<unsigned char>(word.front())))
            word.erase(word.begin());
        
        words.push_back(word);
    }
    
    for (const auto &i : words) {
        cout << i << endl;
    }
    input_file.close();

    return EXIT_SUCCESS;
}

I found something that at least begins to answer my own question. The following two links have wmv files from Microsoft that demonstrate using a C# class in unmanaged C++.

This first one uses a COM object and regasm: http://msdn.microsoft.com/en-us/vstudio/bb892741.

This second one uses the features of C++/CLI to wrap the C# class: http://msdn.microsoft.com/en-us/vstudio/bb892742. I have been able to instantiate a c# class from managed code and retrieve a string as in the video. It has been very helpful but it only answers 2/3rds of my question as I want to instantiate a class with a string perimeter into a c# class. As a proof of concept I altered the code presented in the example for the following method, and achieved this goal. Of course I also added a altered the {public string PickDate(string Name)} method to do something with the name string to prove to myself that it worked.

wchar_t * DatePickerClient::pick(std::wstring nme)
{
    IntPtr temp(ref);// system int pointer from a native int
    String ^date;// tracking handle to a string (managed)
    String ^name;// tracking handle to a string (managed)
    name = gcnew String(nme.c_str());
    wchar_t *ret;// pointer to a c++ string
    GCHandle gch;// garbage collector handle
    DatePicker::DatePicker ^obj;// reference the c# object with tracking handle(^)
    gch = static_cast<GCHandle>(temp);// converted from the int pointer 
    obj = static_cast<DatePicker::DatePicker ^>(gch.Target);
    date = obj->PickDate(name);
    ret = new wchar_t[date->Length +1];
    interior_ptr<const wchar_t> p1 = PtrToStringChars(date);// clr pointer that acts like pointer
    pin_ptr<const wchar_t> p2 = p1;// pin the pointer to a location as clr pointers move around in memory but c++ does not know about that.
    wcscpy_s(ret, date->Length +1, p2);
    return ret;
}

Part of my question was: What is better? From what I have read in many many efforts to research the answer is that COM objects are considered easier to use, and using a wrapper instead allows for greater control. In some cases using a wrapper can (but not always) reduce the size of the thunk, as COM objects automatically have a standard size footprint and wrappers are only as big as they need to be.

The thunk (as I have used above) refers to the space time and resources used in between C# and C++ in the case of the COM object, and in between C++/CLI and native C++ in the case of coding-using a C++/CLI Wrapper. So another part of my answer should include a warning that crossing the thunk boundary more than absolutely necessary is bad practice, accessing the thunk boundary inside a loop is not recommended, and that it is possible to set up a wrapper incorrectly so that it double thunks (crosses the boundary twice where only one thunk is called for) without the code seeming to be incorrect to a novice like me.

Two notes about the wmv’s. First: some footage is reused in both, don’t be fooled. At first they seem the same but they do cover different topics. Second, there are some bonus features such as marshalling that are now a part of the CLI that are not covered in the wmv’s.

Edit:

Note there is a consequence for your installs, your c++ wrapper will not be found by the CLR. You will have to either confirm that the c++ application installs in any/every directory that uses it, or add the library (which will then need to be strongly named) to the GAC at install time. This also means that with either case in development environments you will likely have to copy the library to each directory where applications call it.

void read(FILE *fp)
{
  FILE *fp1 = fp;
  char word[100];
  int x;
  int counter = 0;

  while ((x = fgetc(fp1)) != EOF)
  {
     if (isalpha(x) == 0)
     {
        insert(&tree,word);
        counter = 0;
     }
     if (isalpha(x) != 0)
     {
        tolower(x);
        word[counter] = x;
        counter++;
     }
  }
  rewind(fp1);
  fclose(fp1);
}

2 Answers

char *getWord(FILE *fp){
    char word[100];
    int ch, i=0;

    while(EOF!=(ch=fgetc(fp)) && !isalpha(ch))
        ;//skip
    if(ch == EOF)
        return NULL;
    do{
        word[i++] = tolower(ch);
    }while(EOF!=(ch=fgetc(fp)) && isalpha(ch));

    word[i]='';
    return strdup(word);
}
void read(FILE *fp){
    char *word;
    while(word=getWord(fp)){
        insert(&tree, word);
    }
    //rewind(fp1);
    fclose(fp);
}

char *getword(FILE *fp)
{
    char word[100];
    int ch; 
    size_t idx ;

    for (idx=0; idx < sizeof word -1; ) {
        ch = fgetc(fp);
        if (ch == EOF) break;
        if (!isalpha(ch)) {
           if (!idx) continue; // Nothing read yet; skip this character
           else break; // we are beyond the current word
           }
        word[idx++] = tolower(ch);
        }
    if (!idx) return NULL; // No characters were successfully read
    word[idx] = '';
    return strdup(word);
}

1. 06-10-2003

   
   

   #1

   

   
   Registered User
   

   ---

   Reading in a file word by word
   

   I am trying to write a program that reads a file name from the
   command line, reads the contents of that file, and output a list of words, one word per line, to a second file, whose name is also on the command line.

   For this program a word is a sequence of alphabetic characters. Any character which is not alphabetic is a separator character.

   I know how to open files and create files but I am not sure what to do so that I can read in just one word at a time. I also want to know of any tips on how to write to the new file. Thank you in advance for any help!

   Example

   input file:
   Hello%$this is just a test!

   output file:
   Hello
   this
   is
   just
   a
   test

   ---

2. 06-10-2003

   
   

   #2

   

   
   ATH0
   

   

   ---

   Just continue in whatever book showed you how to open files a page or two, and they’ll show you how to read.

   Basicly there are may ways to do it.
   fgets would work.
   fgetc would also work.
   fscanf would also work…

   Basicly, there are a whole lot of f-ing functions that would do the job.

   Quzah.

   Hope is the first step on the road to disappointment.

   ---

3. 06-10-2003

   
   

   #3

   

   
   Registered User
   

   ---

   Open files
   

   Cool thank you I got it work… I kept forgetting to point to the right spot. Thank you for your help! The only last thing I need to figure out is how to make a new word after a «non letter».

   Example:

   If you use this code:

   Code:

   FILE *fp = fopen(argv[1],"r");
   
   	char buf[10];
   
   		while( fscanf(fp, "%s", buf) != EOF )
   		{
   			printf("%sn", &buf);
   		}

   On an input file that contains:

   This@#$is just a test!

   Your out put will be
   This@#$is
   just
   a
   test!

   What I need the output to be is:
   This
   is
   just
   a
   test

   Last edited by Bumblebee11; 06-10-2003 at 09:15 PM.

   ---

4. 06-10-2003

   
   

   #4

   

   
   ATH0
   

   

   ---

   What you would want to do then, is either modify how your fscanf call works, or, use a loop to run through the string you read in, and check for non-alpha characters.

   To do that, something like this would work.

   Quzah.

   Hope is the first step on the road to disappointment.

   ---

5. 06-10-2003

   
   

   #5

   

   
   Registered User
   

   ---

   Got it to work
   

   I was just able to get my program to work. Thank you for your help!!!

   ---