C Programming

The asterisk here denotes a pointer. We read the above definition as "define addr_x as a pointer to a float". In general:

	   <type name> *<variable name>;
	

Why is this useful? Is allows us to change variables from afar by only knowing the address. In particular, we can now alter more than one value at a time in a function.

Look at a this example function:

	   void swap_floats (float x, float y)
	   {
		  float temp;
		  temp = x;
		  x = y;
		  y = temp;
	   }
	

Examples:

	int nums[5];
	float x[128];
	

As you may have guessed, we use square brackets [ and ] to specify indices into arrays. By C convention, array elements are indexed starting at 0. Hence, the first element of nums is nums[0], and the last element of nums is nums[4]. Be very mindful of this when programming: attempting to access nums[5] will have unpredictable results, as most compilers will happily add the size of an int to the address of the last element of nums. When the code actually runs you may get complete garbage (whatever random data is in that memory location) or you may get an access violation (on Windows)/segmentation fault (on Unix). The latter event occurs when your code does not have permission to read from the memory location.

	float x[5],sum;
	int i;
	x[0] = 0.0; x[1] = 2.0; x[2] = 1.0;
	x[3] = 4.3; x[4] = 5.6;
	sum = 0;
	for (i=0; i<5; i++)
	  sum += x[i];
	

	float x[5] = {0.0,2.0,1.0,4.3,5.6};
	

	float x[] = {0.0,2.0,1.0,4.3,5.6};
	

As we touched on in the section, major errors can occur in C when we do not keep track of the element numbers. C programs can crash or do weird things if you write to elements outside the range of the variable.

Exercise—read an array of 10 floats and return the mean of the elements of the array.

Using multi-dimensional arrays is just as easy as using one-dimensional arrays.

	float x[5][5];
	int i, j;
	for ( i = 0 ; i < 5 ; i++ ) {
		for ( j = 0 ; j < 5 ; j++ ) {
			if ( i==j ) 
				x[i][j] = 1;
			else 
				x[i][j] = 0;
		}
	}
	

	   double *x;
	   x = (double *) malloc(sizeof(double)*10);
	   if ( x == NULL ) {
	   	 printf("Allocation error.\n");
		 exit(EXIT_FAILURE);
	   }
	   /* do something with x .... */
	   free(x);
	

As stated above, you should always free up memory when you are done with it. Do not assume the operating system will do this for you. It is a good idea to add a free statement at the same time as the malloc statement: that way you will be less likely to create leaks.

	
	  char hello[13] = "Hello World\n";
	
	

	
	  char hello[] = "Hello World\n";
	
	

For strcat and strcpy there must be enough memory to store the new string in s1.

	
	float max_float (float x, float y)
	{
	   if (x>y)
		  return x;
	   else
		  return y;
	}

	int main ()
	{
		float x=2.3,y=4,max;
		max = max_float(x,y);
		printf("The maximum of %f and %f is %f.\n",x,y,max);
		return 0; 
	}
	
	

	<return type> <function name> ( <parameter list> );
	

The prototype allowed us to put the actual definition of the max_float later in the file. We could also put the definition in another file. This is one of the best uses of prototypes: splitting up large programs into lots of smaller, easier-to-manage files.

The return value of a function can be of type void, of one of the basic types, or of a pointer type. A void type means that the function does not return a value. The appropriate return statement is empty:

	   return;
	

The type of <expression> must match the <return type> declared in the function's prototype.

	
		float x = 5.4;
		float y = 3.6;
		float max;

		max_float_cr(&x, &y, &max);
	
	

The variables defined in the structure are called its members. We use the . and -> operators (depending on the context) to refer structures members.

For example here is a type to handle complex numbers.

      
          typedef struct
          {
                double real,imag;
          }
          complex_double;
        
	

After we define the structure we can use it like another type.

      
        void main ()
        {
          complex_double x;
          x.real = 0.0; /* set the real element to 0.0 */
          x.imag = 0.0; /* set the imag element to 0.0 */
        }
        
	

	double x,y;
	y = sin(2.0 * M_PI);
	

	double x,y;
	y = sin(2.0 * 3.1415926535897932385E0);
	
	

#define can also be used to define things that are "function-like".

	#define <function name> <parameter list> <replacement>
	

	( <variable name 1>, <variable name 2>,... )
	

	#define ADD(x,y) x+y
	

One caveat about macros: it's best to parenthesize arguments when you are unsure of what might be substituted in their place. For instance, suppose we had a macro for squaring a number.

	  #define SQR(x) x*x
	

	  #define SQR(x) ((x)*(x))
	

This construct is convenient, but you should not think of it as a formal function, as it does no type checking: it will happily try to add a character and a float, for instance. Nevertheless, macros such as the one above are often useful, particular for very simple functions.

Next, after writing and compiling our program, we have to link in the math library (which contains the actual code for the functions described in the math.h header file). To do this with gcc, use the "-lm" switch:

	gcc -o my_math_program my_math_program.c -lm
	

tan is a function which has the prototype:

	   double tan (double x);