算法学习日记

看来还是功底不行，编程的时候遇到了如下麻烦

（1）在写拷贝构造函数的时候，有个疑问：拷贝构造函数的参数是直接使用当前类的私有成员，这样可以吗？查书之后理解了，类的私有成员是针对其他调用这个类的代码所定义的，同一个类的不同对象之间可以互相调用私有成员.

（2）写1维数组类的时候有如下问题，见源码的注释

#include<iostream>

using namespace std;

class BadInitliazer
{
public:
    BadInitliazer();
};

class OutOfBonds
{
public:
    OutOfBonds();
};

template<class T>
class Array1D
{
public:
    ArrayID(int sz,int *a);   //构造函数，默认参数为0
    ArrayID(const Array1D<T> &x);  //赋值构造函数
    ~Array1D{delete [] element};
    T& operator[](int i)const;
    int Size(){return size};
    Array1D<T>& operator=(const Array1D<T> &v);      //注意返回值类型，像赋值这种改变当前对象的就用引用类型。像重载加法之类的就返回自定义的对象类型就可以了。
    //Array1D<T> operator+()const;
    Array1D<T> operator+(const Array1D<T> &v)const; //重载运算符，特别是类里面的，如果返回值是引用类型，都是返回*this（可能算是个技巧）
    Array1D<T> operator-()const;
    Array1D<T> operator-(const Array1D<T> &v)const;
//Array1D<T> operator*(const Array1D<T> &v)const;
    Array1D<T>& operator+=(const T& x);
private:
    int size_1;
    T *element;
};

template<class T>                //构造函数
Array1D<T>::Array1D(int sz,T *a)
{
    if(sz<1)
        throw BadInitliazer();
    else
    {
        size_1=sz;
        element=new T [sz];
        for(int i=0;i<size_1;i++)
        {
            element[i]=a[i];
        }
    }
}


template<class T>                 //拷贝构造函数
Array1D<T>::Array1D(const Array1D<T> &x)
{
    int i=0;
    size_1=x.size_1;
    element=new T [size_1];
    for(i=0;i<size_1;i++)
    {
        element[i]=x.element[i];
    }
}


template<class T>
T& Array1D<T>::operator[](int i) const
{
    if(i<0 || i>size_1)
    {
        throw OutOfBonds();
    }
    else
    {
        return element[i];
    }
}


template<class T>
Array1D<T>& Array1D<T>::operator=(const Array1D<T> &v)
{
    int i=0;
    if(*thils!=v)
    {
        size_1=v.size_1;
        delete [] element;
        element=new T[size_1];
        for(i=0;i<sie_1;i++)
        {
            element[i]=v.element[i];
        }
    }
    return *this;
}


template<class T>
Array1D<T> Array1D<T>::operator+(const Array1D<T>& v) const
{
    if(size_1!=v.size_1())
        throw SizeUnMatch();
    Array1D<T> w(size_1);
    else
    {
       for(i=0;i<size_1;i++)
       {
           w.element[i]=element[i]+v.element[i];
       }
       return w;
    }

}

template<class T>
Array1D<T> Array1D<T>::operator-(const Array1D<T>& v) const
{
    if(size_1!=v.size_1())
        throw SizeUnMatch();
    Array1D<T> w(size_1);
    else
    {
       for(i=0;i<size_1;i++)
       {
           w.element[i]=element[i]-v.element[i];
       }
       return w;
    }
}

template<class T>
Array1D<T> Array1D<T>::operator-()
{
    Array1D<T> w(size_1);
    else
    {
       for(i=0;i<size_1;i++)
       {
           w.element[i]=-element[i];
       }
       return w;
    }
}

template<class T>
Array1D<T>& Array1D<T>::operator+=(const T&x)
{
    int i=0;
    for(i=0;i<size_t;i++)
    {
        element[i]+=x;
    }
    return *this;
}




int main()
{
    int a[3]={1,2,3};
    Array1D<int> array_1(3,a);

}