Arrays of Strings, malloc

[Ian Todd]

Hi,
I am trying to read in a list of data from a file. Each line has a string in
its first column. This is what i want to read. I could start by saying
char[1000][] to read in 1000 lines to the array( i think!!).

But I want to use malloc. Each string is at most 50 characters long, and
there may be zero to thousands of lines. How do I actually start the array?
I have seen char **array etc. At first I tried char *array[50] but I think
that gives 50 pointers to chars .How do I use malloc to set space for the
array once I know how many lines there are? is it
array=malloc(lines*sizeof(char *)) ??

Finally, I want to print each of the strings using printf. How do I access
say the 30th line?

I have sucessfully done this a few times with doubles, ints etc, but now
with strings it seems a 'two dimesional' problem and I'm confused with the
pointer aspect of it.

Can anyone start me off on a simple solution?

Thanks
Ian

 

[Hallvard B Furuseth]

How do I use malloc to set space for the
array once I know how many lines there are? is it
array=malloc(lines*sizeof(char *)) ??

Yes.

I don't know how you know beforehand how many lines there are, though.
Do you read the file twice? If so, I'd suggest to instead start by
malloc()ing e.g. an array of 50 strings, and then as you read in the
file, realloc() it to twice the previous size whenever you have used up
the currently allocated space. When you reach the end of the file,
realloc() it down to just the necessary size, to free the unused
space you allocated.

Finally, I want to print each of the strings using printf. How do I access
say the 30th line?

array[29]. Assuming you count lines from 1 when you say 30th.

I have sucessfully done this a few times with doubles, ints etc, but now
with strings it seems a 'two dimesional' problem and I'm confused with the
pointer aspect of it.

It's just the same. Think of it as a one-dimensional array of 'char*'s,
since a string is a char*.

But a char* string needs malloced space itself, so that part is a bit
more complicated than int or double: W hen you read in a string, you'll
have to malloc space for it (with malloc(length of string + 1)), then
read or copy the string into that space. Later, when you are finished,
you must free() each string before you free() the array of strings.

If you don't know how long the strings can be, you can use the realloc
trick as above: malloc a size which is often enough, read in the string
a piece of a time, realloc as needed, and realloc the string down to its
actual size when done. Or you might just have a single input buffer
which you treat that way, and copy the strings from it into newly
allocated strings when you have read them in.

 

[pete]

Hi,
I am trying to read in a list of data from a file.
Each line has a string in
its first column. This is what i want to read. I could start by saying
char[1000][] to read in 1000 lines to the array( i think!!).

But I want to use malloc.
Each string is at most 50 characters long, and
there may be zero to thousands of lines.
How do I actually start the array?
I have seen char **array etc. At first I tried char *array[50]
but I think that gives 50 pointers to chars
.How do I use malloc to set space for the
array once I know how many lines there are? is it
array=malloc(lines*sizeof(char *)) ??

Finally, I want to print each of the strings using printf.
How do I access say the 30th line?

I have sucessfully done this a few times with doubles,
ints etc, but now
with strings it seems a 'two dimesional' problem
and I'm confused with the pointer aspect of it.

Can anyone start me off on a simple solution?

/* BEGIN hello.c */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define LINES 1000
#define LENGTH 50

int main(void)
{
char (*line)[LENGTH], (*pointer)[50];

line = malloc(LINES * sizeof *line);
if (!line) {
fputs("malloc failure\n", stderr);
exit(EXIT_FAILURE);
}
strcpy(line[30], "hello, ");
strcpy(line[31], "world");
strcpy(line[32], "");
for (pointer = line + 30; **pointer; ++pointer) {
fputs(*pointer, stdout);
}
putchar('\n');
free(line);
return 0;
}

/* END hello.c */

 

[pete]

Hi,
I am trying to read in a list of data from a file.
Each line has a string in
its first column. This is what i want to read. I could start by saying
char[1000][] to read in 1000 lines to the array( i think!!).

But I want to use malloc.
Each string is at most 50 characters long, and
there may be zero to thousands of lines.
How do I actually start the array?
I have seen char **array etc. At first I tried char *array[50]
but I think that gives 50 pointers to chars
.How do I use malloc to set space for the
array once I know how many lines there are? is it
array=malloc(lines*sizeof(char *)) ??

Finally, I want to print each of the strings using printf.
How do I access say the 30th line?

I have sucessfully done this a few times with doubles,
ints etc, but now
with strings it seems a 'two dimesional' problem
and I'm confused with the pointer aspect of it.

Can anyone start me off on a simple solution?

/* BEGIN hello.c */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define LINES 1000
#define LENGTH 50

int main(void)
{
char (*line)[LENGTH], (*pointer)[50];

(*pointer)[LENGTH]

 

[Ian Todd]

I do know how many lines there are by scanning the lines with fgets first.
So lines=34 say. I know then how much space I need for 34 lines, each with
50 characters. How do I start the array off? Is it
char * array[50]?

then array=malloc(lines*sizeof(char *))

Thanks,
Ian

Hi,
I am trying to read in a list of data from a file. Each line has a string in
its first column. This is what i want to read. I could start by saying
char[1000][] to read in 1000 lines to the array( i think!!).

But I want to use malloc. Each string is at most 50 characters long, and
there may be zero to thousands of lines. How do I actually start the array?
I have seen char **array etc. At first I tried char *array[50] but I think
that gives 50 pointers to chars .How do I use malloc to set space for the
array once I know how many lines there are? is it
array=malloc(lines*sizeof(char *)) ??

Finally, I want to print each of the strings using printf. How do I access
say the 30th line?

I have sucessfully done this a few times with doubles, ints etc, but now
with strings it seems a 'two dimesional' problem and I'm confused with the
pointer aspect of it.

Can anyone start me off on a simple solution?

Thanks
Ian

 

[Ian Todd]

Thanks a lot for your help. I have a basic idea of whats going on. Here is
my test program. The principle has been integrated into my main program and
is working.
#include<stdio.h>
#include<stdlib.h>

int main(void)
{
char (*string)[50];
int i,lines;

lines=5;
string=malloc(lines* sizeof(*string));
for(i=0;i<lines;i++)scanf("%s",string);
for(i=0;i<lines;i++)printf("%s\n",string);
free(string);
return 0;
}

Thanks,
Ian

Hi,
I am trying to read in a list of data from a file. Each line has a string in
its first column. This is what i want to read. I could start by saying
char[1000][] to read in 1000 lines to the array( i think!!).

But I want to use malloc. Each string is at most 50 characters long, and
there may be zero to thousands of lines. How do I actually start the array?
I have seen char **array etc. At first I tried char *array[50] but I think
that gives 50 pointers to chars .How do I use malloc to set space for the
array once I know how many lines there are? is it
array=malloc(lines*sizeof(char *)) ??

Finally, I want to print each of the strings using printf. How do I access
say the 30th line?

I have sucessfully done this a few times with doubles, ints etc, but now
with strings it seems a 'two dimesional' problem and I'm confused with the
pointer aspect of it.

Can anyone start me off on a simple solution?

Thanks
Ian

 

[CBFalconer]

I am trying to read in a list of data from a file. Each line has
a string in its first column. This is what i want to read. I could
start by saying char[1000][] to read in 1000 lines to the array( i
think!!).

But I want to use malloc. Each string is at most 50 characters
long, and there may be zero to thousands of lines. How do I
actually start the array? I have seen char **array etc. At first
I tried char *array[50] but I think that gives 50 pointers to
chars .How do I use malloc to set space for the array once I
know how many lines there are? is it
array=malloc(lines*sizeof(char *)) ??

Finally, I want to print each of the strings using printf. How do
I access say the 30th line?

Examine the freverse.c application example included with
ggets.zip, and I think your questions will be answered. You can
find ggets.zip at:

<http://cbfalconer.home.att.net/download/>

 

[Al Bowers]

Hi,
I am trying to read in a list of data from a file. Each line has a string in
its first column. This is what i want to read. I could start by saying
char[1000][] to read in 1000 lines to the array( i think!!).

But I want to use malloc. Each string is at most 50 characters long, and
there may be zero to thousands of lines. How do I actually start the array?
I have seen char **array etc. At first I tried char *array[50] but I think
that gives 50 pointers to chars .How do I use malloc to set space for the
array once I know how many lines there are? is it
array=malloc(lines*sizeof(char *)) ??

Finally, I want to print each of the strings using printf. How do I access
say the 30th line?

I have sucessfully done this a few times with doubles, ints etc, but now
with strings it seems a 'two dimesional' problem and I'm confused with the
pointer aspect of it.

Can anyone start me off on a simple solution?

You can use a char ** variable. Use functions realloc and
malloc to add the strings. Use a integer variable to keep
track on the number of strings you have allocated.

A good solution is to create a data structure for the array
of strings and the count. Write functions to managed this data
type.

A simple example:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define FNAME "test.txt" /* File name goes here */

typedef struct StrArray
{
char **data;
size_t count;
} StrArray;

char *AddStrArray(StrArray *p, const char *s);
void PrintStrArray(StrArray *p);
void FreeStrArray(StrArray *p);

int main(void)
{
StrArray myfile = {NULL,0};
char *s,buf[156];
FILE *fp;

fp = fopen( FNAME , "r");
if(fp)
{
while(fgets(buf,sizeof buf, fp))
{
if((s = strrchr(buf,'\n')) != NULL)
*s = '\0';
if(!AddStrArray(&myfile,buf))
{
puts("Allocation failure");
break;
}
}
fclose(fp);
}
else perror("Unable to open file");
if(myfile.count >= 30)
printf("Line 30 is \"%s\"\n",myfile.data[29]);
/* PrintStrArray(&myfile); */
FreeStrArray(&myfile);
return 0;
}

char *AddStrArray(StrArray *p, const char *s)
{
char **tmp;

if((tmp = realloc(p->data,(sizeof *tmp)*(p->count+1)))==NULL)
return NULL;
p->data = tmp;
if((p->data[p->count] = malloc(strlen(s)+1)) == NULL)
return NULL;
return strcpy(p->data[p->count++],s);
}

void PrintStrArray(StrArray *p)
{
size_t i;

for(i = 0; i < p->count; i++)
puts(p->data);
return;
}

void FreeStrArray(StrArray *p)
{
size_t i;

for(i = 0; i < p->count; i++)
free(p->data);
free(p->data);
p->data = NULL;
p->count = 0;
return;
}

 

[Barry Schwarz]

Hi,
I am trying to read in a list of data from a file. Each line has a string in
its first column. This is what i want to read. I could start by saying
char[1000][] to read in 1000 lines to the array( i think!!).

But I want to use malloc. Each string is at most 50 characters long, and
there may be zero to thousands of lines. How do I actually start the array?
I have seen char **array etc. At first I tried char *array[50] but I think
that gives 50 pointers to chars .How do I use malloc to set space for the
array once I know how many lines there are? is it
array=malloc(lines*sizeof(char *)) ??

Finally, I want to print each of the strings using printf. How do I access
say the 30th line?

I have sucessfully done this a few times with doubles, ints etc, but now
with strings it seems a 'two dimesional' problem and I'm confused with the
pointer aspect of it.

Can anyone start me off on a simple solution?

"A string is a contiguous sequence of characters terminated by and
including the first null character" (n869, section 7.1.1, paragraph
1). While not always technically precise, we tend to refer to this
sequence as an array. You imply that you want to store the data in an
array of strings. So it is a 2-d situation as you surmise.

There are two popular solutions, an "array of pointers" and a "pointer
to an array." Even though they are significantly different, the two
share a common syntax in referring to the individual strings and to
the characters that make up the strings. While this common syntax
simplifies the language it also causes some pervasive confusion.

If T is an object type, then T* is type pointer to T. If we define
T* p;
then p is a pointer to T and when initialized with a non-NULL value
points to exactly one object of type T. However, we frequently allow
p to point to the first of many objects of type T, with the objects in
a contiguous sequence. We then treat p as if it were an array of T
and use p to refer to the i-th object in the array.

For the "array of pointers" approach:

Define a pointer to pointer to char (char** pp.
Allocate space for some number of pointers to char
(pp = malloc(N * sizeof *pp). Note that pp now points to the first
on N pointers to char. Even though these pointers are currently
uninitialized, we can still talk of pp as an array of N pointers or
pointing to such an array.
Read the next string from the file into a buffer.
Determine the length of the string.
Allocate enough space to hold the string
(pp = malloc(length). Note that pp now points to the first of
*length* char. Even though these char are currently uninitialized, we
can still talk of pp as an array of *length* char or pointing to
such an array.
Copy the string from the buffer to the memory pointed to by pp
or, almost equivalently, copy the string from the buffer to the array
pp.
Loop back and read the next string.

Things to note:

The size of each string is independent of the other strings.
If viewed in the common left justified tabular form, the right ends of
the strings would not line up. This is often referred to as a jagged
array.

The value in pp is an address.

The value at that address is another address. This value is
the first of N such addresses. You refer to any particular value with
the expression pp.

Each pp is the address of a char. This char is the first
char in a contiguous sequence of char terminated by a null character.
Therefore, this sequence is a string. We can say pp points to the
string. Furthermore, we can refer to any particularly character in
the i-th string with the expression pp[j].

If you ever determine that the number of strings exceeds N,
you can use realloc to cause pp to point to a larger area capable of
holding more pointers. This is why pp is sometimes referred to as a
dynamic 2-d array.

For the "pointer to an array" approach:

Determine the maximum length of any string (you said 50).
Define a pointer to an array of *maximum* char
(char (*pa)[50]. Note that this is truly a pointer to an array, not
a pointer to the first of a sequence that we are treating as an array.
When we say a char * points to an array or string, we are using verbal
shorthand to avoid the cumbersome expression in the previous sentence
and we are being a little imprecise. When we say pa points to an
array, we are being very precise.
Allocate space for some number of such arrays
(pa = malloc(N * sizeof *pa). Note that pa now points to the first
of N objects. Even though these objects are uninitialized, we can
still talk of pa as an array of N object or as pointing to such an
array. The fact is that each object is an array of 50 char. So we
talk of pa as an array of N arrays of 50 char. We can use pa to
refer to the i-th object so pa is the i-th array of 50 char.
Read the next string from the file into a buffer.
Copy the string from the buffer to the array pa.
Loop back and read the next string.

Things to note.

Each string is housed in an array of 50 char.

The value in pa is an address.

The object at that address is an array of 50 char. This
object is the first of N such objects. You refer to any particular
array as pa. You can refer to a particular character in this array
with pa[j].

If you ever determine that the number of strings exceeds N,
you can use realloc to cause pa to point to a larger area capable of
holding more arrays. This is why pa is sometimes referred to as a
dynamic 2-d array. Unlike pp above which is dynamic in both
dimensions, pa is dynamic only in the first dimension. The second
dimension is fixed (at 50 in this example).


<<Remove the del for email>>

 

[pete]

Barry Schwarz wrote:

"A string is a contiguous sequence of characters terminated by and
including the first null character" (n869, section 7.1.1, paragraph
1). While not always technically precise, we tend to refer to this
sequence as an array.

The size of each string is independent of the other strings.

One of the distinctions between strings and arrays,
is that strings have lengths, objects have sizes.

 

[pete]

Thanks a lot for your help. I have a basic idea of whats going on. Here is
my test program. The principle has been integrated into my main program and
is working.
#include<stdio.h>
#include<stdlib.h>

int main(void)
{
char (*string)[50];
int i,lines;

lines=5;
string=malloc(lines* sizeof(*string));

You neglected to ensure that the return value of malloc
was not NULL, before using it. That's bad.

for(i=0;i<lines;i++)scanf("%s",string);
for(i=0;i<lines;i++)printf("%s\n",string);
free(string);
return 0;
}