TextItem::TextItem(char *file_name)
   {
   m_file_name = file_name;
   file_pointer = fopen(file_name,"r");
   }

To declare an object of type TextItem you could write:

TextItem my_text_item("my_file");

TextItem *my_pointer =
   new TextItem("my_file");

You can handle constructor failures a number of interesting ways. In this month's column I describe a fairly simple method. The approach involves creating a private member in each object to keep track of whether the object is in a valid state. This member's value is set by the constructor and any other member functions that may change the state. A public function can return the validity state. All member functions can test the state of an object before operating on it. The corresponding class might look like this:

class TextItem
   {
   public:
      TextItem(char * file_name);
      Boolean is_valid();
      ...
   private:
      char * m_file_name;
      FILE * file_pointer;
      Boolean valid;
      };
   
   TextItem::TextItem(char *file_name)
      {
      valid = FALSE;
      m_file_name = file_name;
      file_pointer =
         fopen(file_name,"r");
      if (file_pointer != NULL)
         valid = TRUE;
      }
   Boolean TextItem::is_valid()
      {
      return valid;
      }

TextItem my_text_item("my_file");
if (!my_text_item.is_valid())
   {

   // Do appropriate actions

   TextItem *my_pointer =
      new TextItem("my_file");
   if (!my_pointer.is_valid ())
      {
      // Free allocated memory
      delete my_pointer;
   //Do any other appropriate actions

class TextItem
   {
public:
   TextItem(char * file_name);
   TextItem();
   Boolean open(char *file_name);
   ...
private:
   char * m_file_name;
   FILE * file_pointer;
   Boolean valid;
   };

TextItem::TextItem()
   {
   valid = FALSE;
   }

Boolean
TextItem::open(char *file_name)
   {
   // Check to see if already open
   //if (valid)
      {
      fclose(file_pointer);
      m_file_name = "";
      }
   valid = FALSE;
   m_file_name = file_name;
   file_pointer =
      fopen(file_name,"r");
   if (file_pointer != NULL)
      valid = TRUE;
   return valid;
   }

TextItem my_text_item("my_file");
if (!my_text_item.is_valid())
   {
   // Try alternative file
   if (!my_text_item.open(
   "another_file")) {
      // Do appropriate action or
      // try again

Before going onto the next question, I'd like to complete the picture with a discussion of destructors. The system always calls an object's destructor when the object goes out of scope. If you don't include a destructor, C++ will provide a default constructor. But, if your object contains a validity flag, then you will probably also need to create a non-trivial destructor for that object. The destructor should test the validity of the object. If the object is valid, the destructor should in most cases perform the reverse of the actions that made the object valid. For example:

TextItem::~TextItem()
   {
   if (valid)
      {
      fclose(file_pointer);
      }
   }

After reading the column "Question & Answers: Using C Libraries in C++" in the May, 1994 issue of The C User's Journal I came across a techinfo file from Borland that discussed the use of the qsort function in C++. The following text and code is the contents of the file TI659.ASC, dated October 19, 1993, entitled "An Example of Using qsort in C++ Mode:"

Due to the strict type checking enforced by the C++ language, one must insure that the types of the parameters to qsort match exactly.

The types of the parameters passed to the compare function are the area for grief here. By using a typedef which typecasts the compare function to have the types required by the ANSI C prototype for qsort, C++ can be made to accept our code.

//-------------------------------------
// QSORTX.CPP - using qsort() in
// C++ mode

#include <stdlib.h>

typedef int (*cmp_func)(const void *, const void *);

int compare( const int *one, const int *two )
   {
   if (*one > *two)
      return -1
   else
      return 1;
   } // end of compare()

int a[3] = { 50, 10, 20 };

main()
   {
   qsort(a, 3, sizeof(a[0]),compare);
   // Does not compile in C++
   qsort(a, 3, sizeof(a[0]), (cmp_func)compare);
   // Does compile
   } // end of main()

Duane Clark
Kingsville, TX

A

As I noted in my answer, I prefer using this approach, as the compare function accepts pointers to members of a particular class. However, this approach is not guaranteed to be portable, as P.J. Plauger pointed out. On some machines — especially ancient ones, the representation of a void pointer is not necessarily the same as the representation of a pointer to a data type such as int. I worked on one machine which used 12-bit chars and could hold five chars in an addressable word. (In case you are wondering, the machine had a 60-bit word). However, I have not heard of a machine in common use that uses inconsistent pointer representations. If anyone does know of such a machine, please let me know.

The alternative to Borland's approach is to use a compare function such as

int compare( const void *one, const void *two );

Phil Bolduc presented the problem that a member function cannot be used by qsort — but this is only a problem for non-static member functions (which can also access private members of the class)! For example:

#include <stdlib.h>

class DataType
{
public:
   static int compare(const void *, const void *);
};

extern int operator<(const DataType &, const DataType &);
extern int operator==(const DataType &, const DataType &);

void sortDataType(DataType *array, int count)
   {
   qsort(array, count, sizeof(DataType), &DataType::compare);
   }

int DataType::compare(const void *left, const void *right)
   {
   const DataType *dtLeft = (const DataType *)left;
   const DataType *dtRight = (const DataType *)right;
   return (*dtLeft < *dtRight) ? -1 : (*dtLeft == *dtRight) ? 0 : 1;
   }

Tony Cook

A

Thanks for the reply. Tony Beleta of Barcelona, Spain, sent in a similar letter. My original answer centered around the possible incompatibilities between calling sequences of C and C+ functions.

If qsort is compiled as a C++ function, then you have two alternatives: You can make compare a static member of the class, as you have shown, or you can add comparison functions to the class.

For our readers new to C++, a static class function is one that is called without an instance of the class. A static class function does not receive a this pointer. It has the same access rights as other member functions to the private members of the class.

As shown in Tony's example, the DataType::compare(const void *, const void *) will receive two pointers, each of which should point to an object of the DataType class. Since compare is a static class function, it can directly access the appropriate private members of DataType to determine the result.

If you have coded functions as operator: == and operator<, for which Tony shows the prototypes, then the comparison function does not have to be a member of the class. It could be a normal function such as:

int compare_DataType(const void *left, const void *right)
   {

   const DataType *dtLeft = (const DataType *)left;
   const DataType *dtRight = (const DataType *)right;
   return (*dtLeft < *dtRight) ? -1 : (*dtLeft == *dtRight) ? 0 : 1;
   }

If qsort is compiled as a C function, rather than a C++ function, then the problem of a mismatch between C and C++ calling sequences can occur, as covered in the original answer. Borland has found a way around this problem, but it is not part of the C++ language specification.

In "caveats" ("Q&A," The C Users Journal, June 1994) you give an example:

void a_function(int *p_first, const int * p_second)
   {
   /* What you can do */
   * p_first = *p_second;
   /* What you cannot do */
   p_second = p_first;
   /* What you should not do */
   p_first = p_second;
   }

   /* What you cannot do */
   *p_second = *p_first;

A

Thanks for your sharp-eyed correction. The example should have looked like this:

void a_function(int *p_first, const int * p_second)
   {
   /* What you can do */
   *p_first = *p_second;
   /* What you cannot do */
   *p_second = *p_first;
   /* What you should not do */
   p_second = p_first;
   p_first: p_second;
   }