char   * pc1      = new  char;
    // returns char *
char   * pc2      = new  char[n];
    // returns char *
char  ** ppc3     = new  char*;
    // returns char * *
char  ** ppc4     = new (char(*));
    // returns char * *
char   * pc5      = new (char*)[n];
    // returns char *     (what's
char   * pc6      = new (char(*))[n];
    // returns char *      this?)
char  ** ppc7     = new  char*[n];
    // returns char * *    (hurray!)
char (** ppc8)[1] = new (char(*)[n]);
    // returns char[1] * * (huh?)

What kind of data structure(s) are returned for pc5 and pc6? Are they the same?

ppc7 seems to be what I'm looking for? Is it?

What kind of data structure is ppc8? What is returned by new? If ppc3 and ppc4 are the same, why are ppc7 and ppc8 different?

Thank you for a very useful article and for any answers you can provide for this one obscure area.

For the sake of completeness, how do you allocate the array_p_char using malloc()?

Hans Salvisberg
Berne, Switzerland

A

My column on pointers seems to have generated a good deal of feedback. Let me review a couple of points before answering your specific questions.

If you wish to allocate memory for a set of characters, you can do it one of two ways — statically or dynamically. Suppose you need a set of SIZE_OF_STRING characters. Then you can use either of the following:

#define SIZE_OF_STRING 10
char char_array[SIZE_OF_STRING];

char *p_char_array;
p_char_array = mal-
loc(SIZE_OF_STRING * sizeof(char));

#define SIZE_OF_STRING 10
#define NUMBER_OF_STRINGS 5
char char_array[NUMBER_OF_STRINGS]
             [SIZE_OF_STRING];

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

char **p_p_char;
p_p_char = malloc(NUMBER_OF_STRINGS *
               sizeof(char *));
for (i = 0; i < NUMBER_OF_STRINGS];
    i++)
   {
   p_p_char[i] =
      malloc(SIZE_OF_STRING *
            sizeof(char));
   }

char *p_char_array;
p_char_array = new
char[SIZE_OF_STRING];

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

char **p_p_char;
p_p_char = new char *
         [NUMBER_OF_STRINGS];
for (i = 0; i < NUMBER_OF_STRINGS];
    i++)
   {
   p_p_char[i] = new char
               [SIZE_OF_STRING];
   }

char   * pc1      = new char;

qsort is declared as follows:

qsort(void * array, size_t number_elements,
   size_t size_of_element,
   int (*compare_function)(const void *,const void *));

int int_compare(const void * first, const void * second)
   {
   if ( * (int *) first < * (int *) second)
      return -1;
   else ( * (int *) first == * (int *) second)
      return 0;
   else
      return 1;
   }

#define SIZE_OF_ARRAY 10;
int int_array[SIZE_OF_ARRAY];
qsort(int_array, SIZE_OF_ARRAY, sizeof(int),
   int_compare);

Moving to C++, you can declare a class such as Date, for example:

class Date
   {
public:
   compare(Date &);
   ...
   };

Date_compare(const void *, const void *)
   {
return (Date *) first -> compare( * (Date *) second);
   }

#define SIZE_OF_ARRAY 10;
Date date_array[SIZE_OF_ARRAY];
qsort(date_array, SIZE_OF_ARRAY, sizeof(Date),
   Date_compare);

template <class Type>
sort(Type *array, size_t size)
   {
   // Definition of function
   // comparisons using Type::compare(Type &);
   }

sort(date_array, SIZE_OF_ARRAY);

Inside sort, the sizeof an element is not needed, because it is compiled for the type Date. To use this sort function, you must provide a compare member function for every type of class you attempt to sort.

What happens if you use this template in two source files that get linked together into a program? It is possible that the same function (e.g. sort<Date>) has been generated in both files. In this case, the linker better be smart. The linker must detect that both functions were generated from templates, use only one function, and not produce an error message. Alternatively, keep all template definitions in one and only one source file. Then the linker does not have to be so smart.

#define glue(a,b) a##b
#define sort_function_name(class_name) \
   glue(class_name,_sort)

sort_function_name(class_name * array, unsigned_int size);

#include "sort.htp"
sort_function_name(class_name * array, unsigned_int size)
   {
   // Definition for sort
   }

#undef class_name
#define class_name Date
#include "date.h"
#include sort.htp

#include "datesort.h"
#include sort.ctp

#include "datesort.h"

#define SIZE_OF_ARRAY 10;
Date date_array[SIZE_OF_ARRAY];
Date_sort(date_array, SIZE_OF_ARRAY);

// File array.h template <class Type>
class Array
   {
   // Definition of member functions
   Type get_member (int index);
   ...
   };
// All class definitions

#include "array.h"
Array<int> my_array;

#include "intarray.h"
int_Array my_array;

What are the advantages of using a sort template over the generic qsort function? Type checking. And that's a big plus for C++.