Liren Large Software Subsidy 7/07.iso/c/c221/5.ddi/MWHC.005/20

Text File | 1992-06-09 | 5.8 KB | 221 lines

#include <iostream.h>
#include <stdlib.h>

#define TAB "\t"
#define SPACES "    "
#define NL  "\n"
void error(char* str);
int randint(int u);
iostream *bar;

        // base class
//--------------------------------------------------------------------------
class define_array {
public:
    int cursize, maxsize, max, first_item;
    int *x;
    define_array(int m, int n);            // constructor
    define_array() {}                // default constructor
    void start (int& i) const { i = 0; }
    ~define_array() { delete x; }        // destructor
    };

// constructor
define_array::define_array (int m, int n) {
    if (m<1 || n<m)  error ("illegal array size");
    cursize = 0;
    maxsize = m;
    max = n;
  //cout << "curs=" << cursize << " maxs=" << maxsize << " max=" << max << NL;
    x = new int[maxsize];
    }
//==========================================================================


               // First virtual drived class
//--------------------------------------------------------------------------
class create_array : virtual public define_array {
public:
    int b1x, b1y;
    create_array() { b1x = 3; b1y = 4; }
    void insert (int t);
    void insert (float f);
    int valid(int i) { return i<=max; }
    ~create_array() { b1x = 0; b1y = 0; }
    };

void create_array::insert (int t) {
    //cout << "inside insert cursize = " << cursize << NL;
    if (++cursize > maxsize) error ("too many elements");
    int i = cursize-1;
    x[i] = t;

    while (i>0 && x[i-1]>x[i]) {
    int temp = x[i];        // swap
     x[i] = x[i-1];
    x[i-1] = temp;
    i--;
    }
    }
void create_array::insert(float f) {
    insert((int)f);
    }
//==========================================================================


            // Second virtual drived class
//--------------------------------------------------------------------------
class array_op : virtual public define_array {
public:
    int b2x, b2y;
    array_op() { b2x = 5; b2y = 6; }
    int binary_search (int t) const;
    int ok(int& i) const;
    int next_item(int& i) const;
    ~array_op() { b2x = 0; b2y = 0; }
    };

int array_op::binary_search (int item) const {
    int start = 0;
    int end = cursize-1;

    while (start <= end) {
    int mid = (start+end)/2;
    if (item < x[mid])
        end = mid-1;
    else if (item > x[mid])
        start = mid+1;
    else
        return 1;
    }
    return 0;
    }

int array_op::ok(int& i) const {
    return i<cursize;
    }

int array_op::next_item(int& i) const {
    return x[i++];
    }
//==========================================================================


        // multiple inheritance
//--------------------------------------------------------------------------
class manipulate_array : public create_array, public array_op {
public:
    int dx, dy;
    manipulate_array(int a, int b);
    static void FOO(void);
    void swap(int index1, int index2);
    void inc(int index);
    void inc(float index);
    void dec(int index);
    void dec(float index);
    };

manipulate_array::manipulate_array(int num, int m):define_array(num,m) {
    dx = 7; dy = 8;
    }

void manipulate_array::swap(int i, int j) {
    int temp;
    temp = x[i];
    x[i] = x[j];
    x[j] = temp;
    if (j == maxsize)  x[j-1] = first_item;
    }

void manipulate_array::inc(int item) {
    dx += item;
    if (valid(x[item]+1))  x[item] += 1;
    if (item == 0)  first_item = x[item];
    }

void manipulate_array::inc(float item) {
    dy += item;
    inc((int) item);
    }

void manipulate_array::dec(int item) {
    dx -= item;
    if (x[item] > 1 )   x[item] -= 1;
    }

void manipulate_array::dec(float item) {
    dy -= item;
    dec((int) item);
    }

void manipulate_array::FOO(void) {
    cout << "\nFOO is a static function of the class manipulate_array\n" << NL;
    }
//==========================================================================


void main (void) {
    int var;
    int count = 0;
    int m = 10;                // number of items
    int n = 100;            // maximum integer
    manipulate_array d(m, n);    // derived from create_array array_op
    void display_array_in_order(manipulate_array& arr);
    void search(manipulate_array& arr, int item);

    int flipflop = 0;    // if 0 insert int else insert float
    while (++count <= m) {
    var = randint(n);
    if (d.valid(var)) {
        if (flipflop) d.insert((float) var);
        else d.insert(var);
        flipflop = 1-flipflop;
        }
    }
    d.FOO();
    cout << "---------------------------------------------------------" << NL;
    cout << "\tList in ascending order:\n" << NL;
    display_array_in_order(d);
    int val = 43;
    search(d, val);
    cout << "---------------------------------------------------------" << NL << NL;
    for (int i=0; i<=m; i++)
    d.inc(i);
    for (i=0; i<m; i++){
    d.dec(i);
        d.swap(i, i+1);
      }
    cout << "---------------------------------------------------------" << NL;
    cout << "\n\tList rotated left and incremented by 1: " << NL;
    display_array_in_order(d);
    val = 43;
    search(d, val);
    cout << "---------------------------------------------------------" << NL << NL;
    cout << "Done ..." << NL;
    }

void search(manipulate_array& arr, int val) {
    if (arr.binary_search(val))
    cout << "\titem: " << val << " found in the list" << NL;
    else
    cout << "\titem: " << val << " not found in the list" << NL;
    }

void display_array_in_order(manipulate_array& arr) {
    int var;
    arr.start(var);
    while (arr.ok(var)) cout << arr.next_item(var) << SPACES;
    cout << NL ;
    }

int randint(int max) {
    int rnd = rand();
    if (rnd < 0) rnd = -rnd;
    return 1 + rnd%max;
    }

void error(char* str) {
    cout << "array contains: " << str << NL;
    exit(1);
    }