The representation of large numbers that has been chosen for our class is an extension of the representation presented in Part I for the C language. We take from there the arrangement of the digits of a natural number as a vector of clint values, where more-significant digits occupy the places of higher index (cf. Chapter 2). The memory required for this is automatically allocated when an object is generated. This is carried out by the constructors, which are invoked either explicitly by the program or implicitly by the compiler using the allocation function new(). In the class declaration we therefore require a variable of type clint *n_l, to which is associated within one of the constructor functions a pointer to the memory allocated there.

The variable status is used to keep track of various states that can be taken by LINT objects. For example, with status, an overflow or underflow (cf. page 20) can be reported if such an event occurs as a result of operations on LINT objects that would result in the status variable being assigned the value E_LINT_OFL or E_LINT_UFL. Furthermore, we would like to determine whether a LINT object has been initialized, that is, whether any numerical value at all has been assigned to it, before it is used in a numerical expression on the right side of the equal sign. If a LINT object does not possess a numerical value, then status contains the value E_LINT_INV, which all functions must check before an operation is executed. We shall organize our LINT functions and operators in such a way that an error message results if the value of a LINT object, and consequently the value of an expression, is undefined.

The variable status is, strictly speaking, not an element of our numerical representation. It serves rather for reporting and handling error states. The types and mechanisms of error handling are discussed in detail in Chapter 16.

The class LINT defines the following two elements for representing numbers and storing the states of objects:

clint* n_l;
int status;

Since we are dealing here with private elements, access to these class elements is possible only by means of member or friend functions or operators. In particular, there is no possibility of direct access to the individual digits of a number represented by a LINT object.

Constructors are functions for the generation of objects of a particular class. For the LINT class this can occur with or without initialization, where in the latter case an object is created and the required memory for the storage of the number is allocated, but no value is assigned to the object. The constructor required for this takes no argument and thus takes on the role of the default constructor of the class LINT (cf. [Str1], Section 10.4.2). The following default constructor LINT(void) in flintpp.cpp creates a LINT object without assigning it a value:

LINT::LINT (void)
  {
    n_l = new CLINT;
    if (NULL == n_l)
      {
        panic (E_LINT_NHP, "constructor 1", 0, __LINE__);
      }
    status = E_LINT_INV;
  }

If a newly generated object is also to be initialized with a numerical value, then a suitable constructor must be invoked to generate a LINT object and then assign to it a predefined argument as the value. Depending on the type of argument various overloaded constructors must be provided. The class LINT contains the constructor functions as shown in Table 14-1.

We would now like to consider a further example for the LINT construction of the function LINT (const char*), which generates a LINT object and associates to it a value taken from a character string with ASCII digits. A prefix can be given to the digits contained in the string that contains information about the base of the numerical representation. If a character string is prefixed with 0x or 0X, then hexadecimal digits from the domains {0,1,. . .,9} and {a,b,. . .,f}, respectively {A,B,. . .,F}, are expected. If the prefix is 0b or 0B, then binary digits from the set {0, 1 } are expected. If there is no prefix at all, then the digits are interpreted as decimal digits. The constructor employs the function str2clint_l() to transform the character string into an object of type CLINT, from which then in the second step a LINT object is created:

LINT:: LINT (const char* str)
  n_l = new CLINT;
  if (NULL == n_l) // error with new?
    {
      panic (E_LINT _NHP, "constructor 4", 0, __LINE__);
    }
  if (strncmp (str, "0x", 2) == 0 || strncmp (str, "0X", 2) == 0)
    {
      int error = str2clint_l (n_l, (char*)str+2, 16);
    }
  else

{
      if (strncmp (str, "0b", 2) == 0 || strncmp (str, "0B", 2) == 0)
        {
          error = str2clint_l (n_l, (char*)str+2, 2);
        }
      else
        {
          error = str2clint_l (n_l, (char*)str, 10);
        }
    }
  switch (error)     {
      case E_CLINT_OK:
        status = E_LINT_OK;
        break;
      case E_CLINT_NPT:
        status = E_LINT_INV;
        panic (E_LINT_NPT, "constructor 4", 1, __LINE__);
        break;
      case E_CLINT_OFL:
        status = E_LINT_OFL;
        panic (E_LINT_OFL, "constructor 4", 1, __LINE__);
        break;
      default:
        status = E_LINT_INV;
        panic (E_LINT_ERR, "constructor 4", error, __LINE__);
    }
}

Constructors make possible the initialization of LINT objects amongthemselves as well as LINT objects with standard types, constants, and characterstrings, as the following examples demonstrate:

LINT a;
LINT one (1);
int i = 2147483647;
LINT b (i);
LINT c (one);
LINT d ("0x123456789abcdef0");

The constructor functions are called explicitly to generate objects of type LINT from the specified arguments. The LINT constructor, which, for example, changes unsigned long values into LINT objects, is embodied in the following function:

LINT::LINT (USHORT ul)
{
  n_l = new CLINT;
  if (NULL == n_l)
    {
      panic (E_LINT_NHP, "constructor 11", 0, __LINE__);
    }
  ul2clint_l (n_l, ul);
  status = E_LINT_OK;
}

Now we must provide a destructor function to go with the constructors of the class LINT, which enable the release of objects and, in particular, the memory bound to them. To be sure, the compiler would gladly make a default destructor available to us, but this would release only the memory that the elements of a LINT object possess. The additional memory allocated by the constructors would not be released, and memory leakage would result. The following short destructor fulfills the important tasks of releasing memory occupied by LINT objects:

~LINT()
  {
    delete [] n_l;
  }

The overloading of operators represents a powerful mechanism that makes it possible to define functions with the same name but with different parameter lists, functions that can then carry out differing operations. The compiler uses the specified parameter list to determine which function is actually meant. To make this possible C++ employs strong type-checking, which tolerates no ambiguity or inconsistency.

The overloading of operator functions makes it possible to use the "normal" way of expressing a sum c = a + b with LINT objects a, b, and c instead of having to invoke a function like, for example, add_l(a_l, b_l, c_l). This enables the seamless integration of our class into the programming language and significantly improves the readability of programs. For this example it is necessary to overload both the operator "+" and the assignment "=".

There are only a few operators in C++ that cannot be overloaded. Even the operator "[]", which is used for access to vectors, can be overloaded, for example by a function that simultaneously checks whether the access to a vector oversteps the vector's bounds. However, please note that the overloading of operators opens the door to all possible mischief. To be sure, the effect of the operators of C++ on the standard data types cannot be altered; nor can the predefined precedence order of the operators (cf. [Str1], Section 6.2) be changed or new operators "created." But for individual classes it is fully possible to define operator functions that have nothing in common with what one traditionally has associated with the operator as it is normally employed. In the interest of maintainability of programs one is well advised to stick close to the meaning of the standard operators in C++ when overloading operators if one is to avoid unnecessary confusion.

One should note in the above outline of the LINT class that certain operators have been implemented as friend functions and others as member functions. The reason for this is that we would like, for example, to use "+" or "*" as two-position operators that can not only process two equivalent LINT objects but accept alternatively one LINT object and one of the built-in C++ integer types, and moreover, accept the arguments in either order, since addition is commutative. To this end we require the above-described constructors, which create LINT objects of out integer types. Mixed expressions such as in

LINT a, b, c;
int number;

// Initialize a, b, and number and calculate something or other
// . . .
c = number * (a + b / 2)

are thus possible. The compiler takes care of calling the appropriate constructor functions automatically and sees to it that the transformation of the integer type number and the constant 2 into LINT objects takes place at run time, before the operators + and * are invoked. We thereby obtain the greatest possible flexibility in the application of the operators, with the restriction that expressions containing objects of type LINT are themselves of type LINT and can thereafter be assigned only to objects of type LINT.

Before we get ourselves involved in the details of the individual operators, we would like to give an overview of the operators defined by the class LINT, for which the reader is referred to Tables 14-2 through 14-5,

We now would like to deal with the implementation of the operator functions "*", "=", "*=", and "==", which may serve as examples of the implementation of the LINT operators. First, with the help of the operator "*=" we see howmultiplication of LINT objects is carried out by the C function mul_l(). The operator is implemented as a friend function, to which both factors associated with the operation are passed as references. Since the operator functions do not change their arguments, the references are declared as const:

const LINT operator* (const LINT& lm, const LINT& ln)
{
  LINT prd;
  int error;

if (lm.status == E_LINT_INV)
  LINT::panic (E_LINT_VAL, "*", 1, __LINE__);
if (ln.status == E_LINT_INV)
  LINT::panic (E_LINT_VAL, "*", 2, __LINE__);

error = mul_l (lm.n_l, ln.n_l, prd.n_l);

switch (error)
  {
    case 0:
      prd.status = E_LINT_OK;
      break;
    case E_CLINT_OFL:
      prd.status = E_LINT_OFL;
      break;
    default:
      lint::panic (E_LINT_ERR, "*", error, __LINE__);
  }

return prd;
}

Since the object prd exists only within the context of the function, the compiler makes sure that a temporary object is created automatically, which represents the value of prd outside the function. This temporary object is generated with the aid of the copy constructor LINT(const LINT&) (cf. page 328) and exists until the expression within which the operator was used has been processed, that is, until the closing semicolon has been reached. Due to the declaration of the function value as const such nonsensical constructs as (a * b) = c; will not get past the compiler. The goal is to treat LINT objects in exactly the same way as the built-in integer types.

We can extend the operator functions by the following detail: If the factors to be multiplied are equal, then the multiplication can be replaced by squaring, so that the advantage in efficiency associated with this changeover can be utilized automatically (cf. Section 4.2.2). However, since in general it costs an elementwise comparison of the arguments to determine whether they are equal, which is too expensive for us, we shall be satisfied with a compromise: Squaring will be brought into play only if both factors refer to one and the same object. Thus we test whether ln and lm point to the same object and in this case execute the squaring function instead of multiplication. Here is the relevant code:

if (&lm == &ln)
  {
    error = sqr_l (lm.n_l, prd.n_l);
  }
else
  {
    error = mul_l (lm.n_l, ln.n_l, prd.n_l);
  }

This falling back on the functions implemented in C from Part I is a model for all of the remaining functions of the class LINT, which is formed like a shell around the kernel of C functions and protects it from the user of the class.

Before we turn our attention to the more complex assignment operator "*=", it seems a good idea to take a closer look at the simple assignment operator "=". Already in Part I we established that assignment of objects requires particular attention (cf. Chapter 8). Therefore, just as in the C implementation we had to pay heed that in assigning one CLINT object to another the content and not the address of the object was assigned, we must likewise for our LINT class define a special version of the assignment operator "=" that does more than simply copy elements of the class: For the same reasons as were introduced in Chapter 8 we must therefore take care that it is not the address of the numerical vector n_l that is copied, but the digits of the numerical representation pointed to by n_l.

Once one has understood the fundamental necessity for proceeding thus, the implementation is no longer particularly complicated. The operator "=" is implemented as a member function, which returns as a result of the assignment a reference to the implicit left argument. Of course, we use internally the C function cpy_l() to move digits from one object into the other. For executing the assignment a = b the compiler calls the operator function "=" in the context of a, where a takes over the role of an implicit argument that is not given in the parameter list of the operator function. Within the member function reference to the elements of the implicit argument is made simply by naming them without context. Furthermore, a reference to the implicit object can be made via the special pointer this, as in the following implementation of the operator "=":

const LINT& LINT::operator= (const LINT& ln)
{
  if (ln.status == E_LINT_INV)
    panic (E_LINT_VAL "=", 2 __LINE__);

if (&ln != this)
    {
      cpy_l (n_l, ln.n_l);
      status = ln.status;
    }
  return *this;
}

One might ask whether the assignment operator must necessarily return any value at all, since after LINT::operator =(const LINT&) is called the intended assignment appears to have been accomplished. However, the answer to the question is clear if one recalls that expressions of the form

f (a = b);

are allowed. According to the semantics of C++, such an expression would result in a call to the function f with the result of the assignment a = b as argument. Thus is it imperative that the assignment operator return the assigned value as result, and for reasons of efficiency this is done by reference. A special case of such an expression is

a = b = c;

where the assignment operator is called two times, one after the other. At the second call the result of the first assignment b = c is assigned to a.

In contrast to the operator "*", the operator "*=" changes the leftmost of the two passed factors by overwriting it with the value of the product. The meaning of the expression a *= b as an abbreviated form of a = a * b should, of course, remain true for LINT objects. Therefore, the operator "*=" can, like the operator "=", be set up as a member function that for the reasons given above returns areference to the result:

const LINT& LINT::operator*= (const LINT& ln)
{
    int error;

    if (status == E_LINT_INV)
      panic (E_LINT_VAL, "*=", 0, __LINE__);
    if (ln.(status == E_LINT_INV)
      panic (E_LINT_VAL, "*=", 1, __LINE__);
    if (&ln == this)
      error = sqr_l (n_l, n_l);
    else
      error = mul_l (n_l, ln.n_l, n_l);

    switch (error)
      {
        case 0:
          status = E_LINT_OK;
          break;
        case E_CLINT_OFL:
          status = E_LINT_OFL;
          break;
        default:
          panic (E_LINT_ERR, "*=", error, __LINE__);
        }
  return *this;
  }

As our last example of a LINT operator we shall describe the function "==", which tests for the equality of two LINT objects: As result the value 1 is returnedin the case of equality, and otherwise 0. The operator == also illustrates theimplementation of other logical operators.

const int operator == (const LINT& lm, const LINT& ln)
{
  if (lm.(status == E_LINT_INV)
    LINT::panic (E_LINT_VAL, "==", 1, __LINE__);
  if (ln.(status == E_LINT_INV)
    LINT::panic (E_LINT_VAL, "==", 2, __LINE__);
  if (&ln == &lm)
    return 1;
  else
    return equ_l (lm.n_l, ln.n_l);
}