Dynamically allocate memory for character array according to the size of user input - with out malloc, realloc, calloc etc

Question

The problem is that I would like to allocate memory dynamically according to the size of user's input.Please note that the user does not specify the size of input. We have to calculate how long it was, and then only allocate the exact amount of memory for it.What I'm looking for is something like this:

char* input_str = NULL; // No initial size whatsoever
cout<<"\nEnter the string: ";
//Determine how long the string entered was, and allocate memory for it
//make input_str point to it. 

May be this can help us write our version of std::string ?

Answer 1

Just use a std::string, which does all of this for you:

std::cout << "\nEnter the string: ";

std::string input;

// To get a word:
std::cin >> input;

// To get a line of input:
std::getline(std::cin, input);

You won't need to worry about memory allocation at all.

Internally, these functions will call std::cin.rdbuf() to get access to the underlying stream buffer and read character by character until the stopping condition is met. As it does this, it grows some internal storage than it (de)allocates with new[] and delete[].

An alternative simple (but limited and potentially dangerous) approach you might use, is to allocate a buffer that is as large as you're ever going to need (something like new char[100] and read the input into it (with something like std::cin.read or std::cin.getline, etc.). Then you can determine how many characters were inserted into the buffer, allocate some storage of the correct size, transfer your input into this storage, and then deallocate the old buffer. With this approach, you have to be extra careful to avoid buffer overflows which may introduce security vulnerabilities to your program, and you are of course limited to a particular maximum input size.

Answer 2

As I understand the question, in particular the “May be this can help us write our version of std::string ”, it's about

• doing what std::getline from the <string> header does, to see what that involves.

That's already discussed in a good way by Bjarne Stroustrup in his paper “Learning Standard C++ as a New Language”, except that Bjarne discusses input via the >> operator, which only inputs a single whitespace-delimited word.

Bjarne starts with pseudo-code for a hypothetical student's exercise:

write a prompt "Please enter your first name"
read the name
write out "Hello <name>"

He then presents one possible C++ solution:

#include<iostream>      // get standard I/O facilities
#include<string>        // get standard string facilities

int  main()
{
    using namespace std;    // gain access to standard library

    cout << "Please enter your first name:\n";
    string name;
    cin >> name;
    cout << "Hello " << name << '\n';
}

And after some discussion he presents a C style solution, a DIY C style program to do just about the same as the C++ style solution:

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

void quit()  // write error message and quit
{
    fprintf(stderr," memory exhausted\n") ;
    exit(1) ;
}

int main()
{
    int  max = 20;
    char* name = (char*) malloc(max) ;  // allocate buffer
    if (name == 0) quit();
    printf("Please enter your first name:\n");
    while (true) {  // skip leading whitespace
        int c = getchar();
        if (c ==  EOF) break;  // end of file
        if (!isspace(c)) {
            ungetc(c,stdin);
            break;
        }
    }
    int i = 0;
    while (true) {
        int c = getchar() ;
        if (c == '\n' || c ==  EOF) {  // at end; add terminating zero
            name[i] = 0;
            break;
        }
        name[i] = c;
        if (i== max-1) {  // buffer full
            max =  max+max;
            name = (char*)realloc(name, max) ; // get a new and larger buffer
            if (name == 0) quit() ;
        }
        i++;
    }
    printf("Hello %s\n",name);
    free(name) ;  // release memory
    return 0;
}

The two programs are not exactly equivalent: the C++ style first program only reads a single “word” of input, while the C program skips whitespace and then reads a complete line of input. But it illustrates what's involved for doing this yourself. In short, better use C++ style. ;-)

Answer 3

Allocate an array with space for 1 or more characters. Read characters from your input source into the array until the array runs out of space, or you reach your terminating character. If you ran out of space, allocate a new array twice the size, copy the characters over, and deallocate the old array. Then go back to reading characters again. Repeat until you reach your terminating character (or whatever other condition you want to stop at).

Answer 4

You need to either store the whole user string in a temporary buffer with a max size, or read the input character by character.

Note that since you are using C++, it probably doesn't make any sense to allocate the memory manually: you could use std::string instead.