Thread: Reading an integer from file

Code:

matrix[row][column]; //sets array to the specified size
alpha[row][column]; //sets array to the specified size

No, that does not work that way.... You cannot change array size.
You are just accessing matrix[row][column] and the value is discarded.
Again your compiler will give you warning....

Code:

			
fputc(matrix[i][j], f1);

You want to write integer to text file. Then use fprintf...

Code:

			
fputc(" ", f1);

Read the manual of fputc. your code shouldn't even compile.
Here's fputc prototype.

Code:

       int fputc(int c, FILE *stream);

Is using a file required for the assignment?

The reason I ask is, that 0 to 9 is well within the range of a char and you could print out the digits just by changing the format specifier in printf(). For instance:

Code:

#include <stdio.h>

int main(void) {
  int digits[]={0,1,2,3,4,5,6,7,8,9};
  int i;
  for(i=0;i<11;i++) {
    printf("%d ", digits[i]);
    printf("%c   ", digits[i];
  }
  return 0;
}

So you see what char's are - you print raw ascii (or whatever your system is using for it's character set) values. When you print out a number, the value of the raw character set is jumped up to at least what zero is equal to - you'll never see a number 4 looking like a diamond or a 5 looking like a spade suit on a deck of cards.

But if we want to prove a point just make your print line of code, look like this:
printf("%c ", digits[i] + '0'); //plus zero

Just remember that char data type has a very limited range (usually just 8 bytes), so 255 is usually as high as it can go.

Which means when you have your array of digits[], and you want to change digits[i] to letters[i], all you need to do is just

Code:

letters[i] = digits[i] + '0'; //plus zero, not oh

And if you don't have to use a file, then don't. There is no need for one, to make this change, unless your assignment specifies it.

Your code header says the matrix array will be 20 x 20, but your matrix array is 100 x 100, and then you want to change it again? You're confusing me, you know that, right?

Could you post the actual assignment? Your description leaves me with more questions that it answers.

Give me some time to read your post. It was supposed to be a 20x20 matrix, but I went ahead and tried to set the array size to be user-defined, so I arbitrarily went for 100. I also generated the matrix since I was too lazy to write one. The program easily works if the conversion is done within the generator loop, but I'm required to read the matrix from a file. Also, using fputs is optional, but maybe I should give it a try.

Here's the assignment:

Code:

First, create a text file containing 20 rows of 20 integers separated by spaces. The integers should be 
in the range 0-9 and separated by spaces. Write a C program that reads the contents into a 20x20 
(two dimensional)     array of   int. The C program     then   should   use   this  array  to  initialize a 20x21 
array  of  char  by associating  each  integer  from 0 to 9, with a character  from ‘A’ to ‘J’.  For example, 
0 could be associated with ‘A’, while 9 with ‘J’ correspondingly. The 21st character on each line/row in 
the  array of  char should  be the  null character  ‘\0’ (added by the C program), making  each line/row 
of such an array as a string.  The C program displays the resulting array of  char (printing  row-by-row 
the strings)  on screen, and also  write it in into a text file. 

Hints/notes: 

1.     An input text file can be: 

0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5  6  7  8  9 
0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0 
5  5  5  5  5  5  6  6  6  6  4  4  4  4  4  4  5  5  5  6 
1  3  5  7  9  0  2  4  6  8  1  3  5  7  9  0  2 4  6  8 
0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5  6  7  8  9 
0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0 
5  5  5  5  5  5  6  6  6  6  4  4  4  4  4  4  5  5  5  6 
1  3  5  7  9  0  2  4  6  8  1  3  5  7  9  0  2 4  6  8 
0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5  6  7  8  9 
0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0 
5  5  5  5  5  5  6  6  6  6  4  4  4  4  4  4  5  5 5  6 
1  3  5  7  9  0  2  4  6  8  1  3  5  7  9  0  2 4  6  8 
0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5  6  7  8  9 
0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0 
5  5  5  5  5  5  6  6  6  6  4  4  4  4  4  4  5  5  5  6 
1  3  5  7  9  0  2  4  6  8  1  3  5  7  9  0  2 4  6  8 
0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5  6  7  8  9 
0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0 
5  5  5  5  5  5  6  6  6  6  4  4  4  4  4  4  5  5  5  6 
1  3  5  7  9  0  2  4  6  8  1  3  5  7  9  0  2 4  6  8 

2.     A sample run of the program is illustrated below: 

ABCDEFGHIJABCDEFGHIJ 
AAAAAAAAAAAAAAAAAAAA 
FFFFFFGGGGEEEEEEFFFG 
BDFHJACEGIBDFHJACEGI 
ABCDEFGHIJABCDEFGHIJ 
AAAAAAAAAAAAAAAAAAAA 
FFFFFFGGGGEEEEEEFFFG 
BDFHJACEGIBDFHJACEGI 
ABCDEFGHIJABCDEFGHIJ 
AAAAAAAAAAAAAAAAAAAA 
FFFFFFGGGGEEEEEEFFFG 
BDFHJACEGIBDFHJACEGI 
ABCDEFGHIJABCDEFGHIJ 
AAAAAAAAAAAAAAAAAAAA 
FFFFFFGGGGEEEEEEFFFG 
BDFHJACEGIBDFHJACEGI 
ABCDEFGHIJABCDEFGHIJ 
AAAAAAAAAAAAAAAAAAAA 
FFFFFFGGGGEEEEEEFFFG 
BDFHJACEGIBDFHJACEGI

I would minimize the file handling on the disk. It's slow, it's unnecessary, and it doesn't add to the clarity of what you're trying to do. When you have the data you need, already in your array, you wouldn't go back to the file on the disk, and mess with it (especially since it includes things like spaces to be dealt with). Just use the matrix, it has what you need, right there.

I haven't checked this for accuracy, but this is the way I would suggest to do this:

Code:

#include <stdio.h> //standard input/output library
#include <stdlib.h> //for srand()

#define ROW 20  
#define COL 20

int main (void) //main function
{
	/* declaration */
    FILE *fp1, *fp2; //declares pointers to file
    char input1[100], input2[100]; //declares file location variables
    int i, j; //declares counters and array size
    int matrix[ROW][COL];//declares numeric matrix
    char alpha[ROW][COL]; //declares alpha matrix

	/* data input */
	printf("Input the matrix file: ");
    gets(input1); //inputs location of numeric matrix
    printf("Input the alphabet file: ");
    gets(input2); //inputs location of alpha matrix

	fp1 = fopen(input1, "w"); //opens numeric array for writing
	fp2 = fopen(input2, "w"); //opens alpha array for writing

	/* checks if the file(s) is accessible */
    if (fp1 == NULL || fp2 == NULL) //executes if a file is inaccessible
	{
		printf("File access error.\n"); //displays error message
		return 1; //exits the program with error code
	}

    srand(time(NULL)); //seeds random number with current time

	/* generates the numeric matrix */
	for (i = 0; i < ROW; i++) //manipulates row
	{
	    for (j = 0; j < COL; j++) //manipulates column
	    {
            matrix[i][j] = rand() % 10; //random number from 0 to 9
            if(j<COL-1)
              fprintf(fp1, "%d ", matrix[i][j]);
            else
              fprintf(fp1, "%d\n", matrix[i][j]); 
	    }
	}


/* When data has been entered into your array, you don't 
   want to then retrieve that data from a file - always
   use the array. When fresh milk is in the refrigerator,
   you don't drive 10 miles to town, to get a gallon of milk.
*/

	/* reads and converts the numeric matrix into an alpha matrix */
	for (i = 0; i < ROW; i++) //manipulates row
	{
	    for (j = 0; j < COL; j++) //manipulates column
	    {
	        alpha[i][j] = matrix[i][j] + 65; //conversion
                if(j<COL-1)
                  fprintf(fp2, "%c ", alpha[i][j]); //writes to alpha file
                else
                  fprintf(fp2, "%c\n", alpha[i][j]); 

	    }
	}

	/* displays numeric arrays in console */
	for (i = 0; i < ROW; i++) //manipulates row
	{
	    for (j = 0; j < COL; j++) //manipulates column
	    {
            printf("%d ", matrix[i][j]); //prints numeric matrix
	    }
	    printf("\n"); //prints newline
	}

	printf("\nThe above matrix converts to:\n\n");

	/* displays alpha array in console */
	for (i = 0; i < ROW; i++) //manipulates row
	{
	    for (j = 0; j < COL; j++) //manipulates column
	    {
            printf("%c ", alpha[i][j]); //prints alpha matrix
	    }
	    printf("\n"); //prints newline
	}
	/* checks if the file(s) closes correctly */
    if (fclose(fp1) != 0 || fclose(fp2) != 0) //executes if the file does not close correctly
    printf("File close error.\n"); //displays error message

    return 0; //exits the program normally
}

The defines are a godsend when you need to change the size of your array - just change it in ONE place, for the ROW or the COL, and all the rest of your code is fine.

File pointers are fp with me. They may be fp_in or fp_out, or fp1 or fp2, but they're always "fp".

I added stdlib.h for srand(). You may need to also add time.h for time(), depending on your compiler.

I will look into your post, but I just discovered a fatal mistake at fopen. By the way, I agree with what you said. In fact, that was what I did at first (post #7). However, the assignment requires that the matrix is read from the file, which is why I'm still scratching my head right now.

Thanks for the define help! I never thought of it.

Really? I ran it, and the output looked good, although I didn't check every number/letter combo for accuracy - 0=A, 1=B, etc.

OK, then don't rewind the file pointer. close it, and re-open it for reading this time. Or you could open the file for r+w mode, and then rewind it, but you don't want to rewind a file opened in w mode. The first time you try to access it, you will cause the entire previous data in the file, to be destroyed.

Your output looks good, but that was without the need to read the matrix file, so the access type would not matter.

Here's my program and output. Some of the weirder characters do not show up correctly. Also, I noticed there was a beep while running the program. What does that mean?

Code:

#include <stdio.h> //standard input/output library
#include <stdlib.h> //required for srand()

#define ROW 20
#define COL 20

int main (void) //main function
{
	/* declaration */
    FILE *f1, *f2; //declares pointers to file
    char input1[100], input2[100]; //declares file location variables
    char str[100]; //declares string variable
    int i, j, c; //declares integers
    int matrix[ROW][COL];//declares numeric matrix
    char alpha[ROW][COL]; //declares alpha matrix

	/* data input */
	printf("Input the matrix file: ");
    gets(input1); //inputs location of numeric matrix
    printf("Input the alphabet file: ");
    gets(input2); //inputs location of alpha matrix
    printf("\n");

	f1 = fopen(input1, "w+"); //opens numeric array for writing
	f2 = fopen(input2, "w+"); //opens alpha array for writing

	/* checks if the file(s) is accessible */
    if (f1 == NULL || f2 == NULL) //executes if a file is inaccessible
	{
		printf("File access error.\n"); //displays error message
		return 1; //exits the program with error code
	}

    srand(time(NULL)); //seeds random number with current time

	/* generates the numeric matrix */
	for (i = 0; i < ROW; i++) //manipulates row
	{
	    for (j = 0; j < COL; j++) //manipulates column
	    {
            matrix[i][j] = rand() % 10; //random number from 0 to 9
            fprintf(f1, "%d ", matrix[i][j]);
	    }
	    fseek(f1, -1L, SEEK_CUR); //clears the last space of each row in f1
	    fputc('\n', f1); //starts a new row in f1
	}

    rewind(f1);

	/* reads from file and converts the numeric matrix into an alpha matrix */
	for (i = 0; i < ROW; i++) //manipulates row
	{
	    for (j = 0; j < COL; j++) //manipulates column
	    {
	        if ((c = fgetc(f1)) != ' ')
	        {
	            alpha[i][j] = c + '0'; //conversion
                fprintf(f2, "%c ", alpha[i][j]); //writes to alpha file
	        }
	    }
	    fseek(f2, -1L, SEEK_CUR); //clears the last space of each row in f2
	    fputc('\n', f2); //starts a new row in f2
	}

	/* displays numeric arrays in console */
	for (i = 0; i < ROW; i++) //manipulates row
	{
	    for (j = 0; j < COL; j++) //manipulates column
	    {
            printf("%d ", matrix[i][j]); //prints numeric matrix
	    }
	    printf("\n"); //prints newline
	}

	printf("\nThe above matrix converts to:\n\n");

	/* displays alpha array in console */
	for (i = 0; i < ROW; i++) //manipulates row
	{
	    for (j = 0; j < COL; j++) //manipulates column
	    {
            printf("%c ", alpha[i][j]); //prints alpha matrix
	    }
	    printf("\n"); //prints newline
	}

	/* checks if the file(s) closes correctly */
    if (fclose(f1) != 0 || fclose(f2) != 0) //executes if the file does not close correctly
    printf("File close error.\n"); //displays error message

    return 0; //exits the program normally
}

Code:

Input the matrix file: a.txt
Input the alphabet file: b.txt

7 3 7 0 3 4 4 3 4 8 2 8 0 6 5 8 9 0 0 1
0 3 1 0 8 5 1 3 0 9 7 8 1 6 0 4 0 6 6 5
9 9 7 6 4 2 4 8 6 6 1 7 3 3 2 0 9 8 8 9
2 2 1 4 3 8 3 0 0 1 1 2 2 6 1 5 6 8 7 3
1 9 4 7 9 3 1 8 8 6 4 1 2 3 9 1 9 7 5 8
1 5 1 7 5 0 4 3 2 2 6 6 8 2 3 6 7 4 7 5
6 6 9 3 0 1 3 6 9 2 4 3 4 7 0 7 6 1 2 9
8 9 3 2 2 6 7 3 5 1 1 5 1 9 0 9 7 8 5 2
9 3 6 5 1 5 7 3 5 1 8 5 5 7 5 0 0 7 5 1
2 8 1 7 8 0 1 9 4 9 8 4 8 1 2 7 7 0 0 2
4 8 0 8 2 9 5 2 4 6 7 0 0 2 9 3 2 6 2 3
5 0 5 3 1 2 4 4 3 5 7 3 7 8 1 6 1 1 2 5
5 3 1 9 6 1 7 1 3 5 0 4 4 0 0 0 3 1 6 2
9 0 7 4 4 8 1 8 3 1 0 2 4 6 1 7 3 3 5 2
4 4 8 2 8 3 7 8 8 2 1 0 8 7 8 6 7 5 0 3
5 1 9 8 4 5 0 9 5 0 4 1 0 0 0 2 0 4 0 6
6 7 0 2 7 7 1 5 6 7 1 1 5 7 0 0 3 0 5 2
5 7 1 6 5 3 4 2 3 1 5 4 4 0 4 9 6 1 6 9
1 9 4 5 6 8 5 3 1 7 2 5 0 4 1 2 5 2 6 2
9 7 4 7 3 9 1 1 8 7 9 5 1 1 4 5 1 1 0 6

The above matrix converts to:

g  c  g  `  c  d  d  c  d  h 
b  h  `  f  e  h  i  `  `  a :
`  c  a  `  h  e  a  c  `  i 
g  h  a  f  `  d  `  f  f  e :
i  i  g  f  d  b  d  h  f  f 
a  g  c  c  b  `  i  h  h  i :
b  b  a  d  c  h  c  `  `  a 
a  b  b  f  a  e  f  h  g  c :
 c  a  h  h  f  i
d  a  b  c  i ! a # i % g ' e ) h :
a - e / a 1 g 3 e 5 ` 7 d 9 c ; b = b ?
f A f C h E b G c I f K g M d O g Q e :
f U f W i Y c [ ` ] a _ c A f C i E b G
d I c K d M g O ` Q g S f U a W b Y i :
h } i  c   b   b   f   g   c   e   a
a   e   a   i   `   i   g   h   e   b :
i   c   f   e   a   e   g   c   e   a
h   e   e   g   e   `   `   g   e   a :
b   h   a   g   h   `   a   i   d   i
h   d   h   a   b   g   g   `   `   b :

Process returned 0 (0x0)   execution time : 3.479 s
Press any key to continue.

Here's the actual output printed in b.txt

Code:

t v t y u t t s q t
s z t v y y q u z y K
y s q t x y v r q y
x z r x s y r s r q K
u u x w y u t s t x
s s w r z r r w z v K
u w x q x w y w s x
t y w x v y y r y s K
q q y w s x v z z v
u u q y s r w t y x K
v t y z w s u z v q
z u u q u u w z x q K
t q q y x r z y y y
u u y s w t w v w y K
u s r q w q y r y s
s w s w s z z q x z K
z y u x z t x t t x
x v u s v w t w t q K
q r s y u q v t s s
y u y t v r w q u s K

Sounds like you tried to print an ascii char with a value of 7 (\a) "alert".

I see two problems: main one is you're adding '0' (ascii 48) to the alpha, instead of 'A' (65).

minor problem is you have no logic to handle newlines yet.