Question

在这篇文章中

https://codereview.stackexchange.com/questions/5745/dynamic-array-improvements-0

这是什么意思？对不起，如果问题很模糊..我只需要更新我的print_array函数。完整代码低于...我的穷人的动态数组。

有人可以告诉我overloaed＆lt;＆lt;功能有效吗？

// My Current Print Array
void print_array() 
{ 
    for (int i = 0; i < size; i++) cout << array[i] << endl; 
}

如果你打算写print_array，至少要写它以便它可以使用替代方法流（不仅仅是std :: cout）。然后编写输出运算符。

// SO用户建议

std::ostream& operator<<(std::ostream& stream, dynamic_array const& data)
{
    data.print_array(stream); // After you fix print_array
    return stream;
}

//我的动态数组类

#include "c_arclib.cpp"
template <class T> class dynamic_array
{
private:
    T* array;
    T* scratch;
public:
    int size;

    dynamic_array(int sizein)
    {  
        size=sizein;
        array = new T[size]();
    }

    void print_array()
    {  
        for (int i = 0; i < size; i++) cout << array[i] << endl;
    }

    void merge_recurse(int left, int right)
    {  
        if(right == left + 1)
        {  
            return;
        }
        else
        {  
            int i = 0;
            int length = right - left;
            int midpoint_distance = length/2;
            int l = left, r = left + midpoint_distance;
            merge_recurse(left, left + midpoint_distance);
            merge_recurse(left + midpoint_distance, right);
            for(i = 0; i < length; i++)
            {  
                if((l < (left + midpoint_distance)) && (r == right || array[l] > array[r]))
                {  
                    scratch[i] = array[l];
                    l++;
                }
                else
                {  
                    scratch[i] = array[r];
                    r++;
                }
            }
            for(i = left; i < right; i++)
            {  
                array[i] = scratch[i - left];
            }
        }
    }

    int merge_sort()
    {  
        scratch = new T[size]();
        if(scratch != NULL)
        {  
            merge_recurse(0, size);
            return 1;
        }
        else
        {  
            return 0;
            }
    }

    void quick_recurse(int left, int right)
    {  
        int l = left, r = right, tmp;
        int pivot = array[(left + right) / 2];
        while (l <= r)
        {  
            while (array[l] < pivot)l++;
            while (array[r] > pivot)r--;
            if (l <= r)
            {  
                tmp = array[l];
                array[l] = array[r];
                array[r] = tmp;
                l++;
                r--;
            }
        }
        if (left < r)quick_recurse(left, r);
        if (l < right)quick_recurse(l, right);
    }

    void quick_sort()
    {  
        quick_recurse(0,size);
    }

    void rand_to_array()
    {  
        srand(time(NULL));
        int* k;
        for (k = array; k != array + size; ++k)
        {  
            *k=rand();
        }
    }
};

int main()
{  
    dynamic_array<int> d1(10);
    cout << d1.size;
    d1.print_array();
    d1.rand_to_array();
    d1.print_array();
    d1.merge_sort();
    d1.print_array();
}

〜〜

Answer 1

从您的示例中，每当运营商＆lt;＆lt;在std::ostream& stream和dynamic_array const& data之间匹配编译器将调用：

std::ostream& operator<<(std::ostream& stream, dynamic_array const& data) 
{ 
     data.print_array(stream); // After you fix print_array 
     return stream; 
}

其行为类似于全局运算符。换句话说，呼叫：

dynamic_array<int> d(10);
cout << d;
// above is logically equivalent to:
// operator<<(std::cout, d)

注意运营商＆lt;＆lt;函数返回std::ostream&。那是因为我们希望能够链接操作员调用：

dynamic_array<int> d(10);
cout << "Data:" << d;
// above is logically equivalent to:
// operator<<( operator<<(std::cout, "Data:"), d);

由于您使用模板输出数组，因此输出到的流必须知道如何解释模板类型。在这里的示例中，我们使用整数，并且有一个预定义的运算符：

std::ostream& operator<<(std::ostream& stream, int const& i);

唯一需要改变的想法就像Joshua建议修改你的print_array函数以使用ostream＆amp; amp;而不是预定义的cout。

Answer 2

如果您希望自己的功能能够打印到ostream以外的cout，那么您可以这样做

//i added a default argument of cout, so you don't have to specify
void print_array(std::ostream &os = cout) 
{ 
  for (int i = 0; i < size; i++) 
     os << array[i] << endl; 
}

operator<<()函数可以解释如下：它返回对ostream对象的引用，该对象是cout所属的类。返回引用允许链接。现在，由于operator<<()不是成员函数，因此第一个参数是运算符的左侧，在许多情况下，它将是cout。第二个参数是运算符的右侧。我不认为这是有效的C ++语法，它应该是const dynamic_array &data。

动态阵列打印功能

2 个答案: