Thread: [BEGINNER] Shouldn't Int store a number?

Originally Posted by jjohan

I first I declared c as a char which makes sense to me (I want to store a character). I wanted to try to declare it as an int, since it can then store EOF. This also works.
I thought int variables contained numbers and not letters.

1) Anyone want to clarify this for me?
2) Shouldn't the int variable store the ASCI number for the particular character?
3) How does getchar() know that it should jump one step to the right in the while loop? It looks like it should stand at the same character all the time, but it doesn't fortunatuly.

Consider the text of the 1999 edition of the C standard:

Originally Posted by C99 Clause 7.19.7.6

Code:

int getchar(void);

The getchar function is equivalent to getc with the argument stdin.

Originally Posted by C99 Clause 7.19.7.5

Code:

int getc(FILE *stream);

The getc function is equivalent to fgetc, except that if it is implemented as a macro, it may evaluate stream more than once, so the argument should never be an expression with side effects.

Originally Posted by C99 Clause 7.19.7.1

Code:

#include <stdio.h>
int fgetc(FILE *stream);

If the end-of-file indicator for the input stream pointed to by stream is not set and a next character is present, the fgetc function obtains that character as an unsigned char converted to an int and advances the associated file position indicator for the stream (if defined).

If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end- of-file indicator for the stream is set and the fgetc function returns EOF. Otherwise, the fgetc function returns the next character from the input stream pointed to by stream. If a read error occurs, the error indicator for the stream is set and the fgetc function returns EOF.

So, the character that is read is read as an unsigned char, which is then converted to int. Assuming ASCII, if 'A' is read, then you end up with 65 stored in the int. getchar reads the next character from the standard input stream, thus the answer to "how does it know?" is that it is implemented to "know", the details of which are implementation defined.

Originally Posted by jjohan

4) Also the statement c = getchar() is an allocation inside the while loop I guess? Is this recommended? It looks kind of odd to me.

It is a function call within the condition of the loop. If you are careful, it is fine. Problem is, some people carelessly write:

Code:

while(c = getchar() != '\n')

which is equivalent to:

Code:

while(c = (getchar() != '\n'))

and hence wrong.

Originally Posted by jjohan

So the type char only exists because it takes less memory than an int?

No, it is strongly associated with the notion of a "member of the basic execution character set" and somewhat more loosely associated with the notion of a "byte".

Originally Posted by jjohan

One could then rewrite all programs in c and replace all chars with ints?

No, since the standard C notion of a string is a contiguous sequence of char terminated by a null character, and although 'A' is of type int, "A" is not of type array of 2 int. Furthermore, it is always the case that sizeof(char) == 1.

Originally Posted by anduril462

3
I'm not sure I understand "jump one step to the right". Please clarify.

What I meant was is maybe best explained by an example:
Suppose the string is "Hello"
Then at first getchar() reads 'H', then in the loop it "jumps one step to the right" to read in 'e' without me telling getchar() to do so.

Originally Posted by anduril462

And: hooray for using constants instead of magic numbers!

But constants cannot be used for variables that are of float type right?

Originally Posted by jjohan

Suppoese the string is "Hello"
Then at first getchar() reads 'H', then in the loop it "jumps one step to the right" to read in 'e' without me telling getchar() to do so.

The fact that you are calling getchar in a loop means that you did indeed "tell" getchar to do so.

Originally Posted by jjohan

But constants cannot be used for variables that are of float type right?

They can. If you are using a macro constant, then specify the type with the f suffix, e.g., 1.23f.

Originally Posted by jjohan

Hm, not sure I understand this.

The type char also exists for reasons other than "because it takes less memory than an int". It is not even guaranteed that a char will take less memory than an int.

Originally Posted by jjohan

OK, but my char text[] array contains integers I guess since text[n] = c, and c is an integer.

Yes, since char is an integer type. Consider this program:

Code:

#include <stdio.h>

int main(void)
{
    char name[] = "jjohan";
    printf("%s\n", name);
    return 0;
}

Compile and run it. Now, let's rewrite the program to replace char with int:

Code:

#include <stdio.h>

int main(void)
{
    int name[] = "jjohan";
    printf("%s\n", name);
    return 0;
}

Compile the program and observe the compile error and warning.

OK, nice example Laserlight.

The first program works as expected.

The second program gives compile error:
tempo.c: In function ‘main’:
tempo.c:5:5: error: wide character array initialized from non-wide string
int name[] ="jjohan";
^
tempo.c:6:5: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
printf("%s\n", name);


So I guess a char array can store integers, but an int array cannot store characters?

Possibly you are confusing alphanumeric characters and numeric values,
and confusing integers (whole numbers) and ints (a C storage type)

A char type, stores one byte of information. Because one byte is large enough
to store the code for an alphanumeric character, chars are used to store them.

(unicode characters need 2 bytes; that doesn't apply here)

The char byte does not store a letter, for example. It stores a code which represents
that letter. That code is an integer, ie, it is a whole number. But it is not a C int type.

Chars and ints both store integer values; the difference is in the size, and also in what
they typically represent. Chars are typically used to store integer values that represent
alphanumeric characters. Ints are typically used for larger general purpose integer values.

An array of type char, char string[10], will contain 10 bytes of storage. That array will
hold 10 characters, ie, it will hold 10 values which represent the respective 10 characters.

An array of 10 ints, int string[10], will contain 20 bytes of storage. If you really wanted to,
you could store characters in that array, by assinging values one array element at a time.
But you could not use that array as a string with standard library functions. Those functions
are expecting char arrays, not int arrays.
The sequential character codes are expected to be one byte apart, not two.

You could interpret an int array yourself if you wanted, accessing each int array element individually.

Hope that all makes sense

-

You can use more readable variation of same loop:

Code:

while( 1 ) {
    c = getchar();
    if( c == EOF || c == '\n' ) { break; }
    text[n] = c;
    ++n;
}

// By the way, you do not check out of bounds. You can fix this by adding a condition n == 90, but much better to use "for" loop.

for( i = 0; i < 90; ++i ) {
    c = getchar();
    if( c == EOF || c == '\n' ) { break; }
    text[i] = c;
}