0

In this post

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

What does this mean? Sorry if the question is vague..I just need to update my print_array function. Full code is below..for my poor man's dynamic array.

Can someone tell me how the overloaed << function works?

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

If you are going to write print_array at least write it so that it can use alternative stream (not just std::cout). Then write the output operator.

// SO user advice

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

// My Dynamic Array Class

#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();
}

~ ~

Improve this question
1
  • It's not clear what your question is. Are you asking about operator<<? Commented Nov 2, 2011 at 3:16

2 Answers 2

Reset to default
1

From your example, whenever operator << is matched between std::ostream& stream and dynamic_array const& data compiler will invoke:

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

which behaves like a global operator. In other words, calling:

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

Note that the operator<< function returns std::ostream&. That is because we want to be able to chain operator calls:

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

Since you are using templates to output your array, the stream you are outputing to must know how to interpret the template type. In the example here we are using integers, and there is a predefined operator for that:

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

The only think left to change is like Joshua suggested to modify your print_array function to use ostream& rather than predefined cout.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Once you modify print_array to accept std::ostream& stream as an argument and output to it instead of std::cout yes.
std::cout is a predefined global instance of a particular std::ostream similarly std::cin is a predefined global instance of a particular std::istream. Simply passing std::cout to your print_array is enough to output data to the screen/console, but you could also output it to a file using the same function, over a network if necessary etc. any std::ostream.
0

If you want your function to be able to print to ostreams other than cout, you would do it like this

//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; 
}

The operator<<() function can be explained as follows: it returns a reference to an ostream object, which is the class that cout is a part of. Returning a reference allows for chaining. Now, since operator<<() is not a member function, the first argument is the left side of the operator, in many cases, it would be cout. The second argument is the right side of the operator. And I don't think that is valid C++ syntax, it should be const dynamic_array &data.

Improve this answer

3 Comments

why would I want this? Someone is telling me to to this on code reveiw? Why does your fuction look different from theirs...can you elaborate?
where do I put these functions?
print_array() is fine where it's at in the class declaration. The overloaded operator would be declared outside of the class declaration.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.