C/C++ Extensions

Over my years of programming in C and C++ I've made a wish list of things I'd like to see added or changed. These things mostly concern engineering and simulation programs, but some of it may be useful to others. I've organized the items on my list into functionality categories. The end-goal is to create a set of language extensions that can be enabled or disabled according to the needs of an application, either with #pragma's or command line parameters.

If others take an interest in this and suggest extensions I haven't thought of I'll try and maintain a list of them here. Maybe we can get a new standard going.

• Basic Syntax Changes
  • Default Array and Structure Operators
  • Standard Type Inheritance
  • Masked Boolean Operators
• Branching Instructions
  • Matrix Switch
• Mathematics Extensions
  • Number Types
• Scientific Extensions
  • Units

Basic Syntax Changes

Default Array and Structure Operators

Rationale

Description

For arrays loops can be used to call the operators on each element. Usage of loop-unrolling should be determined by compiler optimizations.

struct My_struct
{
   double a;
   int b;
   double a;
} structa, structb, structc;

double my_array[], my_array2, my_array3;

//operator= and operator+ are both defined for type double. so the following
//   code calls these operators for each element (assuming the arrays are the 
//   same length)

my_array3 = my_array + my_array2;

// Or...
structc = structa * structb;

// Which evaluates to...
structc.a = structa.a * structb.a;
structc.b = structa.b * structb.b;
structc.c = structa.c * structb.c;

Standard Type Inheritance

Rationale

Description

class my_double : public double
{
   ...
};

Masked Boolean Operators - Added 14 Apr 2004

Rationale

In some cases not all bits are relevant in a boolean operations. Some processors have instructions that either operate on a subset of the operand bits or somehow change their behavior based on a mask/control operand. Currently neither C nor C++ have any mechanism for directly making use of this functionality. It can only be approximated by beforming bitwise masking operations before the intended boolean operation. A compiler that can understand the concept of masked boolean operators could conceivably make use of the functionality afforded by supporting processors.

Description

Boolean operators that work through a set of mask bits. Instead of comparing all of the bits in the operands, compare only a subset of them as indicated by the mask bits.

For instance, to compare the upper half of two bytes without regard to the 4 least significant bits currently requires something like (a & 0x0F) == (b & 0x0F), which performs two bitwise AND operations before calling the equality operator. The same operation could be performed in a single instruction on some processors, however the compiler has no way of knowing that it should use the single instruction instead of multiple instructions. Boolean operators that accept a third argument would provide the compiler with the needed information and allow it to generate more optimum code.

Branching Instructions

Matrix Switch

Description

switch(a,b)
{
   case 3: break;   // Both a and b must equal 3
   case 2,4: break; // If a==2 and b==4
   case 2..4,1..6: break; // If 2<=a<=4 and 1<=b<=6
}

Mathematics Extensions

Number Types

double vector3 vec;  //An object with three elements of type double
int vector2 v2;      //An object with two elements of type int
vector3 vec3;        //Use default data type (set with a #pragma)

vec = <1,2,3>;       //Assign a value to each element
v2 = (4,5);          //Maybe use parenthesis instead of angle brackets?

//Addition of constants
vec = <1,2,3> + <4,5,6>; //So vec = <5,7,9>

vec[0] = 1;      //Assign a value to the first element of the vector
//which is equivalent to
vec.x = 1;

vec = <1,v2>;    //Composite assignment

void myfunc(double a, vector2 double vec);
...
myfunc(2,<3,4>); //This passes a const double and a const vector2 double

vector2 vec2 = {3,4};
...
myfunc(2,vec2);

Default Storage Types

#pragma def_type vector3 double //Set default type to double

Scalar

Complex Full Specification

complex < storage_type > < token >

eg.

complex double mycomplex;

Quaternion

quaternion < storage_type > < token >

Vector

vector2 < storage_type > < token >
vector3 < storage_type > < token >
vector4 < storage_type > < token >
vector[i] < storage_type > < token >

Matrix

matrix3x3 < storage_type > < token >
matrix4x4 < storage_type > < token >
matrix[i][j] < storage_type > < token >

Arrays

vector3 double my_vec[5];

vector3 int my_vec[5][5]; //5x5 array of 3 element vectors of type int
matrix[3][3][3] int my_matrix[5][5]; //5x5 array of 3-D matrices

Polar Coordinates

Scientific Extensions

Units Checking

< unit_type > < number_type > < storage_type > < token >

myfunc()
{
   meters int x;
   meters double length; 
   radians double rad;
   ...
} 

rad = length;

double sin(radians double x); 
degrees double theta; 
radians double radtheta;
... 
double a = sin(theta);  //The compiler automatically converts theta to 
                        //   radians
theta = radtheta;       //And here it converts radians to degrees

meters vector3 long myvector;