char scrnbuf = new char
[300][83];

    char *scrnbuf = new char [300][83];

    char (*scrnbuf)[83] = new char[300][83];

Thus, I have two questions: 1. How do I correctly allocate the array on the heap, and 2. What are the advantages of using heap memory rather than the stack, or is using the heap better than using the stack in this case, and why?

Tom Parke
Reno, Nevada

A

Since you asked two questions, I will answer in two parts. The first part will cover how memory can be allocated for arrays and the second will cover what kind of memory you would like to allocate.

The quick answer to your question is that your solution does work. Sometimes experimentation is the key to the solution of a problem. For the benefit of our C readers, I'll convert your example to C, and then switch back to C++ for the final answer.

Let's start by reviewing some array basics and then move on from there. If you simply used an array to hold a single string, you might code it something like:

    #define NUMBER_OF_CHARS 10
    char char_array[NUMBER_OF_CHARS] = "MNOPQRSTUV";

You could code a series of strings as:

    #define NUMBER_OF_STRINGS 5
    char char_matrix[NUMBER_OF_STRINGS]
                  [NUMBER_OF_CHARS] = {
        "ABCDEFGHIJ",
        "",
        "",
        "",
        "QRUSTVWZYZ",
        };

The type of char_matrix[4] is pointer to char (char *) and its value is the address of the fifth element, which contains "QRUSTVWZYZ".

The type of char_matrix is array of NUMBER_OF_STRINGS arrays of NUMBER_OF_CHARS char. In most expressions this does not become char, nor does it become pointer to char. Instead, it becomes a pointer to objects which are arrays of char that have NUMBER_OF_CHARS elements. This type is symbolized by char (*) [NUMBER_OF_CHARS] or char (*) [10]. char_matrix is also the address of the first element in the array of strings. According to pointer arithmetic, if the value of char_matrix is 1000, then the value of char_matrix + 1 is 1010.

If an array is static or global, the program allocates it from the data segment of the executable. If the array is automatic, the program allocates it from the stack segment. To use the heap, you need to use pointers. Let's declare some variables corresponding to those in my previous code samples.

The declaration

    char *p_char;

    int NUMBER_OF_CHARS = 10;
    p_char = (char *) malloc(NUMBER_OF_CHARS);

    strncpy(p_char, "MNOPQRSTUV", NUMBER_OF_CHARS);

     Expression     Meaning

     p_char         pointer to char (char *)
     *p_char        char (first char)   'M'
     *(p_char + 4)  char (fifth char)   'Q'
     p_char[4]      char (fifth char)   'Q'

To store strings in two dimensions, there are two data structures you can use — an array of pointers or a pointer to arrays. Suppose you declare:

    char *array_p_char[NUMBER_OF_STRINGS];

To allocate storage for each of these pointers, we use a loop, such as:

    for (i = 0; i < NUMBER_OF_STRINGS; i++)
        {
        array_p_char[i] = (char *) malloc
                        (NUMBER_OF_CHARS);
        }

    strncpy(array_p_char[0], "ABCDEFGHIJ",
           NUMBER_OF_CHARS);
    strncpy(array_p_char[4], "QRUSTVWZYZ",
           NUMBER_OF_CHARS);

     Expression           Meaning

     array_p_char         pointer to pointer to char
     *array_p_char        char pointer pointing at
                          "ABCDEFGHIJ"
     *(array_p_char + 4)  pointer to char (fifth element
                          in array_p_char) pointing
                          at "QRUSTVWZYZ",
     array_p_char[4]      pointer to char (as previous),
                          pointing at "QRUSTVWZYZ",

     Expression          Meaning

     *array_p_char[0]    char 'A'
     array_p_char[0][0]  char 'A'
     *array_p_char[4]    char 'Q'
     array_p_char[4][0]  char 'Q'
     array_p_char[4][9]  char 'Z'

    char (*p_char_array)[NUMBER_OF_CHARS];

To allocate memory for this pointer to reference, use:

    #define NUMBER_OF_CHARS 10
    int NUMBER_OF_STRINGS = 5;
    p_char_array = (char (*) [NUMBER_OF_CHARS])
        malloc(NUMBER_OF_CHARS * NUMBER_OF_STRINGS);

You can put some data into p_char_array with:

    strncpy(p_char_array[0], "ABCDEFGHIJ",
           NUMBER_OF_CHARS);
    strncpy(p_char_array[4], "QRUSTVWZYZ",
           NUMBER_OF_CHARS);

     Expression           Meaning

     p_char_array         pointer to
                          char[NUMBER_OF_CHARS]
     *p_char_array        char [NUMBER_OF_CHARS] array
                                containing "ABCDEFGHIJ"
     *(p_char_array + 4)  char [NUMBER_OF_CHARS] array
                               (fifth set of 10 chars)
                               containing "QRUSTVWZYZ",
     p_char_array[4]      char [NUMBER_OF_CHARS] array
                               (fifth set of 10 chars)
                               containing "QRUSTVWZYZ",

     Expression           Meaning

     *p_char_array[0]     char 'A'
     p_char_array [0][0]  char 'A'
     *p_char_array[4]     char 'Q'
     p_char_array[4][0]   char 'Q'
     p_char_array[4][9]   char 'Z'

Now to get back to C++, which is where your original question came from. Unlike malloc, new returns a pointer to the type specified. For example:

    p_char = new char;

    #define NUMBER_OF_CHARS 10
    p_char = new char[NUMBER_OF_CHARS];

The object which follows new does not have to be a simple variable. So if you have:

    char (*p_char_array)[NUMBER_OF_CHARS];

    p_char_array = new char[NUMBER_OF_STRINGS]
                        [NUMBER_OF_CHARS];

It's generally best to allocate "small" objects (say, <20 bytes) from the stack, provided they don't need to be preserved between function calls. Declare the object within the body of the function; it will become an automatic variable. If a small object must persist in memory between function calls, declare it within the body of that function, but with the static qualifier. It will not be an automatic variable, but will be allocated from the data segment.

On many machines, the stack has a limitation of 64K bytes or less. So large objects, regardless of usage, should not be automatic. If they need to persist throughout a program, declare them static. Otherwise, allocate them from the heap. Of course, if you allocate them from the heap, you should be sure to call free or delete, once you are done with the object.

When programming on an x86 type machine, with the large memory model (where both pointers to data and pointers to functions require four bytes), the differences between far and near pointers are probably insignificant. However, if you are programming under Microsoft Windows using Microsoft Visual C++, you normally use the medium memory model (four bytes for function pointers, two bytes for data pointers). In the medium model, new allocates memory from the near heap, which is only 64K bytes long. This convention dramatically limits the use of new. How can you get more storage in Microsoft C++?

First, declare any pointers that will point to allocated storage as __far pointers. This declaration will force them to be four bytes. For example, if you code:

     char __far * p_char; // Far pointer
     p_char = new char[NUMBER_OF_CHARS]; // but still stuck on near heap

    char __far * p_char;
    p_char = new __far char[NUMBER_OF_CHARS];

You need to be sure to call the proper delete operator. There are four, corresponding to the four new operators.

For C++ classes, there is another interesting twist. Member functions get a pointer to this. How big is that pointer? The answer is two bytes, under the medium model. For example, suppose you have:

    class A_class
        {
    public:
        A_class() ;
        a_function() ;
        };
        
    A_class __far *p_a_class = new __far A_class;

    class A_class
        {
    public:
        A_class() __far;
        a_function() __far;
        };

Second, you can assign a memory model to a class, such as:

    class __far A_class
        {
    public:
        A_class();
        a_function() ;
        };

As a side warning to those getting into the medium memory model, you should be aware of a hair-pulling, expletive-causing, <fill in your own adjective> possibility of unfathomable bugs in simple-looking statements. Suppose you have:

    class __far A_class
        {
    public:
        char name[100];
        };

        A_class a_class;
        char buffer[100];
        sprintf(buffer, "Name is %s", a_class.name);

This particular nuance hit me when I was converting a large scale C program to C++, that had a tremendous number of sprintf calls of this type. Watch out for variable parameter functions. If you are starting from scratch — use the strstream class.

Is 00.0 a valid floating-point constant or an invalid octal constant according to the ANSI standard? This question is motivated by the following experience. A C program contained the following statement:

    float x = 00.;

Michael G. Soyka
Warren, RI

I don't believe it's a gray area at all. It appears that the compiler is not interpreting the code according to the Standard. The rule is that the compiler should parse source characters into the longest sequence that forms a token.

The Standard gives the following description of a floating-point constant, in syntax notation:

floating-constant:

    fractional-constant exponent-partopt floating-suffixopt

fractional-constant:

    digit-sequenceopt. digit-sequence
    digit-sequence.

digit-sequence

     digit
       digit-sequence digit

digit one of

     0 1 2 3 4 5 6 7 8 9

octal-constant

    0
    octal-constant octal-digit

octal-digit:

    0 1 2 3 4 5 6 7

Your question reminds me of the expression:

    i +++++ i

    i ++ ++ + i

    (i++) + (++i)