Suitability of C vs C++ for

['Guy Jennings' <guy_jennings@qmgate.anl.gov>]

                      Subject:                              Time:  11:16 AM
  OFFICE MEMO         Suitability of C vs C++ for_          Date:  6/18/94
We seem to be converging on the idea of an interpreted macro language front
end driving a collection of compiled C modules as our solution to the data
acquisition software problem.

I'd like to propose the use of C++ instead of C since I feel that it is much
better suited to scientific/numerical programming than is C.  In fact, I have
been unable to think of any advantages to using C except the potential
difficulty of learning a new programming language.

Here's a top 10 list of advantages of C++ over C.

1:  Stronger Type Checking - the use of classes, inheritance & automatic type
conversions mostly eliminates the need for the abominable void* of C.

2:  Type safe linkage - you can't accidentally call a routine from another
module with the
wrong type and/or number of arguments - even if your header files get out of
date.

3:  A complex data type is provided. It includes all the standard arithmetic
operations, implemented as operators, not function calls.

4:  User-defined operators and function overloading are supported.  When you
design a data type you can specify which operators & functions are provided.

5:  You can use class libraries to provide robust new data types which can be
made exceptionally easy to use.
For example, the Rogue Wave 'math.h++' class library implements general
multi-dimensional arrays which can be manipulated with high-level operations
and an intuitive syntax:

DComplexArray a(10,10); // Construct a 10x10 complex array
cin >> a;                           // read it in from standard input
DComplexArray b = inverse(a); // Calculate the inverse
cout << b;                        // write out the inverse
cout << variance(b.diagonal());  // write out the variance of the diagonal
elements of b

6:  You can define automatic type conversions to convert between data types. 
For example, the Rogue Wave library provides a conversion from a double array
to a complex array.

DoubleVec a(10, 0.0, 1.0); // Construct a double vector in initialised to
{0,1,2,3,4...
DComplexVec z = a;          // Construct a complex vector initialised to
{(0,0),(1,0),(2,0),...
cout << a;                         // write them out
cout << z;
cout << cos(z)*exp(DComplex(0,1)*a); 

7:   Provides inline functions which combine the efficiency of using macros
with the safety of using functions - simply prepend the word 'inline' in
front of the function - if the compiler can inline it, it will.

inline Double
SumOfPositiveElements
   (const DoubleVec&amp; v)
{
   Double theSum = 0;
   for (int i = 0; i < v.length(); i++) {
      if (v[i] > 0) {
         theSum += v[i];
      }
   }
   return theSum;
}

8:   C++ Compiles most ANSI C code directly and can call compiled C code
directly, so you don't even have to learn anything new at all!
I recently spent some time converting a copy of SUPER to ANSI C on a
Macintosh and was able to compile it equally easily with C++ as well.  The
C++ version also had the advantage that it worked when I finished, I had
managed to break the C version so that it crashed almost immediately.

9:   You don't have to put all of your declarations at the top of each block
in C++.  This means
that you can organise your code into logically related 'paragraphs' complete
with their necessary declarations.  This makes code much more maintainable -
you can easily move sections of code around, taking the necessary
declarations along at the same time.  If you use the const modifier you can
also ensure that variables whose value should not change after it is first
calculated do not do so.

Double x,y;  // Declare two variables
cin >> x >> y;   // read in their values
const Double sqrtX = sqrt(x);  // Calculate the square roots
const Double sqrtY = sqrt(y);
cout << sqrt(sqrtX+sqrtY);
sqrtX = 42;  // Will give an error...

10:   Classes provide extensible types, promoting code reuse.   This can
result in major savings in the amount of code written.  I saw a recent
article which stated that the new Taligent operating system, which is written
in C++, consists of 250,000 lines of code, whereas WindowsNT, written in C,
was said to consist of 4,000,000 lines of code.

In summary, I feel that if people are about to write C code, they should look
seriously at the alternative of C++, even if you only use it as a superior
kind of C compiler.

Guy Jennings
BESSRC