Go4Expert

Go4Expert (http://www.go4expert.com/)
-   C++ (http://www.go4expert.com/forums/cpp/)
-   -   operator overloading (http://www.go4expert.com/forums/operator-overloading-t5431/)

BKurosawa 24Jul2007 10:28

operator overloading
 
Hi, I am pressed for time to finish an IntArray class with overloaded operators. I have a driver that makes use of the IntArray class. I am having problems with my code because when I run the driver almost all of the contents of the arrays are -8 and problem with array(less than 0) pops up many times on each of the twenty tests in the driver. I think there is a problem with the []operators, the constructors, and the ostream/istream operators. Can someone please look at my code and make suggestions for how to fix this problem? I will post my code here and the driver code in the following post.

Code:


//intarray.h

#ifndef _IntArray_H
#define _IntArray_H

#include <iostream>
#include "iadrv.h"
using std::ostream;
using std::istream;

class IntArray
{

        friend ostream &operator<<(ostream &output, IntArray &a);
        friend istream &operator>>(istream &input, IntArray &a);

public:
        IntArray();
        IntArray(IntArray &);
        IntArray(int start, int finish);
        IntArray(int anarray[], int amount);
        IntArray(int theSize);
        ~IntArray();
        int& operator[](int index);
        const int& operator[] (int index) const;
        int high();
        int low();
        void setName(const char* name);
        int translateIndexToZeroBased(int index);
        IntArray& operator= (const IntArray &rhs);       
        IntArray& operator+= (IntArray& add);
    friend IntArray operator+ (IntArray& start, IntArray& finish);
        bool operator!= (IntArray &other);
        bool operator== (IntArray &other);
protected:
        void CreateArray(int theSize);


private:
        int start;
        int finish;
        int size;
        int *parray;
        int index;
        int anarray;
        int amount;
        char* name;
        int theSize;
        int theStart;
        int theFinish;
};

#endif




#include <iostream>
#include "intarray.h"
#include "iadrv.h"
using namespace std;
using std::strcpy;
using std::strlen;
#include <iomanip>
using std::setw;


IntArray::IntArray(void): start(0), finish(9)
{
        CreateArray(finish + 1);
        cout<< "constructor begin" << endl;
}

IntArray::IntArray(IntArray &rhs): parray(0), start(rhs.start), finish(rhs.finish)
{
        CreateArray(rhs.size);
        for ( int i = rhs.low(); i <= rhs.high(); i++ )
                parray[i - rhs.low()] = rhs.parray[i - rhs.low()];
        cout<< "&rhs initiate" << endl;
}
IntArray::IntArray(int theStart, int theFinish): parray(0), start(theStart), finish(theFinish)
{
        if(start > finish)
        {
        cout<< "There is an error with the array" << endl;
        start = theStart;
        finish = theFinish;
        }
        else
        {
        CreateArray(finish - start + 1);
        cout<< "constructor called"<< endl;
        }

}

int IntArray::translateIndexToZeroBased(int index)
{
        index = index - low();
        return index;
}

int& IntArray::operator [](int index)
{
        static int sink;
        int zerobasedindex = translateIndexToZeroBased(index);
        if(zerobasedindex < 0 || zerobasedindex >= theSize)
        {
                cout<< "Problem with index (less than 0)" << endl;
                return sink;
        }

        else
        {
                CreateArray(index);

        }
        return parray[zerobasedindex];
}

const int& IntArray::operator [](int index) const
{
        static int sink;
        int zerobasedindex = 10;
        if(zerobasedindex < 0 || zerobasedindex >= theSize)
        {
                cout<< "Problem with index (l)" << endl;
                return sink;
        }
        return parray[zerobasedindex];
}

IntArray::IntArray(int anarray[], int amount): parray(0), size(amount), start(0), finish(amount - 1)
{
        CreateArray(amount);
        for(int i = start; i <= finish; i++)
                parray[i] = anarray[i];

}


IntArray::IntArray(int theSize): parray(0), size(theSize), start(0), finish(theSize -1)
{
        CreateArray(size);
        for(int i = start; i <= finish; i++)
                parray[i] = i * 10;

}

IntArray::~IntArray()
{
        delete []parray;
}

void IntArray::CreateArray(int theSize)
{
        parray = NULL;
        size = theSize;
        parray = new int[size];
}

int IntArray::low()
{
        return theStart;
}

int IntArray::high()
{
        return theFinish;
}



void IntArray::setName(const char* aname)
{
        name = new char[strlen(aname + 1)];
        strcpy(name, aname);
}

bool IntArray::operator ==(IntArray &other)
{
        if(*this != other)
        return false;
        for(int k = 0; k < size; k++)
                if( parray[k] != other.parray[k])
                        return false;
        return true;
}

bool IntArray::operator !=(IntArray &other)
{
        return !(this == &other);
}

IntArray &IntArray::operator =(const IntArray &rhs)
{
        if(this == &rhs)
                return *this;
        else
        {
                delete []parray;
                size = rhs.size;
                parray = new int[size];
                for(int i = start; i<size ; i++)
                        parray[i] = rhs.parray[i];
        }
        return *this;
}


IntArray operator+ (IntArray& start, IntArray& finish)
{
        int *array;
        array = new int[start.size + finish.size];
        for(int i = 0; i < start.size; i++)
                array [i] = start.parray [i];
        for(int k = start.size; k < start.size + finish.size; k++)
                array [k] = finish.parray [k - start.size];
        IntArray temp(array, start.size + finish.size);
        delete []array;
        return temp;
}

IntArray& IntArray::operator+= (IntArray& add)
{
        delete []parray;
        size = add.size;
        parray = new int[size];
        for(int k = 0; k< size ; k++)
                parray[k] += add.parray[k];
        cout<< "Success!" << endl;
        return *this;
}

istream& operator>>(istream& input, IntArray& a)
  {
 
 
  input >> a.size;
 
 
  delete []a.parray;
 
  a.parray = new int [a.size];
 

 
  for (int n = a.low(); n <= a.high(); n++)
      input >> a[n];
                         
 
  return input;
  }
ostream& operator<<(ostream& output, IntArray& a )
  {

 
  for (int n = a.low(); n <= a.high(); n++)
      output << a[n] << endl;
                         
   
  return output;
  }


BKurosawa 24Jul2007 10:29

Re: operator overloading
 
Here is the driver:

Code:


#ifndef _IADRV_H

#define _IADRV_H

 

#include "intarray.h"

 

int main();

void test1();

void test2();

void test3();

void test4();

void test5();

void test6();

void test7();

void test8();

void test9();

void test10();

void test11();

void test12();

void test13();

void test14();

void test15();

void test16();

void test17();

void test18();

void test19();

void test20();

void wait();

 

#endif



// iadrv.cpp - driver program for testing IntArray class

 

#include <iostream>

#include <iomanip>

#include <fstream>

#include <stdlib.h>

#include "iadrv.h"

#include "intarray.h"

 

using namespace std;

 

ofstream csis;

 

int main() {

    csis.open("csis.dat");

    test1();

    test2();

    test3();

    test4();

    test5();

    test6();

    test7();

    test8();

    test9();

    test10();

    test11();

    test12();

    test13();

    test14();

    test15();

    test16();

    test17();

    test18();

    test19();

    test20();

    csis.close();

}

 

void test1() {

    system("cls");

    cout << "1. Array declared with single integer: IntArray a(10);" << endl << endl;

    csis << "1. Array declared with single integer: IntArray a(10);" << endl << endl;

    IntArray a(10);

    for(int i = a.low(); i <= a.high(); i++)

        a[i] = i * 10;

    a.setName("a");

    cout << a << endl;

    csis << a << endl;

    wait();

}

 

void test2() {

    system("cls");

    cout << "2. Array declared with two integers: IntArray b(-3, 6);" << endl << endl;

    csis << "2. Array declared with two integers: IntArray b(-3, 6);" << endl << endl;

    IntArray b(-3, 6);

    for(int i = b.low(); i <= b.high(); i++)

        b[i] = i * 10;

    b.setName("b");

    cout << b << endl;

    csis << b << endl;

    wait();

}

 

void test3() {

    system("cls");

    cout << "3. Array declared with two integers: IntArray c(6, 8);" << endl << endl;

    csis << "3. Array declared with two integers: IntArray c(6, 8);" << endl << endl;

    IntArray c(6, 8);

    for(int i = c.low(); i <= c.high(); i++)

        c[i] = i * 10;

    c.setName("c");

    cout << c << endl;

    csis << c << endl;

    wait();

}

 

void test4() {

    system("cls");

    cout << "4. Array declared with two identical integers: IntArray d(5, 5);" << endl << endl;

    csis << "4. Array declared with two identical integers: IntArray d(5, 5);" << endl << endl;

    IntArray d(5, 5);

    for(int i = d.low(); i <= d.high(); i++)

        d[i] = i * 10;

    d.setName("d");

    cout << d << endl;

    csis << d << endl;

    wait();

}

 

void test5() {

    system("cls");

    cout << "5. Array declared with no integers: IntArray z;" << endl << endl;

    csis << "5. Array declared with no integers: IntArray z;" << endl << endl;

    IntArray z;

    for(int i = z.low(); i <= z.high(); i++)

        z[i] = i * 10;

    z.setName("z");

    cout << z << endl;

    csis << z << endl;

    wait();

}

 

void test6() {

    system("cls");

    cout << "6. Array declared with another object of type IntArray: IntArray c(6, 8);" << endl;

    cout << "                                                        Intarray e(c);"    << endl << endl;

    csis << "6. Array declared with another object of type IntArray: IntArray c(6, 8);" << endl;

    csis << "                                                        Intarray e(c);"    << endl << endl;

    IntArray c(6, 8);

    for(int i = c.low(); i <= c.high(); i++)

        c[i] = i * 10;

    c.setName("c");

    cout << c << endl;

    csis << c << endl;

    IntArray e(c);

    e.setName("e");

    cout << e << endl; 

    csis << e << endl;

    wait();

}

 

void test7() {

    system("cls");

    cout << "7. Array assigned to another array with different indices: IntArray f(1, 4);"  << endl;

    cout << "                                                          IntArray g(5, 8);"  << endl;

    cout << "                                                          f = g;"            << endl << endl;

    csis << "7. Array assigned to another array with different indices: IntArray f(1, 4);"  << endl;

    csis << "                                                          IntArray g(5, 8);"  << endl;

    csis << "                                                          f = g;"            << endl << endl;

    IntArray f(1, 4);

    for(int i = f.low(); i <= f.high(); i++)

        f[i] = i * 10;

    f.setName("f");

    cout << f << endl;

    csis << f << endl;

    IntArray g(5, 8);

    for(int i = g.low(); i <= g.high(); i++)

        g[i] = i * 10;

    g.setName("g");

    cout << g << endl;

    csis << g << endl;

    wait();

    system("cls");

    f = g;

    cout << f << endl;

    cout << g << endl;

    csis << f << endl;

    csis << g << endl;

    wait();

}

 

void test8() {

    system("cls");

    cout << "8. Multiple array assignment with different indices: IntArray j(3, 6);"  << endl;

    cout << "                                                    IntArray k(6, 9);"  << endl;

    cout << "                                                    IntArray l(1, 4);"  << endl;

    cout << "                                                    j = k = l;"        << endl << endl;

    csis << "8. Multiple array assignment with different indices: IntArray j(3, 6);"  << endl;

    csis << "                                                    IntArray k(6, 9);"  << endl;

    csis << "                                                    IntArray l(1, 4);"  << endl;

    csis << "                                                    j = k = l;"        << endl << endl;

    IntArray j(3, 6);

    for(int i = j.low(); i <= j.high(); i++)

        j[i] = i * 10;

    j.setName("j");

    cout << j << endl;

    csis << j << endl;

    IntArray k(6, 9);

    for(int i = k.low(); i <= k.high(); i++)

        k[i] = i * 10;

    k.setName("k");

    cout << k << endl;

    csis << k << endl;

    IntArray l(1, 4);

    for(int i = l.low(); i <= l.high(); i++)

        l[i] = i * 10;

    l.setName("l");

    cout << l << endl;

    csis << l << endl;

    wait();

    system("cls");

    j = k = l;

    cout << j << endl;

    cout << k << endl;

    cout << l << endl;

    csis << j << endl;

    csis << k << endl;

    csis << l << endl;

    wait();

}

 

void test9() {

    system("cls");

    cout << "9. Overloaded equality operator (identical elements): IntArray m(3, 7);"  << endl;

    cout << "                                                      IntArray n(1, 5);"  << endl;

    cout << "                                                      m == n"            << endl << endl;

    csis << "9. Overloaded equality operator (identical elements): IntArray m(3, 7);"  << endl;

    csis << "                                                      IntArray n(1, 5);"  << endl;

    csis << "                                                      m == n"            << endl << endl;

    IntArray m(3, 7);

    for(int i = m.low(); i <= m.high(); i++)

        m[i] = i * 10;

    m.setName("m");

    cout << m << endl;

    csis << m << endl;

    IntArray n(1, 5);

    for(int i = n.low(); i <= n.high(); i++)

        n[i] = i * 10;

    n.setName("n");

    cout << n << endl;

    csis << n << endl;

    wait();

    system("cls");

    m = n;

    cout << m << endl;

    cout << n << endl;

    cout << "Returns " << (m == n ? "True." : "False.") << endl << endl;

    csis << m << endl;

    csis << n << endl;

    csis << "Returns " << (m == n ? "True." : "False.") << endl << endl;

    wait();

}

 

void test10() {

    system("cls");

    cout << "10. Overloaded equality operator (different elements): IntArray o(3, 7);"  << endl;

    cout << "                                                      IntArray p(1, 5);"  << endl;

    cout << "                                                      o == p"            << endl << endl;

    csis << "10. Overloaded equality operator (different elements): IntArray o(3, 7);"  << endl;

    csis << "                                                      IntArray p(1, 5);"  << endl;

    csis << "                                                      o == p"            << endl << endl;

    IntArray o(3, 7);

    for(int i = o.low(); i <= o.high(); i++)

        o[i] = i * 10;

    o.setName("o");

    cout << o << endl;

    csis << o << endl;

    IntArray p(1, 5);

    for(int i = p.low(); i <= p.high(); i++)

        p[i] = i * 10;

    p.setName("p");

    cout << p << endl;

    cout << "Returns " << (o == p ? "True." : "False.") << endl << endl;

    csis << p << endl;

    csis << "Returns " << (o == p ? "True." : "False.") << endl << endl;

    wait();

}

 

void test11() {

    system("cls");

    cout << "11. Overloaded equality operator (different size arrays): IntArray q(1, 3);"  << endl;

    cout << "                                                          IntArray r(1, 4);"  << endl;

    cout << "                                                          q == r;"    << endl << endl;

    csis << "11. Overloaded equality operator (different size arrays): IntArray q(1, 3);"  << endl;

    csis << "                                                          IntArray r(1, 4);"  << endl;

    csis << "                                                          q == r;"    << endl << endl;

    IntArray q(1, 3);

    for(int i = q.low(); i <= q.high(); i++)

        q[i] = i * 10;

    q.setName("q");

    cout << q << endl;

    csis << q << endl;

    IntArray r(1, 4);

    for(int i = r.low(); i <= r.high(); i++)

        r[i] = i * 10;

    r.setName("r");

    cout << r << endl;

    cout << "Returns " << (q == r ? "True." : "False.") << endl << endl;

    csis << r << endl;

    csis << "Returns " << (q == r ? "True." : "False.") << endl << endl;

    wait();

}

 

void test12() {

    system("cls");

    cout << "12. Overloaded inequality operator (identical elements): IntArray s(3, 7);" << endl;

    cout << "                                                        IntArray t(1, 5);" << endl;

    cout << "                                                        s != t;"          << endl << endl;

    csis << "12. Overloaded inequality operator (identical elements): IntArray s(3, 7);" << endl;

    csis << "                                                        IntArray t(1, 5);" << endl;

    csis << "                                                        s != t;"          << endl << endl;

    IntArray s(3, 7);

    for(int i = s.low(); i <= s.high(); i++)

        s[i] = i * 10;

    s.setName("s");

    cout << s << endl;

    csis << s << endl;

    IntArray t(1, 5);

    for(int i = t.low(); i <= t.high(); i++)

        t[i] = i * 10;

    t.setName("t");

    cout << t << endl;

    csis << t << endl;

    wait();

    system("cls");

    s = t;

    cout << s << endl;

    cout << t << endl;

    cout << "Returns " << (s != t ? "True." : "False.") << endl << endl;

    csis << s << endl;

    csis << t << endl;

    csis << "Returns " << (s != t ? "True." : "False.") << endl << endl;

    wait();

}

 

void test13() {

    system("cls");

    cout << "13. Overloaded inequality operator (different elements): IntArray u(3, 7);" << endl;

    cout << "                                                        IntArray v(1, 5);" << endl;

    cout << "                                                        u != v;"          << endl << endl;

    csis << "13. Overloaded inequality operator (different elements): IntArray u(3, 7);" << endl;

    csis << "                                                        IntArray v(1, 5);" << endl;

    csis << "                                                        u != v;"          << endl << endl;

    IntArray u(3, 7);

    for(int i = u.low(); i <= u.high(); i++)

        u[i] = i * 10;

    u.setName("u");

    cout << u << endl;

    csis << u << endl;

    IntArray v(1, 5);

    for(int i = v.low(); i <= v.high(); i++)

        v[i] = i * 10;

    v.setName("v");

    cout << v << endl;

    cout << "Returns " << (u != v ? "True." : "False.") << endl << endl;

    csis << v << endl;

    csis << "Returns " << (u != v ? "True." : "False.") << endl << endl;

    wait();

}

 

void test14() {

    system("cls");

    cout << "14. Overloaded inequality operator (different size arrays): IntArray w(1, 3);" << endl;

    cout << "                                                            IntArray x(1, 4);" << endl;

    cout << "                                                            w != x;"          << endl << endl;

    csis << "14. Overloaded inequality operator (different size arrays): IntArray w(1, 3);" << endl;

    csis << "                                                            IntArray x(1, 4);" << endl;

    csis << "                                                            w != x;"          << endl << endl;

    IntArray w(1, 3);

    for(int i = w.low(); i <= w.high(); i++)

        w[i] = i * 10;

    w.setName("w");

    cout << w << endl;

    csis << w << endl;

    IntArray x(1, 4);

    for(int i = x.low(); i <= x.high(); i++)

        x[i] = i * 10;

    x.setName("x");

    cout << x << endl;

    cout << "Returns " << (w != x ? "True." : "False.") << endl << endl;

    csis << x << endl;

    csis << "Returns " << (w != x ? "True." : "False.") << endl << endl;

    wait();

}

 

void test15() {

    system("cls");

    cout << "15. Sum of two arrays assigned to third array: IntArray a(1, 5);"  << endl;

    cout << "                                              IntArray b(4, 8);"  << endl;

    cout << "                                              IntArray c = a + b;" << endl << endl;

    csis << "15. Sum of two arrays assigned to third array: IntArray a(1, 5);"  << endl;

    csis << "                                              IntArray b(4, 8);"  << endl;

    csis << "                                              IntArray c = a + b;" << endl << endl;

    IntArray a(1, 5);

    for(int i = a.low(); i <= a.high(); i++)

        a[i] = i * 10;

    a.setName("a");

    cout << a << endl;

    csis << a << endl;

    IntArray b(4, 8);

    for(int i = b.low(); i <= b.high(); i++)

        b[i] = i * 10;

    b.setName("b");

    cout << b << endl;

    csis << b << endl;

    wait();

    system("cls");

    IntArray c = a + b;

    c.setName("c");

    cout << c << endl;

    csis << c << endl;

    wait();

}

 

void test16() {

    system("cls");

    cout << "16. Sum of two arrays assigned to first array: IntArray d(10, 13);" << endl;

    cout << "                                              IntArray e(30, 33);" << endl;

    cout << "                                              d += e;"            << endl << endl;

    csis << "16. Sum of two arrays assigned to first array: IntArray d(10, 13);" << endl;

    csis << "                                              IntArray e(30, 33);" << endl;

    csis << "                                              d += e;"            << endl << endl;

    IntArray d(10, 13);

    for(int i = d.low(); i <= d.high(); i++)

        d[i] = i * 10;

    d.setName("d");

    cout << d << endl;

    csis << d << endl;

    IntArray e(30, 33);

    for(int i = e.low(); i <= e.high(); i++)

        e[i] = i * 10;

    e.setName("e");

    cout << e << endl;

    csis << e << endl;

    d += e;

    cout << d << endl;

    csis << d << endl;

    wait();

}

 

void test17() {

    system("cls");

    cout << "17. Array declared with illegal array bounds: IntArray f(5, 2);" << endl << endl;

    csis << "17. Array declared with illegal array bounds: IntArray f(5, 2);" << endl << endl;

    IntArray f(5, 2);

    for(int i = f.low(); i <= f.high(); i++)

        f[i] = i * 10;

    f.setName("f");

    cout << f << endl;

    csis << f << endl;

    wait();

}

 

void test18() {

    system("cls");

    cout << "18. Array with index out of range: IntArray g(10);"    << endl;

    cout << "                                  g[10] = 1;"        << endl << endl;

    csis << "18. Array with index out of range: IntArray g(10);"    << endl;

    csis << "                                  g[10] = 1;"        << endl << endl;

    IntArray g(10);

    for(int i = g.low(); i <= g.high(); i++)

        g[i] = i * 10;

    g.setName("g");

    cout << g << endl;

    csis << g << endl;

    g[10] = 1;

    wait();

}

 

void test19() {

    system("cls");

    cout << "19. Arrays with length mismatch: IntArray m(1, 4);" << endl;

    cout << "                                IntArray n(2, 4);" << endl;

    cout << "                                m = n;"            << endl << endl;

    csis << "19. Arrays with length mismatch: IntArray m(1, 4);" << endl;

    csis << "                                IntArray n(2, 4);" << endl;

    csis << "                                m = n;"            << endl << endl;

    IntArray m(1, 4);

    for(int i = m.low(); i <= m.high(); i++)

        m[i] = i * 10;

    m.setName("m");

    cout << m << endl;

    csis << m << endl;

    IntArray n(2, 4);

    for(int i = n.low(); i <= n.high(); i++)

        n[i] = i * 10;

    n.setName("n");

    cout << n << endl;

    csis << n << endl;

    wait();

    system("cls");

    m = n;

    cout << m << endl;

    cout << n << endl;

    csis << m << endl;

    csis << n << endl;

    wait();

}

 

void test20() {

    system("cls");

    cout << "20. Array subscript operator: IntArray o(7, 8);" << endl;

    cout << "                              o[7] = 25;"        << endl;

    cout << "                              o[8] = o[7];"      << endl << endl;

    csis << "20. Array subscript operator: IntArray o(7, 8);" << endl;

    csis << "                              o[7] = 25;"        << endl;

    csis << "                              o[8] = o[7];"      << endl << endl;

    IntArray o(7, 8);

    for(int i = o.low(); i <= o.high(); i++)

        o[i] = i * 10;

    o.setName("o");

    cout << o << endl;

    csis << o << endl;

    o[7] = 25;

    o[8] = o[7];

    cout << o << endl;

    csis << o << endl;

    wait();

}

 

void wait() {

    char buf;

 

    cout << "Press any key to continue." << endl;

    cin.get(buf);

}


shabbir 24Jul2007 11:41

Re: operator overloading
 
Its good to share all the code but its difficult to find the problem and if you can also share the area where you are having problem we can look into the issue faster.

BKurosawa 24Jul2007 22:28

Re: operator overloading
 
Specifically, I think there is a problem in IntArray.cpp with the [] operators, i/ostream operators, and also the constructors. In the i/ostream this part of the code has problems I think.

Code:


  for (int n = a.low(); n <= a.high(); n++)
      output << a[n] << endl;

I am not sure where the problem is in the constructors or the []operators but I narrowed it down to the following code.

Code:


IntArray::IntArray(void): start(0), finish(9)
{
        CreateArray(finish + 1);
        cout<< "constructor begin" << endl;
}

IntArray::IntArray(IntArray &rhs): parray(0), start(rhs.start), finish(rhs.finish)
{
        CreateArray(rhs.size);
        for ( int i = rhs.low(); i <= rhs.high(); i++ )
                parray[i - rhs.low()] = rhs.parray[i - rhs.low()];
        cout<< "&rhs initiate" << endl;
}
IntArray::IntArray(int theStart, int theFinish): parray(0), start(theStart), finish(theFinish)
{
        if(start > finish)
        {
        cout<< "There is an error with the array" << endl;
        start = theStart;
        finish = theFinish;
        }
        else
        {
        CreateArray(finish - start + 1);
        cout<< "constructor called"<< endl;
        }

}

int IntArray::translateIndexToZeroBased(int index)
{
        index = index - low();
        return index;
}

int& IntArray::operator [](int index)
{
        static int sink;
        int zerobasedindex = translateIndexToZeroBased(index);
        if(zerobasedindex < 0 || zerobasedindex >= theSize)
        {
                cout<< "Problem with index (less than 0)" << endl;
                return sink;
        }

        return parray[zerobasedindex];
}

const int& IntArray::operator [](int index) const
{
        static int sink;
        int zerobasedindex = 10;
        if(zerobasedindex < 0 || zerobasedindex >= theSize)
        {
                cout<< "Problem with index (l)" << endl;
                return sink;
        }
        return parray[zerobasedindex];
}


shabbir 25Jul2007 09:13

Re: operator overloading
 
I was not clear probably but in your driver program you have lots of tests and which test function is having the problem.


All times are GMT +5.5. The time now is 00:18.