Is there a way to 'dynamically size' a char variable? - c

Question

I didn't exactly know how to phrase the question title. Is there way to make a char get larger with every char I type? It's kind of hard to understand. Take a look at the code:
char t[100];
scanf("%c", &t);
Is there a way to make the char bigger than 100 indexes if needed?

Answer 1

Yes, but...
You cannot resize a fixed-size array like t in your example. You'll have to use dynamic memory routines such as malloc, calloc, or realloc to allocate and resize the buffer. Here's a typical implementation that starts with a small buffer and doubles its size as necessary:
#include <stdlib.h>
#include <stdio.h>
/**
* getInput
*
* Reads input from the specified stream into a character buffer, extending
* the buffer as necessary.
*
* Inputs:
*
* stream - the input stream
*
* Outputs: none
*
* Returns: pointer to a character buffer containing the input string.
*/
char *getInput( FILE *stream )
{
/**
* Track the physical size of our buffer, which is at least 1 greater
* than the number of characters stored in it. Since we double the
* buffer size on each realloc, this has to start as a non-zero value.
*/
size_t buffer_size = 1;
/**
* Track the number of characters read from the input stream. Once this
* count equals the buffer size, we need to extend the buffer.
*/
size_t characters_read = 0;
/**
* Pointer to our dynamically-allocated buffer.
*/
char *buffer = NULL;
int c;
/**
* Read characters from the input stream until we hit a newline or EOF.
*/
while ( ( c = fgetc( stream ) ) != EOF && c != '\n' )
{
/**
* Update the number of characters read.
*
* If the number of characters read equals the buffer size,
* then we need to extend the buffer. Typically, we double
* the buffer size.
*/
if ( ++characters_read == buffer_size )
{
/**
* Double the size of the buffer (if the buffer pointer is NULL,
* this will allocate the buffer). ALWAYS assign the result of
* realloc to a temporary pointer - if it fails, it will return NULL
* and leave the buffer unchanged. If you assign that NULL to your
* pointer variable, you'll lose your reference to that memory.
*/
char *tmp = realloc( buffer, sizeof *buffer * (buffer_size * 2) );
/**
* If the allocation is unsuccessful, write an error message and
* return the buffer in its current state.
*/
if ( !tmp )
{
fprintf( stderr, "getInput - failed to extend input buffer, returning what we have so far...\n" );
return buffer;
}
/**
* Otherwise, update our buffer pointer (which may have changed
* as a result of the malloc operation) and buffer size:
*/
buffer = tmp;
buffer_size *= 2;
}
/**
* Write the character to the buffer. Remember that arrays are
* 0-indexed, so the first character goes to index 0, second
* character goes to index 1, etc.
*/
buffer[characters_read-1] = c;
}
/**
* Terminate the string. The logic above should make sure that
* characters_read is *always* less than buffer_size, so we shouldn't
* need to check for overflow here.
*/
buffer[characters_read] = 0;
/**
* Some debugging output
*/
fprintf( stderr, "buffer_size = %zu\n", buffer_size );
fprintf( stderr, "characters_read = %zu\n", characters_read );
return buffer;
}
/**
* Simple main program to exercise the code above.
*/
int main( void )
{
printf( "Gimme something: " );
char *input = getInput( stdin );
if ( input )
{
printf( "You typed: \"%s\"\n", input );
free( input );
}
else
{
printf( "error getting input\n" );
}
return 0;
}
Some example runs:
jbode:input john.bode$ ./input
Gimme something: a
buffer_size = 2
characters_read = 1
You typed: "a"
jbode:input john.bode$ ./input
Gimme something: ab
buffer_size = 4
characters_read = 2
You typed: "ab"
jbode:input john.bode$ ./input
Gimme something: abc
buffer_size = 4
characters_read = 3
You typed: "abc"
jbode:input john.bode$ ./input
Gimme something: abcd
buffer_size = 8
characters_read = 4
You typed: "abcd"
Note that the buffer size is always at least 1 larger than the number of characters in the string.
Doubling the size of the buffer each time winds up being a little more runtime efficient in the end than extending it by a fixed amount each time through, because on average you're making fewer realloc calls (which can be an expensive operation). The tradeoff is that you may wind up with a buffer twice as big as you really need. Extending by a fixed amount should result in less wasted space, but see above about runtime. In the end, you may need to do some analysis to determine which way is best for the problem at hand.