Classic C (also called K&R C after its authors, Brian Kernighan and Dennis Ritchie) uses a function header that’s different from the one used in C++. In C++ the parameter types and names are included inside the ( ) defining the function. In Classic C, only the names appear. Type information comes later. The following code shows the same function twice, first as defined in C++, followed by its K&R definition:

int do_it(char *name, int function)   // C++ function definition
{
    // Body of the function

int do_it(name, function)             // Classic C definition
char *name;
int function;
{
    // Body of the function

When C++ came along, the ANSI C committee decided it would be a good idea if C used the new function definitions. However, because there was a lot of code out there using the old method, C accepts both types of functions. C++ does not.

int funct(  );    // Default prototype for Classic C functions

int do_it(  );    // Classic C function prototype

i = do_it(  );
i = do_it(1, 2, 3);
i = do_it("Test", 'a'),

In C++, when you declare a struct, you can use the structure as a type name. For example:

struct sample {
    int i, j;    // Data for the sample
};
sample sample_var;  // Last sample seen

C is more strict. You must put the keyword struct before each variable declaration:

struct sample sample_var;  // Legal in C
sample sample_var;          // Illegal in C

In C++, you use the new operator to get memory from the heap and use delete to return the memory. C has no built-in memory-handling operations. Instead, it makes use of two library routines: malloc and free.

foo_ptr = (struct foo *)malloc(sizeof(struct foo));

foo_ptr = new foo;

foo_ptr = (struct foo *)malloc(sizeof(struct foo) * 3);

foo_ptr = new foo[3];

foo_var = (struct foo*)calloc(3, sizeof(foo));

foo_var = new foo[3];
memset(foo_var, '', sizeof(foo) * 3);

class foo {...};
foo_var = (struct foo *)malloc(sizeof(struct foo)); // Don't code like this

free((char *)foo_var);
foo_var = NULL;

delete foo_var;
foo_var = NULL;

delete []foo_array;
foo_array = NULL;

Frequently when examining C code you may find a number of defined struct statements that look like they should be objects defined as C++ classes. Actually, a structure is really just a data-only class with all the members public.

C programmers frequently take advantage of the fact that a structure contains only data. One example of this is reading and writing a structure to a binary file. For example:

a_struct struct_var;	   // A structure variable

// Perform a raw read to read in the structure
read_size = read(fd, (char *)&struct_var, sizeof(struct_var));

// Perform a raw write to send the data to a file
write_size = write(fd, (char *)&struct_var, sizeof(struct_var));

Turning a structure like this into a class can cause problems. C++ keeps extra information, such as virtual function pointers, in a class. When you write the class to disk using a raw write, you are outputting all that information. What’s worse, when you read the class in, you overwrite this bookkeeping data.

For example, suppose we have the class:

class sample {
    public:
        const int sample_size;     // Number of samples
        int cur_sample;            // Current sample number
        sample(  ) : sample_size(100) {} // Set up class
        virtual void get_sample(  ); // Routine to get a sample
};

Internally, this class consists of three member variables: a constant, sample_size (which C++ won’t allow you to change); a simple variable, cur_sample; and a pointer to the real function to be used when get_sample is called. All three of these are written to disk by the call:

sample a_sample;
// ...
write_size = write(fd, (char *)&a_sample, sizeof(a_sample));

When this class is read, all three members are changed. That includes the constant (which we aren’t supposed to change) and the function pointer (which now probably points to something strange).

C programmers also make use of the memset function to set all the members of a structure to zero. For example:

struct a_struct { ... }
a_struct struct_var;
// ...
memset(&struct_var, '', sizeof(struct_var));

Be careful when turning a structure into a class. If we had used the class a_sample in the previous example instead of the structure struct_var, we would have zeroed the constant sample_size as well as the virtual function pointer. The result would probably be a crash if we ever tried to call get_sample.

C has its own way of handling exceptions through the use of setjmp and longjmp. The setjmp function marks a place in a program. The longjmp function jumps to the place marked by setjmp.

Normally setjmp returns a zero. This tells the program to execute normal code. When an exception occurs, the longjmp call returns to the location of the setjmp function. The only difference the program can see between a real setjmp call and a fake setjmp call caused by a longjmp is that normally setjmp returns a zero. When setjmp is “called” by longjmp, the return value is controlled by a parameter to longjmp.

The definition of the setjmp function is:

#include <setjmp.h>

int setjmp(jmp_buf env);

where env is the place where setjmp saves the current environment for later use by longjmp.

The setjmp function return values are as follows:

The definition of the longjmp call is:

void longjmp(jmp_buf env, int return_code);

where env is the environment initialized by a previous setjmp call, and return_code is the return code that will be returned by the setjmp call.

Figure 28-1 illustrates the control flow when using setjmp and longjmp.

Figure 28-1. setjmp/longjmp control flow

There is one problem here, however. The longjmp call returns control to the corresponding setjmp. It does not call the destructors of any classes that are “destroyed” in the process.

In Figure 28-1 we can see that in the subroutine we define a class named a_list. Normally we would call the destructor for a_list at the end of the function or at a return statement. However, in this case we use longjmp to exit the function. Since longjmp is a C function, it knows nothing about classes and destructors and does not call the destructor for a_list. So we now have a situation where a variable has disappeared but the destructor has not been called. The technical name for this situation is a “foul-up.”

When converting C to C++, change all setjmp/longjmp combinations into exceptions.

It is possible for C++ code to call a C function. The trick is that you need to tell C++ that the function you are calling is written in C and not C++. This is accomplished by declaring the function prototypes inside an extern "C" block. For example:

extern "C" {
    extern int the_c_function(int arg);
}

What you must do to get C to compile with a C++ compiler:

Once you’ve done these tasks, you have a C+¹/₂ program. It works, but it’s really a C program in C++’s clothing. To convert it to a real C++ program, you also need to do the following:

Exercise 28-1: There are a lot of C programs out there. Turn one into C++.