A very silly question on character arrays but I will ask it.

This code is a direct paste from K&R:

Code:

#include <stdio.h>
#define MAXLINE 1000 /* maximum input line length */
int getline(char line[], int maxline);
void copy(char to[], char from[]); /* print the longest input*/
main()
{
int len;

int max;

char line[MAXLINE];  /* current line length */
char longest[MAXLINE]; /*maximum length seen so far */

max = 0;
while ((len = getline(line, MAXLINE)) > 0)
if (len > max) {
max = len;
copy(longest, line);
}
if (max > 0) /* there was a line */
printf("%s", longest);
return 0;
}
/* getline: read a line into s, return length*/
int getline(char s[],int lim)
{
int c, i;

for (i=0; i < lim-1 && (c=getchar())!=EOF && c!='\n'; ++i)
s[i] = c;
if (c == '\n') {
s[i] = c;
++i;
}
s[i] = '\0';
return i;
}
/* copy: copy 'from' into 'to'; assume to is big enough */
void copy(char to[], char from[])
{
int i;
i = 0;
while ((to[i] = from[i]) != '\0')
++i;
}

My doubt is, how

Code:

copy(char to[], char from[])

is getting string input? AFAIK getchar() reads the next input character and assigns it to s[i].

Or in other words I would like to understand assignment of character array between two functions (i.e. getline & copy). This may be the silliest of question ever asked on this forum but am really confused here!

When you pass a character array to a function, you are effectively passing its address.
So, if the array is changed inside the function, the changes are reflected back to the array you pass.
Here getline puts the input into an array (line) and the copy function takes that array and just copies all its(line's) elements to another(longest).

Originally Posted by alter.ego

This may be the silliest of question ever asked on this forum but am really confused here!

No, it isn't.
I remember being very confused by this a few years ago .

getline(line, MAXLINE) is what reads characters into the line array. After getline is called, getchar() is not needed anymore and the call to copy(longest, line) copies the characters while exclusively dealing with the arrays. In other words, copy does not concern itself with how line[] was populated in the first place, it just copies it.

This may be the silliest of question ever asked on this forum but am really confused here!

The silliest question that is asked on this forum is, "Can someone build me a program which..." - Usually followed by various reasons why they tried, but found it too hard to do themselves.

Thanks guys, much appreciated. But what about, say there was another function say CountWord(...,...), taking input as another character array, how would have copy() responded then?

Originally Posted by alter.ego

Thanks guys, much appreciated. But what about, say there was another function say CountWord(...,...), taking input as another character array, how would have copy() responded then?

This is a hard question because it's so simple. A knowledgeable person like me thinks, how does copy(...,...) relate to CountWord(...,...)?

Part of the magic of functions is that, after you write them and they work properly, you can call them anywhere, and they will do that specific job in that place. So let's consider what copy(..., ...) does. If you take a string and some storage and call copy like this:

Code:

char duplicate[100];
char stuff[100] = "This is quite interesting";
copy(duplicate, stuff);

You will end up with two editable versions of the sentence about quite interesting.

There is also the program you made, surrounding copy. You programmatically searched for the longest line and copied what you found into a variable, so that you would print the right answer. So the take away is that when you need a string duplicated, call the copy function.

Great! Much clearer now. Thanks!

@alter.ego

I highly recommend you to have a look at Pointers - C++ Documentation for clear understanding of pointers in C. It gives visual explanations as well which makes it easier to understand the concept.

Consider the snprintf() (snprintf - C++ Reference) function, which expects a char* as first argument. In fact, the *char HAS TO point a char[] memory location rather than being a simple *char variable.

Originally Posted by fnoyan

Consider the snprintf() (snprintf - C++ Reference) function, which expects a char* as first argument. In fact, the *char HAS TO point a char[] memory location rather than being a simple *char variable.

What exactly is the difference between "char[] memory" and a "simple char * variable"? Surely the following is valid:

Code:

char *s = malloc(10000);
assert(s);
snprintf(s, 10000, "%s\n", "Hello, world");

Is s not a "simple char *" variable? The only requirement is that s points to valid memory and that it's big enough (e.g. 10000 bytes).

Well, you are right....It is enough to have a memory location enough to hold the input str. Actually, I meant (if you refer the function definition of snprintf), the first argument is given as char*,so one should not simply try pass char* (without reserving space)

^^ Thanks! Haven't yet reached the chapter on Pointers & will definitely refer it once I am there.