数组类模板

最新推荐文章于 2025-04-25 00:01:36 发布

Martin Luther King, Jr

最新推荐文章于 2025-04-25 00:01:36 发布

阅读量93

点赞数

文章标签： c++

本文链接：https://blog.youkuaiyun.com/weixin_70746119/article/details/129663455

版权

文章介绍了C++中的模板类Data，包括其成员函数如构造函数、拷贝构造函数、析构函数以及putste和sort方法。特别强调了内存管理的重要性，特别是避免内存泄漏和正确使用拷贝构造。同时，提到了友元函数operator<<的重载，并展示了如何处理类Person的比较操作。在main函数中，创建Data实例并进行排序展示。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

重点和易错点都在注释

template<class T>
class Data
{
    template<class T>
    friend ostream& operator<<(ostream& cout, Data<T>ob);
private:
    T* p;
    int size;
    int capcity;
public:
    Data()
    {
        size = 0;
        capcity = 5;//一定得写capcity的初始化
        p = new T[capcity];
    }
    Data(int capcity)
    {
        this->capcity = capcity;
        p = new T[capcity];
        memset(p, 0, sizeof(T) * capcity);
    }
    Data(const Data<T>& ob)
    {
        capcity =ob.capcity;
        size = ob.size;
        p = new T[capcity];
        memset(p, 0, sizeof(T) * ob.capcity);
        memcpy(p, ob.p, sizeof(T) * ob.capcity);
    }
    ~Data()
    {
        if (p != NULL)
        {
            delete[]p;
            p = NULL;//如果在构造函数中么有初始化capcity的话这会报错，
            //主要原因还是在有参构造的时候开辟空间问题
        }
    }
    void putste(T ele)
    {
        if (size == capcity)
        {
            int cap = capcity;
            capcity = 2 * capcity;
            T* temp = new T[capcity];
            memset(temp, 0, sizeof(T) * capcity);
            memcpy(temp, p, sizeof(T) * cap);
            delete[]p;
            p = NULL;
            p = temp;
        }
        p[size] = ele;
        size++;
    }
    void sort()
    {
        int i = 0; int j = 0;
        int k;
        for (i = 0; i < size; i++)
        {
            k = i;
            for (j = i + 1; j < size; j++)
            {
                if (p[k] > p[j])
                {
                    k = j;
                }
            }
            if (k != i)
            {
                T temp;
                temp = p[i];
                p[i] = p[k];
                p[k] = temp;
            }
        }
    }
    Data<T>& operator=(Data<T>& ob)
    {

    }
};
class Person
{
    friend ostream& operator<<(ostream& cout, Person person);
private:
    int c;
public:
    Person()
    {
        c = 0;
    }
    Person(int c)
    {
        this->c = c;
    }
    bool operator>(Person &per)const//之前一直纠结bool类型的问题，现在突然想开
        //它是判断这个式子是否成立if (p[k] > p[j])if成立则进入if循环
    {
        return (c > per.c);
    }
};
template<class T>
ostream& operator<<(ostream& cout, Data<T>ob)//对于这个运算符重载
//我表示无语，老师说最好别用引用但是这不用引用又不行,我现在收回这句话
//主要原因是我没写拷贝构造，这里又指针变量，默认是浅拷贝，造成内存泄漏
//当我重新写了拷贝构造运算符重载<<传递了非引用也是ok的
//主要原因还是没有用引用的时候它会开辟空间；
{
    int i;
    for (i = 0; i <ob.size; i++)
    {
        cout << ob.p[i] << "  ";//在这还需要重载运算符，ob.p[i]这是Person类它不识别
    }
    return cout;
}
ostream& operator<<(ostream& cout, Person person)
{
    cout << person.c;
    return cout;
}
int main()
{
    Data<Person>ob;
    ob.putste(Person(1));
    ob.putste(Person(3));
    ob.putste(Person(2));
    ob.putste(Person(7));
    ob.putste(Person(6));
    ob.sort();
    cout << ob << endl;;
    return 0;
}

//这张图片是没写拷贝构造时报错，主要错误还是内存的泄漏导致

//x