C Now

Modular Programs in C

Modular Programming

modular programming
A programming style in which a program is divided into separately compiled files.
In C, modular programming uses separate implementation and interface files.
Interface files (usually referred to as header files) contain declarations, but no executable code.
Implementation files use the declarations which are in the interface files, by including them with preprocessor #include statements, and contain executable code.
Interface (header) files have the extension .h.
Implementation files have the extension .c.

A Program using Boolean Operators

File barith2.c

/***************************************************************
 * File:    barith2.c
 * Purpose: Program to report the results 
 *          of boolean operations.
 * Author:  John Young
 * Date:    May 24, 2004
 ***************************************************************/

#include "boolean.h"

int main () {

  And (0, 0);
  And (0, 1);
  And (1, 0);
  And (1, 1);
  Or (0, 0);
  Or (0, 1);
  Or (1, 0);
  Or (1, 1);
  EQ (0, 0);
  EQ (0, 1);
  EQ (1, 0);
  EQ (1, 1);
  NE (0, 0);
  NE (0, 1);
  NE (1, 0);
  NE (1, 1);
  Not (0);
  Not (1);

  return 0;
}

File boolean.h

/***************************************************************
 * File:    boolean.h
 * Purpose: Interface for functions to report the results 
 *          of boolean operations.
 * Author:  John Young
 * Date:    May 24, 2004
 ***************************************************************/

#ifndef boolean_h
#define boolean_h

void And (int A, int B);

void Or (int A, int B);

void EQ (int A, int B);

void NE (int A, int B);

void Not (int A);

#endif

File boolean.c

/***************************************************************
 * File:    boolean.c
 * Purpose: Implementation of functions to report the results 
 *          of boolean operations.
 * Author:  John Young
 * Date:    May 24, 2004
 ***************************************************************/

#include <stdio.h>
#include "boolean.h"

void And (int A, int B) {
  int Result;

  Result = A && B;
  printf ("%d && %d = %d\n", A, B, Result);
}

void Or (int A, int B) {
  int Result;

  Result = A || B;
  printf ("%d || %d = %d\n", A, B, Result);
}

void EQ (int A, int B) {
  int Result;

  Result = A == B;
  printf ("%d == %d = %d\n", A, B, Result);
}

void NE (int A, int B) {
  int Result;

  Result = A != B;
  printf ("%d != %d = %d\n", A, B, Result);
}

void Not (int A) {
  int Result;

  Result = ! A;
  printf ("! %d = %d\n", A, Result);
}

Compiling the program:

>cc barith2.cpp boolean.cpp
Borland C++ 5.5 for Win32 Copyright (c) 1993, 2000 Borland
barith2.cpp:
boolean.cpp:
Turbo Incremental Link 5.00 Copyright (c) 1997, 2000 Borland

will produce barith2.exe
Program output

0 && 0 = 0
0 && 1 = 0
1 && 0 = 0
1 && 1 = 1
0 || 0 = 0
0 || 1 = 1
1 || 0 = 1
1 || 1 = 1
0 == 0 = 1
0 == 1 = 0
1 == 0 = 0
1 == 1 = 1
0 != 0 = 0
0 != 1 = 1
1 != 0 = 1
1 != 1 = 0
! 0 = 1
! 1 = 0

This program applys the integer operators to all possible combinations of true and false (0 and 0, 0 and 1, 1 and 0, and 1 and 1), and then reports the results to standard output, normally the display screen.

Declarations

Function Prototypes

function prototype
A function declaration that provides type information for each parameter.
The declaration of a function (the prototype) should appear in the source code before it is used in an expression.
Syntax:

<type> <name> ( <arg type list> );
The type of a function is the type of the value returned by it.
The type of programmer written functions can be any of the builtin C types, a previously declared type, or the keyword void.
A function with type void does not return a value, and corresponds to the procedure of other languages.
The <arg type list> is a list of argument types, separated by commas,

And

The and operator for integer operands is a double ampersand sign (&&).
The result has a type of int.
If both values are true (1), the result is true (1); if either value is false (0), the result is false (0);
Style: Programs are more readable if spaces are used before and after the and operator.

Or

The or operator for integer operands is a double vertical bar (||).
The result has a type of int.
if either value is true (1), the result is true (1); If both values are false (0), the result is false (0);
Style: Programs are more readable if spaces are used before and after the or operator.

Equality

The equality operator for integer operands is a double equals sign (==).
The result has a type of int.
If the operand values are equal, the result is true (1); if the operand values are not equal, the result is false (0);
Style: Programs are more readable if spaces are used before and after the equality operator.

Inequality

The inequality operator for integer operands is the exclamation mark followed by an equals sign (!=).
The result has a type of int.
The inequality operator is equivalent to an exclusive or operator.
If the operand values are not equal, the result is true (1); if the operand values are equal, the result is false (0);
Equivalently, the result is true iff exactly one of the operand values is true.
Style: Programs are more readable if spaces are used before and after the inequality operator.

Not

The not operator for integer operands is an exclamation mark (!).
unary operator
An operator with a single operand.
Not is a unary operator.
The result has a type of int.
if the operand value is false (0), the result is true (1); if the operand value is true (1), the result is false (0);
Style: Programs are more readable if spaces are used before and after the not operator.

function prototype

modular programming

unary operator

	ASCII character codes	Computer Science Now
	C Character Set	C Now
	C Keywords	C Now

C Now Home

Tutorial Index