Programming

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

#define SIZE 4

int main(void)
{
	int mem = SIZE;
	char *str = malloc(mem); // let's keep str pointing to beginning of string...
	char *next_read = str; // ...and next_read pointing to where next character should go

	fgets(next_read, mem, stdin);
	next_read--; // so that after we add SIZE to pointer, it points to current '\0'

	while(str[strlen(str)-1] != '\n') // if we got whole string, the last char will be '\n'
	{
		mem += SIZE;
		str = realloc(str, mem); 
		next_read += SIZE;
		fgets(next_read, SIZE+1, stdin); // read the rest (hopefully) of the line into the new space
		printf("str is now %s\n", str);
	}

	printf("final str is %s", str);
	// free(str);
	return 0;
}

bruno@thinkpad:~/Desktop434$ gcc getstring.c 
bruno@thinkpad:~/Desktop436$ ./a.out 
I love linux
str is now I love 
str is now I love linu
str is now I love linux

final str is I love linux
bruno@thinkpad:~/Desktop436$ ./a.out 
I love linux and the C programming language
str is now I love 
str is now I love linu
str is now I love linux an
str is now I love linux and th
str is now I love linux and the C 
str is now I love linux and the C 
str is now I love linux and the C 
str is now I love linux and the C 
str is now I love linux and the C 
str is now I love linux and the C 
str is now I love linux and the C

str = realloc(str, mem);

realloc(str, mem);

next_read = str + strlen(str);

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

#define SIZE 4

int main(void)
{
	int mem = SIZE;
	char *str = malloc(mem); // let's keep str pointing to beginning of string...
	char *next_read = str; // ...and next_read pointing to where next character should go

	fgets(next_read, mem, stdin);
	printf("str is now %s\n", str);

	while(str[strlen(str)-1] != '\n') // if we got whole string, the last char will be '\n'
	{
		mem += SIZE;
		str = realloc(str, mem); 
		next_read = str + strlen(str);
		fgets(next_read, SIZE+1, stdin); // read the rest (hopefully) of the line into the new space
		printf("str is now %s\n", str);
	}

	printf("final str is %s", str);
	// free(str);
	return 0;
}

bruno@thinkpad:~/Desktop444$ gcc getstring.c
bruno@thinkpad:~/Desktop445$ ./a.out 
I love linux and the C programming language
str is now I l
str is now I love 
str is now I love linu
str is now I love linux an
str is now I love linux and th
str is now I love linux and the C 
str is now I love linux and the C prog
str is now I love linux and the C programm
str is now I love linux and the C programming 
str is now I love linux and the C programming lang
str is now I love linux and the C programming language
str is now I love linux and the C programming language

final str is I love linux and the C programming language

// filename: mylib.c

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

#define SIZE 256

char *getstring(void)   // this function reads a string from command line, 
{                    // chops off the final \n, then shrinks allocated memory to exact bytes needed to hold the string
	int mem = SIZE;
	char *str = malloc(mem); // I'll keep str pointing to beginning of string...
	if (str == NULL)
		report_alloc_error();
	char *next_char = str; // ...and next_char pointing to where next character should go

	fgets(next_char, mem, stdin);

	while(str[strlen(str)-1] != '\n') // when we get whole string, last char will be '\n'
	{
		mem *= 2;
		str = realloc(str, mem); 
		if (str == NULL)
			report_alloc_error();
		next_char = str + strlen(str);
		fgets(next_char, mem/2 + 1, stdin);
	}

	// chop off trailing newline from string
	*(str + strlen(str) - 1) = '\0';

	// trim mem down to exact bytes needed to hold string
	mem = strlen(str) + 1;
	str = realloc(str, mem);

	// for debugging:
	//printf("final str is %s\n", str);
	//printf("final mem is %d\n", mem);
	
	return str;
}

void clean_stdin(void)
{
	int c;
	do 
	{
		c = getchar();
	} while (c != '\n' && c != EOF);
}

void report_alloc_error(void)
{
	printf("Memory allocation failed. Exiting.");
	exit(1);
}

// filename: mylib.h

#ifndef MYLIB_H_ // This guards against including this header more than once
#define MYLIB_H_

char *getstring(void);
void clean_stdin(void); 
void report_alloc_error(void);

#endif

// filename: example.c
// to compile: gcc -o example example.c mylib.c

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

int main(void)
{
	char c;
	int i;
	float f;
	char *s;

	printf("Enter a character: ");
	scanf(" %c", &c); // the space tells scanf to ignore leading white space (if that's what you want).
	clean_stdin();	  // note that for format specifiers other than %c, scanf automatically ignores leading whitespace.

	printf("Enter an integer: ");
	scanf("%d", &i);
	clean_stdin();

	printf("Enter a float: ");
	scanf("%f", &f);
	clean_stdin();

	printf("Enter a string: ");
	s = getstring();

	printf("\nYour character: %c\n", c);
	printf("Your integer: %d\n", i);
	printf("Your float: %f\n", f);
	printf("Your string: %s\n", s);
	free(s);

	return 0;
}

$ gcc -o example example.c mylib.c
$ ./example
Enter a character: y some garbage 38.9
Enter an integer: 3 more garbage 89
Enter a float: 3.14159 7389junk
Enter a string: I love C programming, yes I do!

Your character: y
Your integer: 3
Your float: 3.141590
Your string: I love C programming, yes I do!

char* tmp = realloc (str, len);
if (tmp == NULL) {
    free (str); // you can free str since you haven't changed the address in realloc
    return NULL; // or something to signal an allocation failure

} 

str = tmp; // the reallocation worked and now we assign tmp to str