Failed With Overloading the Insertion Operator

Question

I am not sure what I am doing wrong here but I used Google and found almost the identical code to mine but they did not claim an error. Our assignment is to overload the insertion operator. The problem is that I get an error in the driver for every time I pass SAM or JOE. The error states: Error 2 error C2679: binary '<<' : no operator found which takes a right-hand operand of type 'MyVector' (or there is no acceptable conversion). Any help is appreciated. Please note that I have not completed this assignment and if another function doesn't seem right, it may be because I haven't work on it. Thanks in advance.

Driver.cpp

#include <iostream>
#include "MyVector.h"     
using namespace std;

// the printV function
// used to test the copy constructor
// parameter: a MyVector object
void printV(MyVector);

int main()
{
    cout << "\nCreating a vector Sam of size 4.";
    MyVector sam(4);

    cout << "\nPush 12 values into the vector.";
    for (int i = 0; i < 12; i++)
        sam.push_back(i);

    cout << "\nHere is sam: ";
    cout << sam;
    cout << "\n---------------\n";

    cout << "\nCreating a vector Joe of size 4.";
    MyVector joe(4);
    cout << "\nPush 6 values into the vector.";
    for (int i = 0; i < 6; i++)
        joe.push_back(i * 3);

    cout << "\nHere is joe: ";
    cout << joe;
    cout << "\n---------------\n";

    cout << "\nTest the overloaded assignment operator \"joe = sam\": ";
    joe = sam;

    cout << "\nHere is sam: ";
    cout << sam;
    cout << "\n---------------\n";

    cout << "\nHere is joe: ";
    cout << joe;
    cout << "\n---------------\n";

    // pass a copy of sam by value
    printV(sam);


    cout << endl;
    system("PAUSE");
    return 0;
}

void printV(MyVector v)
{
    cout << "\n--------------------\n";
    cout << "Printing a copy of a vector\n";
    cout << v;
}

My Vector.h

#pragma once

class MyVector
{
private:
    int vSize;
    int vCapacity;
    int* vArray;
    void grow();

public:
    MyVector();
    MyVector(int n);
    MyVector(const MyVector& b);
    int size() const;
    int capacity() const;
    void clear();
    void push_back(int n);
    int& at(int n) const;
    MyVector& operator=(const MyVector& rho);
    ~MyVector();
};

MyVector.cpp

#include "MyVector.h"
#include <iostream>
using namespace std;


MyVector::MyVector()
{
    vArray = nullptr;
    vSize = 0;
    vCapacity = 0;
}

MyVector::MyVector(int n)
{
    vArray = new int[vCapacity];
    vSize = 0;
    vCapacity = n;
}

MyVector::MyVector(const MyVector& b)
{
    vSize = b.size();
    vArray = new int[vSize];
    for (int i = 0; i < b.size(); i++)
    {
        this->vArray[i] = b.vArray[i];
    }
}

int MyVector::size() const
{
    return vSize;
}

int MyVector::capacity() const
{
    return vCapacity;
}

void MyVector::clear(void)
{
    if (vArray != nullptr)
    {
        delete[] vArray;
        vArray = nullptr;
        vSize = 0;
        vCapacity = 0;
    }
}

void MyVector::push_back(int n)
{
    if (vCapacity == 0)
    {
        vCapacity++;
        int* tmp = new int[vCapacity];
        delete[] vArray;
        vArray = tmp;
    }

    if (vSize >= vCapacity)
    {
        grow();
    }
    vArray[vSize] = n;
    vSize++;
}

void MyVector::grow()
{
    vCapacity = vCapacity + vCapacity;
    int* tmp = new int[vCapacity];
    for (int i = 0; i < vSize; i++)
    {
        tmp[i] = vArray[i];
    }
    delete[] vArray;
    vArray = tmp;
}

int& MyVector::at(int index) const
{
    if (index >= 0 && index<vSize)
    {
        return vArray[index];
    }
    else
    {
        throw index;
    }
}

MyVector& MyVector::operator=(const MyVector& rho)
{
    // test for self assignment
    if (this == &rho)
        return *this;

    // clean up array in left hand object (this)
    delete[] this->vArray;

    // create a new array big enough to hold right hand object's data
    vSize = rho.size();
    this->vArray = new int[vSize];

    // copy the data
    for (int i = 0; i < rho.size(); i++)
    {
        this->vArray[i] = rho.vArray[i];
    }

    // return this object
    return *this;
}

MyVector::~MyVector()
{
    if (vArray != nullptr)
    {
        clear();
    }
}

ostream& operator<<(ostream& out, const MyVector& rho)
{
    for (int i = 0; i < rho.size(); i++)
    {
        out << rho.at(i);
    }
    return out;
}

Answer 1

Declare std::ostream& operator<<(std::ostream& out, const MyVector& rho) in My Vector.h. That function is used in Driver.cpp, therefore Driver.cpp must know about it.

If you do this, you should also #include <ostream> in My Vector.h.