Question

我有一个类，它接受一个数组及其大小。在类中我有一个索引运算符“[]”，它已被重载以将其内容传递给类成员函数并返回该函数。它还会检查我是否正在访问数组大小的内容。

     this_type operator[] (int index)  
    {
        assert (index > 0 && index<=len);
        at(index);
        return c_arr()[index];
    }

我为它制作了一个复制构造函数

   //constructor
    my_array(this_type const arr[], int size)
    {
    len = size;
    assert(arr != NULL);
    assert(size >= 0);

    this->arr = new this_type[size];
    for (int i = 0; i < size; i++)
        (*this).arr[i] = arr[i];
    }
    //copy constructor
    my_array( const my_array<this_type>  & arr)
    {
    this->arr = new this_type[sizeof(arr)];
    memcpy(this->arr, arr.arr, sizeof(this_type)*arr.len);
    }
    my_array(int size)
    {
    len = size;
    assert(size >= 0);

    this->arr = new this_type[size];
    }

但是当调用成员函数“len”时，它似乎没有传入数组大小值。有什么想法吗？

    #include <iostream>
    #include <cassert>
    #include <assert.h>
    using namespace std;

    template <class this_type> 
    class my_array
    {
    private:
    this_type *arr;
    int len;

    int sum()
    {
        int sum;
        for (int i = 0; i < len; i++)
            sum += arr[i];
    }

    public:


    int size() const
    {
    return len;
    }

    this_type &at(int index)
    {
    assert( index >= 0 && index < len);
    return arr[index];
    }

    my_array(this_type const arr[], int size)
    {
    len = size;
    assert(arr != NULL);
    assert(size >= 0);

    this->arr = new this_type[size];
    for (int i = 0; i < size; i++)
        (*this).arr[i] = arr[i];
    }
    my_array( const my_array<this_type>  & arr)
    {
    this->arr = new this_type[sizeof(arr)];
    memcpy(this->arr, arr.arr, sizeof(this_type)*arr.len);
    }
    my_array(int size)
    {
    len = size;
    assert(size >= 0);

    this->arr = new this_type[size];
    }
    ~my_array()
    {
    delete[] arr;
    }

    this_type* c_arr()
    {
        return arr;
    }

     this_type & operator[] (int index)
        {
        assert (index > 0 && index<=len);
         at(index);
         return c_arr()[index];
    }

     this_type operator[] (int index)  
    {
        assert (index > 0 && index<=len);
        at(index);
        return c_arr()[index];
    }
    friend istream & operator>>(istream &lhs, my_array<this_type> &rhs);

    friend ostream & operator<<(ostream &lhs, my_array<this_type> &rhs);
    };
    template <class this_type> 
    ostream & operator<<(ostream &lhs, my_array<this_type>&rhs)
    {
    for ( int i = 0; i < rhs.size(); i++)
        lhs << rhs.arr[i] << endl;
    return lhs;
    }
    template <class this_type> 
    istream & operator>>(istream &lhs, my_array<this_type> &rhs)
    {
    for ( int i = 0; i < rhs.size(); i++)
        lhs >> rhs.arr[i];
    return lhs;
    }




    int main()
    {
    char arra[5]={'c','o','d','e','s'};

    my_array<char> arr(arra,5), arr1(5), arr2(arr);
       for(int t=0;t< 9;t++)
      {
       //use the operator that is attached to the class instance
        cout << arr2[t];

   }
    for(int t=0;t< 9;t++)
    {
    cout<<arr2.c_arr()[t];
    }
    return 0;
    }

Answer 1

this->arr = new this_type[sizeof(arr)];

复制构造函数中的这一行不正确。 arr是my_array班级的对象。 sizeof(arr)是编译时常量，完全独立于为数组分配的元素数。这些元素甚至不包含在课堂上。它们位于免费商店，而类中则包含指向它们的指针。你想要的是这个：

this->arr = new this_type[arr.len];

您还希望分配给正在构建的对象的len成员。

this->len = arr.len;

我不得不说，除非您是为了学习目的而创建此课程，否则只需使用std::vector。

复制构造函数不从类对象中获取数组大小

1 个答案: