How to read from a char array (array of names)? - c

Question

Guys I have used this to read in data successfully from a file.
void read(FILE *fPtr, int *a, int *b, char **c, int size)
{
char line[100];
int num = 0;
while ( fgets(line, 99, fPtr) && num < size )
{
// This is a names array
c[num] = strtok (line, " ");
// here the name prints out fine
a[num] = atoi(strtok (NULL, " \n"));
b[num] = atoi(strtok (NULL, " \n"));
num++;
}
}
But I am unable to read properly from this char ** array.
main function:
int main()
{
FILE *fp;
int g[30];
int a[30];
char *names[30];
// Open file
fp = fopen("input.txt", "r");
read(
fp, g, a,
names, 30 );
printf("%s\n", player_names[0]);
printThis(
g, a,
names, 30 );
return 0;
}
print this:
void printThis(int* g, int* a, char** n, int s)
{
for (int i = 0; i < 5; ++i)
printf("%s\n", n[i]);
}
This totally does not print names! it prints just # some space chars and #. Why isn't it printing anything. Is it not the proper way for accessing char arrays?

Answer 1

Where, as has been addressed in the comments, you were expecting to assign c[num] = strtok (line, " ");, you found the values in names no longer pointed to anything meaningful. When you declare a variable within a function, unless you dynamically allocate storage for the variable (e.g. with malloc), the variable only survives for the lifetime of the function. Why?
When a function is called a separate area of memory is created for the execution of the function called the function stack frame. That memory holds the variables declared within the function. When the function returns, the stack frame is destroyed (actually just released for reuse as required). Any variables declared local to the function are no longer available for access.
In your case, strtok returns a pointer to the beginning of a token within line (or NULL if no token in found). Upon function return, the pointer returned by strtok points to memory that has been release for reuse and can no longer be accessed within the calling function (main here) -- thus your problem.
How do I fix this? Well, there are many ways. The first, easiest solution, is just to dynamically allocate storage for the names, and make a copy of the tokens found by strtok and store them within the memory you have allocated. That memory will survive return and can be validly accessed in the caller. (you must remember to free the memory when it is no longer needed)
You also need to have your read (my readfp below) function return a meaningful value rather than void. It would be nice to know how many records were actually filled. If you change the function type to int, then you can return num and know how many records (e.g. name[x] a[x] & g[x] combination) were filled.
Wait... num was declared local to read, why can I return it? Every function can always return a value of its own type. If you declare int read (...), read can return an int value and its survives return due to the calling convention between caller and callee.
Putting those pieces together, and using strtol in place of atoi for int conversions (and making it easy by creating a separate function to handle and validate the conversions), you could do something similar to the following. Also note that main takes arguments which you can make use of to pass a filename to open, rather than hardcoding, e.g. fopen("input.txt", "r").
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <limits.h>
/* define constants for use below */
enum { BASE = 10, MAXP = 30, MAXL = 100 };
int readfp (FILE *fp, int *a, int *b, char **c, int size);
int xstrtol (char *s, int base);
int main (int argc, char **argv) {
int g[MAXP] = {0},
a[MAXP] = {0},
n = 0;
char *names[MAXP] = {NULL};
FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;
if (!fp) { /* validate file open for reading */
fprintf (stderr, "error: file open failed '%s'.\n", argv[1]);
return 1;
}
n = readfp (fp, g, a, names, MAXP );
if (fp != stdin) fclose (fp); /* close file if not stdin */
if (n)
for (int i = 0; i < n; i++) {
printf ("%-30s %8d %8d\n", names[i], g[i], a[i]);
free (names[i]); /* free memory allocated by strdup */
}
return 0;
}
int readfp (FILE *fp, int *a, int *b, char **c, int size)
{
char line[MAXL] = "";
int num = 0;
while (num < size && fgets (line, sizeof line, fp))
{
char *delim = " \t\n",
*tmp = strtok (line, delim);
int itmp = 0;
if (tmp)
c[num] = strdup (tmp); /* allocate storage and copy tmp */
else {
fprintf (stderr, "error: strtok failed - c[%d].\n", num);
break;
}
if ((tmp = strtok (NULL, delim)) && (itmp = xstrtol (tmp, BASE)))
a[num] = itmp;
else {
fprintf (stderr, "error: strtok failed - a[%d].\n", num);
break;
}
if ((tmp = strtok (NULL, delim)) && (itmp = xstrtol (tmp, BASE)))
b[num] = itmp;
else {
fprintf (stderr, "error: strtok failed - b[%d].\n", num);
break;
}
num++;
}
return num;
}
int xstrtol (char *s, int base)
{
errno = 0;
char *endptr = NULL;
long v = strtol (s, &endptr, base);
if (errno) {
fprintf (stderr, "xstrtol() error: over/underflow detected.\n");
exit (EXIT_FAILURE);
}
if (s == endptr && v == 0) {
fprintf (stderr, "xstrtol() error: no digits found.\n");
exit (EXIT_FAILURE);
}
if (v < INT_MIN || INT_MAX < v) {
fprintf (stderr, "xstrtol() error: out of range of integer.\n");
exit (EXIT_FAILURE);
}
return (int)v;
}
Example Input File
$ cat dat/names.txt
Ryan,Elizabeth 62 325
McIntyre,Osborne 84 326
DuMond,Kristin 18 327
Larson,Lois 42 328
Thorpe,Trinity 15 329
Ruiz,Pedro 35 330
Ali,Mohammed 60 331
Vashti,Indura 20 332
Example Use/Output
$ ./bin/readnames <dat/names.txt
Ryan,Elizabeth 62 325
McIntyre,Osborne 84 326
DuMond,Kristin 18 327
Larson,Lois 42 328
Thorpe,Trinity 15 329
Ruiz,Pedro 35 330
Ali,Mohammed 60 331
Vashti,Indura 20 332
Memory Use/Error Check
In any code you write that dynamically allocates memory, you have 2 responsibilities regarding any block of memory allocated: (1) always preserve a pointer to the starting address for the block of memory so, (2) it can be freed when it is no longer needed.
It is imperative that you use a memory error checking program to insure you do not attempt to write beyond/outside the bounds of your allocated block of memory, attempt to read or base a conditional jump on an uninitialized value, and finally, to confirm that you free all the memory you have allocated.
For Linux valgrind is the normal choice. There are similar memory checkers for every platform. They are all simple to use, just run your program through it.
$ valgrind ./bin/readnames <dat/names.txt
==11303== Memcheck, a memory error detector
==11303== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==11303== Using Valgrind-3.11.0 and LibVEX; rerun with -h for copyright info
==11303== Command: ./bin/readnames
==11303==
Ryan,Elizabeth 62 325
McIntyre,Osborne 84 326
DuMond,Kristin 18 327
Larson,Lois 42 328
Thorpe,Trinity 15 329
Ruiz,Pedro 35 330
Ali,Mohammed 60 331
Vashti,Indura 20 332
==11303==
==11303== HEAP SUMMARY:
==11303== in use at exit: 0 bytes in 0 blocks
==11303== total heap usage: 8 allocs, 8 frees, 112 bytes allocated
==11303==
==11303== All heap blocks were freed -- no leaks are possible
==11303==
==11303== For counts of detected and suppressed errors, rerun with: -v
==11303== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Always confirm that you have freed all memory you have allocated and that there are no memory errors.
Look things over and let me know if you have further questions.

Answer 2

You have lots of issues in your code as mentioned by the people in comments. But you should carefully consider the comment by Weather Vane. Right now your names array is char *names[30]; and you assign address of a local variable to it. You need to copy the data in some way(as line goes out of scope after function call). So i would suggest changing your names array to something like :
char names[30][WORD_LEN];
For copying data you might need something like strcpy. I changed your code a bit and was able to see the desired result:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define WORD_LEN 100
void read(FILE *fPtr, int *a, int *b, char c[][WORD_LEN], int size)
{
char line[100];
int num = 0;
while ( fgets(line, 99, fPtr) && num < size ) {
// This is a names array
//strcpy(c[num], strtok (line, " "));
// here the name prints out fine
// !avoid atoi, use sscanf instead
//a[num] = atoi(strtok (NULL, " "));
//b[num] = atoi(strtok (NULL, " "));
sscanf(line, "%s%d%d", c[num], &a[num], &b[num]);
num++;
}
}
void printThis(int* g, int* a, char n[][WORD_LEN], int s)
{
for (int i = 0; i < 2; ++i)
printf("%s %d %d\n", n[i], a[i], g[i]);
}
int main()
{
FILE *fp;
int g[30];
int a[30];
char names[30][WORD_LEN];
// Open file
fp = fopen("input.txt", "r");
read(fp, g, a, names, 30 );
printThis(g, a, names, 30 );
return 0;
}
I changed the file structure to space delimited tokens, and i was able to see the names :
~/work : $ cat input.txt
Rohan 120000 4300000
Prashant 12 43
~/work : $ g++ readCharArray.c
~/work : $ ./a.out
Rohan 4300000 120000
Prashant 43 12
~/work : $