C++ is stricter about type checking than C. For example, the following code fragment is legal C, but not legal C++:

main() {
    void f();

    f(45);
}

Even a simple data type such as Boolean can be implemented in a number of different ways. The best implementation depends upon your circumstances. For example, if you are making a data type for a project that three programmers will work on for four months, you will probably favor an implementation that is easy to use and simple to construct. On the other hand, if you are making a data type for a five-year project that will involve 100 programmers, you may be willing to give up some ease of use in exchange for stricter type checking so the compiler can catch more programmer mistakes.

It is in the larger coding projects, involving more than one person, that C++ holds a clear advantage over C. Why invest time carefully designing a Boolean data type if you never write programs more than a few pages long? As the type-constructing tools provided by C++ are contrasted with those of C, you will see how you can use C++ to tailor a type definition to your own unique needs.

bool func(){
bool more;
while (more=fread (/*args*/)){
      if(/*some condition*/)
          return more;
      }
}

while(more=(bool)fread(/*args*/)){
/* or worse: */
while (more=(fread (/*args*/) !=0)) {

/* bool.h */
typedef int bool;

Although typedef does not create a new data type, struct does. Here is an alternative implementation of bool in C:

/* bool.h */
typedef struct{int val;} bool;

bool a = 1; /* error */
bool b.val = 1; /* ok,
    but painful to type */

/* bool.h */
typedef struct{int val;} bool;
bool booli(int i);
int ibool(bool b);

/* bool.c */
#include <bool.h>
bool booli(int i) {
    bool ret;
    ret.val = i;
    return ret;
}
int ibool (bool b) {return b.val;}

First, this bool implementation is clumsy to use; the syntax is less than elegant. A typical use of this implementation might be:

bool b;
    b    = booli(x > 5);
    printf("b = %d\n", ibool(b));

int        l = 45;
bool      b;
/* set b to 1 */
    b.val = l;

Finally, the conversion functions create extra time and space overhead in the generated code. A function call is relatively cheap in C, but it should not be necessary for such simple conversions as these.

/* bool.h */
struct     bool {int val;};
bool      booli(int i);
int        ibool (bool b);

#include <bool.h>
/* legal C & C++ */
struct bool b;
/* legal C++, not C */
bool b;

/* bool.h */
struct bool {
private:
    int val;
    };
bool booli(int i);
int  ibool(bool b);

include <bool.>h
...
bool a;
    a.val = 5;
/* error: val is private */

/* bool.h */
struct    bool {
friend    bool     booli(int i);
friend    int      ibool(bool b);
private:
    int val;
    };

You can make the connection between the conversion functions and the data type more explicit by making the conversion functions member functions of the structure. A member function of a structure has the same privileges as a friend member function, but it has a different invocation syntax and can only be used to operate on the data type with which it was declared. Changing the two access functions into member functions results in the following header file:

/* bool.h */
struct    bool {
    void  booli(int i);
    int   ibool ();
private:
    int val;
    };

#include "bool.h"
bool b;
b.booli(45);
int i = b.ibool();

The definition of the two member functions must also change if they are not friend functions. The corresponding changes in bool.c are:

/* bool.c */
#include <bool .h>
void bool::booli(int i) {
    val = i;
}
int bool::ibool(){ return val; }

Of course, the user of data type bool still has to type things like b.ibool(), just to reference a Boolean; however, you now have hidden the implementation of the data type. If you ever discover a bool that has been set to something other than zero or one, you know the bug must be in the member functions. If you want to change val to be a char instead of an int, you can be confident that only the member functions will be affected by the change.

/* bool.h */
struct    bool {
    bool (int i);
    int     ibool ();
private:
    int val;
    };

Defining a constructor guarantees you won't have any uninitialized variables of a particular data type. In other words, with the newest header file, the following code won't compile:

#include "bool.h"
bool b; /* error */

#include "bool.h"
bool b(9);

Defining a constructor with a single argument also enables the cast operator for that data type. In this case, the constructor will be called whenever you cast an integer into a Boolean as in the following example:

#include "bool.h"
bool b(1);
int i = 38;
...
b   = (bool) i;

int      i;
long l;
l        = (long)i; /* legal C & C++ */
l        = long(i); /* legal C++ not C */

#include "bool .h"
bool b(9);
bool c = (bool)9;
bool d = bool(9);

Finally, a constructor with one argument defines an implicit conversion. Just as you can assign an int to a long because of C's built-in implicit conversion, you can now assign an int to a bool, because an implicit conversion has been defined for it. In other words, you don't have to use the cast operator and the following code fragment is legal C++.

#include "bool .h"
bool b(1);
int       i;
    b = i; /* OK */

There is no way to define a constructor function that takes a single argument without getting all three of these effects. This is a fact to ponder when you define a constructor for a data type. You can't tell the compiler to require the user to use an explicit cast to convert an integer into a Boolean. You can't tell the compiler to allow a Boolean to be initialized with an integer, but not assigned an integer. Sometimes, this forces you to avoid using a constructor and return to the explicit function notation used previously.

If you want all of your Booleans to be initialized, but don't want to have to type all those initializers, you can take advantage of a C++ feature called default arguments. Here is how it works:

/* bool.h */
stuct     bool {
    bool(int i=0);
    int    ibool ();
private:
    int val;
    };

#include "bool .h"
bool b; /* initialize to zero */
bool b = bool();

Once again, the type conversion requires a member function, but this time it is an operator member function. This revised header replaces ibool() with a type conversion function:

/* bool.h */
struct    bool {
    bool (int i);
    operator int();
private:
    int val;
    };

/* bool.c */
#include <bool.h>
bool::booli(int i) {
    val = (i != 0);
}
bool::operator int(){ return
val; }

Just as with constructor functions, the conversion function can be used either implicitly or explicitly. The following code, for example, is legal:

#include "bool.h"
bool b=1;
int i;
/*...*/
i     = (int)b;
i     = int(b);
i     = b;

The bool data type is nearly finished now. The original example of the desired usage of the data type is completely legal now:

bool func (){
bool more;
while (more=fread (/*args*/)){
     if(/*some condition*/)
         return more;
     }
}

/* bool.h */
#define     FALSE 0
#define     TRUE 1
struct      bool {
    bool(int i){val = (i!=O);}
    operator int(){return val;}
private:
    int val;
    };

There is actually an inline keyword in C++ which you can place in front of any function you would like to be inline. The simpler the function is, the more likely the compiler can generate inline code for it. When the compiler cannot inline the code, it simply generates a normal function call. Functions that are defined inside data type specifications are automatically inline functions, so there was no need for the keyword in the above specification.

Now the bool data type is as efficient as anything you could implement in C to do the same thing. Each variable of type bool is guaranteed to be either zero or one at all times and you are free to change how the Boolean is stored and how it is converted to and from integers without affecting any other code. Unfortunately our current specification still looks a bit like a C programmer coded it; here is how a more fluent C++ programmer might write it:

// bool .h
class bool {
    int val;
public:
    bool(int i){val = (i!=0);}
    operator int (){return val ;}
    };
const bool FALSE=0,TRUE=1

#include "bool .h"
#include "player.h"
playercount p;
bool      b;
    p    = b;

If you really want a second user-defined conversion to be applied, you can code it explicitly:

#include "bool .h"
#include "player.h"
playercount p;
bool      b;
    p    = playercount (b);