ASCII characters not getting printed out - c

Question

I want to read cards from an input file and print out their values.
However when I try to print out characters it prints out '0'.
If I print out the character 'A', then normally the int value 65 is supposed to be printed out since I stored the character 'A' as an Int.
Could anyone help me out?
Thank you in advance.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define max 100
#define MAX_LENGTH 14
int main(){
char *lines = malloc(max*sizeof(char));
char **colour = malloc(max*sizeof(char));
int *value =malloc(max*sizeof(int));
FILE *fp;
fp = fopen("config2.txt", "r");
if(fp == NULL){
printf("Cannot open filelist.txt\n");
return 1;
}
int i= 0;
while (i < max && fgets(lines, MAX_LENGTH, fp) != NULL) {
colour[i] = malloc(MAX_LENGTH);
sscanf(lines, "%s %d", colour[i], &value[i]);
printf("%s\n", colour[i]);
printf("%d\n", value[i]);
i++;
}
return 0;
}
input:
RED A
RED 2
RED 3
RED 4
RED 5
RED 6
RED 7
RED 8
RED 9
RED 10
RED J
RED Q
RED K

Answer 1

Your primary problem handling either 'A' or an integer as the value, stems from the misunderstanding that A can be parsed with sscanf using the "%d" format specifier, it can't. Why? When you attempt to parse 'A' with "%d" a matching failure occurs, no further characters are extracted from the input buffer, and the return for sscanf will be the number of successful conversions that took place prior to the failure.
When you have data of differing types, e.g.
RED A
RED 2
In order to parse the values for A or 2, it will require two different sscanf expressions, which you can easily distinguish simply by checking the return for sscanf. You do this in a conditional and if parsing with "%s %d" fails, you attempt the parse with "%s %c" and validate whether that succeeded.
For instance, say instead of allocating with malloc (you are not reallocating anyway), you simply declare an array of struct to hold the color and value read from each line, e.g.
...
#define MAXCOLR 14
#define MAXLINE 100
#define MAXCHR 1024 /* don't skimp on read buffer size */
typedef struct { /* simple struct to associate each color/value */
char color[MAXCOLR];
int value;
} colorval_t;
int main (int argc, char **argv) {
size_t ndx = 0; /* index */
char buf[MAXCHR]; /* read buffer */
colorval_t arr[MAXLINE] = {{ .color = "" }}; /* array of struct */
/* use filename provided as 1st argument (stdin by default) */
FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;
...
while (ndx < MAXLINE && fgets (buf, MAXCHR, fp)) {
char c; /* temp char to use for parsing 2nd case */
if (sscanf (buf, "%13s %d", arr[ndx].color, &arr[ndx].value) == 2)
ndx++;
else if (sscanf (buf, "%13s %c", arr[ndx].color, &c) == 2) {
arr[ndx].value = c;
ndx++;
}
}
The while loop above being the operative code for handling the parse of information read from each line into buf. The first sscanf call attempts the parse into a string and integer value. If the return is not 2, then a second call to sscanf is made to attempt to parse the contents into a string and a character. If that succeeds, the character value (e.g. the ASCII value for the character) is assigned to value, which from your question appears to be what you intended.
Adding a few validations and then outputting the color and value for each struct contained in arr, you could do something like the following. (note: the program takes the filename to read as the first argument or reads from stdin by default if no argument is given. Don't hardcode filenames. Either pass the filename as an argument or prompt for its entry)
#include <stdio.h>
#define MAXCOLR 14
#define MAXLINE 100
#define MAXCHR 1024 /* don't skimp on read buffer size */
typedef struct {
char color[MAXCOLR];
int value;
} colorval_t;
int main (int argc, char **argv) {
size_t ndx = 0;
char buf[MAXCHR];
colorval_t arr[MAXLINE] = {{ .color = "" }};
/* use filename provided as 1st argument (stdin by default) */
FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;
if (!fp) { /* validate file open for reading */
perror ("file open failed");
return 1;
}
while (ndx < MAXLINE && fgets (buf, MAXCHR, fp)) {
char c;
if (sscanf (buf, "%13s %d", arr[ndx].color, &arr[ndx].value) == 2)
ndx++;
else if (sscanf (buf, "%13s %c", arr[ndx].color, &c) == 2) {
arr[ndx].value = c;
ndx++;
}
}
if (fp != stdin) fclose (fp); /* close file if not stdin */
for (size_t i = 0; i < ndx; i++)
printf ("arr[%2zu] : %-14s %d\n", i, arr[i].color, arr[i].value);
return 0;
}
(note: the use of the field-width modifier 13 to protect the character array bounds for color)
Example Use/Output
Using your data as input would result in the following:
$ ./bin/rdcolorval <dat/colorval.txt
arr[ 0] : RED 65
arr[ 1] : RED 2
arr[ 2] : RED 3
arr[ 3] : RED 4
arr[ 4] : RED 5
arr[ 5] : RED 6
arr[ 6] : RED 7
arr[ 7] : RED 8
arr[ 8] : RED 9
arr[ 9] : RED 10
arr[10] : RED 74
arr[11] : RED 81
arr[12] : RED 75
Look things over and let me know if you have further questions.

Answer 2

the following proposed code:
does not keep the contents of every line, rather only of the current line. You might want to change that
properly checks for errors
does not use dynamic memory allocation. You might want to change that
cleanly compiles
Does not include header files those contents are not used
Properly cleans up (closes files) when exiting either normally or when a call to sscanf() fails.
uses a valid signature for main()
uses the convention of defined values being in all capitals
properly uses MAX CHARACTERS modifier on the input format specifier %s so as to avoid any possibility of a buffer overflow and the resulting undefined behavior
documents why each header file is being included
does NOT correct the mismatch between the incoming data and the call to sscanf() Strongly suggest you read about atoi() and strtol() and modify the call to sscanf() to expect two char sequences and save them accordingly.
And now, the proposed code:
#include <stdio.h> // printf(), fprintf(), sscanf()
#include <stdlib.h> // exit(), EXIT_FAILURE
//#define MAX_LINES 100
#define MAX_LENGTH 14
int main( void )
{
char lines[ MAX_LENGTH +1];
char colour[ MAX_LENGTH ];
int value;
FILE *fp = fopen( "config2.txt", "r" );
if(fp == NULL)
{
perror( "fopen to read config2.txt failed" );
exit( EXIT_FAILURE );
}
while ( fgets( lines, MAX_LENGTH, fp ) )
{
if( sscanf(lines, "%100s %d", colour, &value) != 2 )
{
fprintf( stderr, "sscanf to extract two fields from input line failed\n" );
fclose( fp );
exit( EXIT_FAILURE );
}
printf( "colour: %s\n", colour );
printf( "value: %d\n", value );
}
fclose( fp );
return 0;
}

Answer 3

Your code is pretty close to something that works. The main problem is that you can not scan a line like "RED A" using the format specifier "%s %d" as A is not an integer. Instead you can scan it using a char.
Further you have a problem with the malloc of colour. You need to do sizeof(char*) as you want an array of char pointers.
So try something like:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define max 100
#define MAX_LENGTH 14
int main(){
char *filename = "config2.txt";
char *lines = malloc(max*sizeof(char));
char **colour = malloc(max*sizeof(char*)); // Use sizeof(char*)
char *value =malloc(max*sizeof(char)); // Use char instead of int
FILE *fp;
fp = fopen(filename, "r");
if(fp == NULL){
fprintf(stderr, "Cannot open %s : ", filename);
perror("");
exit(1);
}
int i= 0;
while (i < max && fgets(lines, MAX_LENGTH, fp) != NULL) {
colour[i] = malloc(MAX_LENGTH);
if (sscanf(lines, "%s %c", colour[i], &value[i]) != 2) // Use %c instead of %d and check return value
{
printf("Unexpected input file data\n");
exit(1);
}
printf("%s ", colour[i]);
printf("%c (%d)\n", value[i], value[i]); // Print value as both char and int
i++;
}
// Clean up
fclose (fp);
for (int j = 0; j<i; ++j) free(colour[j]);
free(colour);
free(value);
return 0;
}
Output:
RED A (65)
RED 2 (50)
RED 3 (51)
RED 4 (52)
RED 5 (53)
RED 6 (54)
RED 7 (55)
RED 8 (56)
RED 9 (57)
RED 1 (49)
RED J (74)
RED Q (81)
RED K (75)
Also notice that you should always check the return value of malloc. Example:
SomeType *someVar = malloc(sizeof(SomeType)); // or better malloc(sizeof *momeVar);
if (someVar == NULL)
{
// Out of memory - add error handling (e.g. terminate program)
}