好像根据书中那样写出来的程序
虽然说是重载了operator[ ] ,好像还是不能
象这样 IntArray myArray;
        myArray[4] = 5 ; // 这样的赋值根本就通过不了!!!!

而他下面的例子中这样的赋值比比皆是

请教一下^^^^^达人帮忙解释一下哈,谢谢


附上我写的代码:
//IntArray.h

#include <cassert>

class IntArray
{
    public:
        explicit IntArray(int size = defaultsize);
        IntArray ( int size, int *array);
        IntArray ( const IntArray &rhs);
        virtual ~IntArray(){delete [] ia;};
        int operator[](int index);
        bool operator==(const IntArray& rhs) const;
        bool operator!=(const IntArray& rhs) const;
        IntArray& operator=(const IntArray& rhs);
        int size() const {return (_size);};
        int min() const;
        int max() const;
       
    private:
        int *ia;
        static const int defaultsize;
        int _size;
        void inti(int size,int *array);
};

const int IntArray::defaultsize = 10;//vc++ 6.0 中这个好像只能放在外面???

IntArray::IntArray( int size)
{
        inti(size, 0);
}

IntArray::IntArray(int size, int* array)
{
        inti( size, array);
}

IntArray::IntArray( const IntArray& rhs)
{
        inti(rhs._size, rhs.ia);
}

void IntArray::inti(int size, int* array)
{
        _size = size;
        ia = new int[_size];
        for(int ix=0; ix<_size; ++ix)
          if(!array)
          ia[ix] = 0;
          else
          ia[ix] = array[ix];
             
}

int IntArray::operator[](int index)
{
        assert(index >=0 && index <_size);
        return ia[index];
}

bool IntArray::operator==(const IntArray& rhs) const
{
        bool flag = true;
        for(int ix=0; ix < _size; ++ix)
        {
          if( ia[ix]!= rhs.ia[ix])
          flag = false;
        }
        return flag;
}

bool IntArray::operator!=(const IntArray& rhs) const
{
        bool flag = true;
        for(int ix=0; ix<_size; ++ix)
        {
          if( ia[ix] = =rhs.ia[ix])
          flag = false;
        }
        return flag;
}

IntArray& IntArray::operator=(const IntArray& rhs)
{
        if( this == &rhs)
        return (*this);
        else
        inti(rhs._size, rhs.ia);
        return (*this);
}

int IntArray::min() const
{
        int min = ia[0];
        for(int ix=1; ix<_size; ++ix)
        if( ia[ix] < min )
        min = ia[ix];
        return min;
}

int IntArray::max() const
{
        int max = ia[0];
        for(int ix=1; ix< _size; ++ix)
          if( ia[ix] > max)
          max = ia[ix];
        return max;
}

//IntArray.h end.



//IntArray.cpp


#include <iostream>
#include "IntArray.h"
using namespace std;

int main(int argc, char** argv)
{
  int array[10] = {0,1,2,3,4,5,6,7,8,9};
  IntArray myArray(10,array);
  IntArray array1;
  array1 = myArray;
  array1[4] = 10;//这行通过不了...
  cout<<array1.size()<<endl;
  cout<<(array1!= myArray)<<endl;
  cout<<myArray.max()<<endl;
  cout<<myArray.min()<<endl;
  cout<<array1.min()<<endl;
  cout<<array1[4]<<endl;
  return 0;
}


//IntArray.cpp end.


[ 此贴被ollo在2006-11-19 17:23重新编辑 ]

恩蝈蝈说的对哈,一开始好像是没通过就改了,后来就忘了哈^^^

谢谢哈

还有一个问题

就是
int main(int argc, char** argv)
{
int array[10] = {0,1,2,3,4,5,6,7,8,9};
IntArray myArray(10,array);
IntArray array1;
array1 = myArray;
array1[4] = 22;//这行现在可以通过了...
cout<<array1.size()<<endl;
cout<<(array1!= myArray)<<endl;
cout<<myArray.max()<<endl;
cout<<myArray.min()<<endl;
cout<<array1.min()<<endl;
cout<<array1[4]<<endl;//但是这边打印的值为什么还是4呢?
return 0;
}

Quote:

引用第2楼perfect_刘于2006-11-19 14:29发表的:
将那个重载函数定义为
int &operator [](int index)
返回值为
return *(ia+index);

还有几是return (ia[index]);这句好像不改也通过了
想想好象不改也是对的啊,

ia+index 一地址,再加* 解引用就是值,那直接 ia[index] 也是值啊


[ 此贴被ollo在2006-11-19 15:08重新编辑 ]

Quote:

引用第8楼perfect_刘于2006-11-19 17:09发表的:
还有你程序内存泄露问题大大的有啊~~~！！
你写的这个类真的是一个可怕的类！！！
呵呵

哈哈,大哥 我学c++才几天啊,我也知道有内存泄露,但是你说咱现在还没学到那种境界去考虑也没用啊

恩那个比较那边是偶疏忽了(真是[屏蔽],丢人,汗!)......

谢谢指点哈...

还有那个,,兄弟有时间能不能在上面那个代码上解决内存泄露问题给我看下,学习一下

谢谢了....

Quote:

引用第6楼perfect_刘于2006-11-19 17:03发表的:
全部重新赋值就是4...

初始化是4没错
那我下面加的那句：array1[4] = 22;
怎么没用呢？

Quote:

引用第12楼perfect_刘于2006-11-19 17:38发表的:

有用 ，但是你后面调用 !=时候又对array[4]赋值了嘛！！

我晕…………就是就是，今天晕糊了

恩，谢谢

那那个关于内存泄露的问题，请蝈蝈再指教一下哈

不胜感激

Quote:

引用第14楼perfect_刘于2006-11-19 18:13发表的:
其实就两点，
不用的delete掉，
还有不要两次delete同一块内存！
你要有你自己就是指针的感觉，内存中随你指！！
呵呵

恩说得有道理
那对于我的代码中是不是就是指

Quote:

void IntArray::inti(int size, int* array)
{
    _size = size;
    ia = new int[_size];
    for(int ix=0; ix<_size; ++ix)
      if(!array)
      ia[ix] = 0;
      else
      ia[ix] = array[ix];
       
}

这个函数中的问题呢,但是好像那个析构函数中是用了delete[]ia
了啊,别的还有什么地方有问题吗?

Quote:

引用第16楼perfect_刘于2006-11-19 19:41发表的:
就是 你对ia重新分配一块内存，但是ia以前指向的内存你就没有管了！！
析构函数只是对象销毁时候调用的，此时也没有调用
应该先释放在从新分配

恩刚才也想到了这个,那蝈蝈看下现在行不?
void IntArray::inti(int size, int* array)
{
  _size = size;
  if(ia)
  delete [] ia;
  else
  ia = new int[_size];       //这个 new 析构函数释放了的吧
  for(int ix=0; ix<_size; ++ix)
    if(!array)
    ia[ix] = 0;
    else
    ia[ix] = array[ix];
   
}


[ 此贴被ollo在2006-11-19 20:08重新编辑 ]